summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorAlex AUVOLAT <alex.auvolat@ens.fr>2014-03-28 17:16:09 +0100
committerAlex AUVOLAT <alex.auvolat@ens.fr>2014-03-28 17:16:09 +0100
commitacb5161d7384e6b6352c0a9f3cc067621fbf28ad (patch)
tree6b66a66927e98b84d53f97da411b58c1b7ad3c53
parenta8968330aff45e0b8cf278f49fa337d5fcb9bfd8 (diff)
downloadSOS-acb5161d7384e6b6352c0a9f3cc067621fbf28ad.tar.gz
SOS-acb5161d7384e6b6352c0a9f3cc067621fbf28ad.zip
Import and compile article 6.75HEADmaster
-rw-r--r--sos-code-article6.75/INSTALL118
-rw-r--r--sos-code-article6.75/LICENSE340
-rw-r--r--sos-code-article6.75/Makefile83
-rw-r--r--sos-code-article6.75/README90
-rw-r--r--sos-code-article6.75/VERSION13
-rw-r--r--sos-code-article6.75/bootstrap/multiboot.S85
-rw-r--r--sos-code-article6.75/bootstrap/multiboot.h133
-rw-r--r--sos-code-article6.75/cdrom/boot/grub/stage2_eltoritobin0 -> 147440 bytes
-rw-r--r--sos-code-article6.75/drivers/bochs.c123
-rw-r--r--sos-code-article6.75/drivers/bochs.h55
-rw-r--r--sos-code-article6.75/drivers/x86_videomem.c127
-rw-r--r--sos-code-article6.75/drivers/x86_videomem.h97
-rw-r--r--sos-code-article6.75/extra/Makefile40
-rw-r--r--sos-code-article6.75/extra/README73
-rw-r--r--sos-code-article6.75/extra/bootsect.S406
-rw-r--r--sos-code-article6.75/extra/dot.mkvars29
-rw-r--r--sos-code-article6.75/extra/grub.img.gzbin0 -> 67535 bytes
-rw-r--r--sos-code-article6.75/extra/mtoolsrc2
-rw-r--r--sos-code-article6.75/extra/qemu-port-e9.diff73
-rw-r--r--sos-code-article6.75/extra/sos_bsect.lds61
-rw-r--r--sos-code-article6.75/hwcore/cpu_context.c407
-rw-r--r--sos-code-article6.75/hwcore/cpu_context.h270
-rw-r--r--sos-code-article6.75/hwcore/cpu_context_switch.S128
-rw-r--r--sos-code-article6.75/hwcore/exception.c167
-rw-r--r--sos-code-article6.75/hwcore/exception.h83
-rw-r--r--sos-code-article6.75/hwcore/exception_wrappers.S221
-rw-r--r--sos-code-article6.75/hwcore/gdt.c152
-rw-r--r--sos-code-article6.75/hwcore/gdt.h42
-rw-r--r--sos-code-article6.75/hwcore/i8254.c79
-rw-r--r--sos-code-article6.75/hwcore/i8254.h35
-rw-r--r--sos-code-article6.75/hwcore/i8259.c79
-rw-r--r--sos-code-article6.75/hwcore/i8259.h40
-rw-r--r--sos-code-article6.75/hwcore/idt.c159
-rw-r--r--sos-code-article6.75/hwcore/idt.h84
-rw-r--r--sos-code-article6.75/hwcore/ioports.h46
-rw-r--r--sos-code-article6.75/hwcore/irq.c100
-rw-r--r--sos-code-article6.75/hwcore/irq.h97
-rw-r--r--sos-code-article6.75/hwcore/irq_wrappers.S220
-rw-r--r--sos-code-article6.75/hwcore/paging.c465
-rw-r--r--sos-code-article6.75/hwcore/paging.h132
-rw-r--r--sos-code-article6.75/hwcore/segment.h70
-rw-r--r--sos-code-article6.75/sos.map329
-rw-r--r--sos-code-article6.75/sos/assert.c44
-rw-r--r--sos-code-article6.75/sos/assert.h45
-rw-r--r--sos-code-article6.75/sos/errno.h42
-rw-r--r--sos-code-article6.75/sos/klibc.c308
-rw-r--r--sos-code-article6.75/sos/klibc.h103
-rw-r--r--sos-code-article6.75/sos/kmalloc.c113
-rw-r--r--sos-code-article6.75/sos/kmalloc.h63
-rw-r--r--sos-code-article6.75/sos/kmem_slab.c812
-rw-r--r--sos-code-article6.75/sos/kmem_slab.h206
-rw-r--r--sos-code-article6.75/sos/kmem_vmm.c606
-rw-r--r--sos-code-article6.75/sos/kmem_vmm.h113
-rw-r--r--sos-code-article6.75/sos/ksynch.c235
-rw-r--r--sos-code-article6.75/sos/ksynch.h172
-rw-r--r--sos-code-article6.75/sos/kwaitq.c321
-rw-r--r--sos-code-article6.75/sos/kwaitq.h216
-rw-r--r--sos-code-article6.75/sos/list.h186
-rw-r--r--sos-code-article6.75/sos/macros.h41
-rw-r--r--sos-code-article6.75/sos/main.c462
-rw-r--r--sos-code-article6.75/sos/mouse_sim.c805
-rw-r--r--sos-code-article6.75/sos/physmem.c319
-rw-r--r--sos-code-article6.75/sos/physmem.h147
-rw-r--r--sos-code-article6.75/sos/sched.c208
-rw-r--r--sos-code-article6.75/sos/sched.h141
-rw-r--r--sos-code-article6.75/sos/thread.c513
-rw-r--r--sos-code-article6.75/sos/thread.h228
-rw-r--r--sos-code-article6.75/sos/time.c355
-rw-r--r--sos-code-article6.75/sos/time.h222
-rw-r--r--sos-code-article6.75/sos/types.h52
-rwxr-xr-xsos-code-article6.75/support/build_image.sh215
-rw-r--r--sos-code-article6.75/support/sos.lds115
-rw-r--r--sos-code-article6.75/userland/Makefile82
-rw-r--r--sos-code-article6.75/userland/ldscript.lds74
74 files changed, 12917 insertions, 0 deletions
diff --git a/sos-code-article6.75/INSTALL b/sos-code-article6.75/INSTALL
new file mode 100644
index 0000000..7c7d619
--- /dev/null
+++ b/sos-code-article6.75/INSTALL
@@ -0,0 +1,118 @@
+
+ SOS: A Simple Operating System
+
+ Compilation/Installation/Test instructions
+
+
+Compilation
+===========
+
+IMPORTANT
+---------
+
+Don't forget to run 'make clean' before 'make' after you have modified
+any source or header file(s).
+
+
+On a x86 host where grub is correctly installed
+-----------------------------------------------
+
+Simply run 'make'
+
+
+On a non-x86 host (without grub of course !)
+--------------------------------------------
+
+See extra/README
+
+
+On an x86 host without Grub, or with a buggy Grub
+-------------------------------------------------
+
+See extra/README
+
+How do I know I have a buggy grub installation ? Answer: in the qemu
+PC emulator, Grub hangs while loading the kernel
+
+
+Installation
+============
+
+Nothing special to do besides compiling
+
+
+Test the SOS Kernel
+===================
+
+On a x86 real machine with Grub installed
+-----------------------------------------
+
+ 1st method
+ => Boot the sos.elf file (append 'kernel=<path_to>sos.elf' in the
+ menu.lst or type it on Grub's command line) from a hard disk, a
+ floppy, or from the network
+
+ 2nd method
+ => Copy the file 'fd.img' to a floppy and boot from it
+
+
+On a x86 real machine without Grub installed
+--------------------------------------------
+
+ 1st method
+ => see extra/README to compile with the grub floppy image we provide,
+ copy the file 'fd.img' to a floppy, and boot from it
+
+ 2nd method
+ => see extra/README to compile with the boot sector we provide (up to
+ article 2 only), copy the file 'extra/sos_bsect.img' to a floppy,
+ and boot from it
+
+
+Inside a PC emulator (x86 and non-x86 hosts)
+--------------------------------------------
+
+Tested on both the bochs emulator (x86/linux, sparc/solaris and
+ppc/linux hosts, 'apt-get install bochs-x vgabios' on debian
+testing/unstable), and the qemu system emulator (with libsdl
+installed: 'apt-get install libsdl1.2-dev' on debian
+testing/unstable).
+
+ 1/ Grub is installed on the host (x86 hosts only)
+ - - - - - - - - - - - - - - - - - - - - - - - - -
+
+ bochs: boot from the file 'fd.img'. Example of a ~/.bochsrc:
+ floppya: 1_44=/home/d2/sos/fd.img, status=inserted
+ romimage: file=/usr/share/bochs/BIOS-bochs-latest, address=0xf0000
+ vgaromimage: /usr/share/vgabios/vgabios.bin
+ megs:63 # 63 Mo de RAM
+
+ qemu: run 'qemu -fda fd.img'
+ If grub hangs while loading the kernel, please go to method 2/
+
+ 2/ Grub is not installed (all hosts)
+ - - - - - - - - - - - - - - - - - -
+
+ See extra/README to generate a floppy image with the Grub floppy
+ image we provide, and:
+
+ bochs: boot from the file 'fd.img'
+
+ qemu: run 'qemu -fda fd.img'
+
+ 3/ Bonus: boot with the bootsector we provide (all hosts, up to art. 2 ONLY !)
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+ See extra/README to generate a floppy image with the boot sector we
+ provide, and:
+
+ bochs: boot from the file 'extra/sos_bsect.img'
+
+ qemu: run 'qemu -fda extra/sos_qemu.img'
+
+ NOTE: After article 2, this way of booting is not supported: please
+ use the method 2/ above.
+
+
+--
+David Decotigny
diff --git a/sos-code-article6.75/LICENSE b/sos-code-article6.75/LICENSE
new file mode 100644
index 0000000..60549be
--- /dev/null
+++ b/sos-code-article6.75/LICENSE
@@ -0,0 +1,340 @@
+ GNU GENERAL PUBLIC LICENSE
+ Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+ 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+ Preamble
+
+ The licenses for most software are designed to take away your
+freedom to share and change it. By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users. This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it. (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.) You can apply it to
+your programs, too.
+
+ When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+ To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+ For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have. You must make sure that they, too, receive or can get the
+source code. And you must show them these terms so they know their
+rights.
+
+ We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+ Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software. If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+ Finally, any free program is threatened constantly by software
+patents. We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary. To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+ The precise terms and conditions for copying, distribution and
+modification follow.
+
+ GNU GENERAL PUBLIC LICENSE
+ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License. The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language. (Hereinafter, translation is included without limitation in
+the term "modification".) Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope. The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+ 1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+ 2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+ a) You must cause the modified files to carry prominent notices
+ stating that you changed the files and the date of any change.
+
+ b) You must cause any work that you distribute or publish, that in
+ whole or in part contains or is derived from the Program or any
+ part thereof, to be licensed as a whole at no charge to all third
+ parties under the terms of this License.
+
+ c) If the modified program normally reads commands interactively
+ when run, you must cause it, when started running for such
+ interactive use in the most ordinary way, to print or display an
+ announcement including an appropriate copyright notice and a
+ notice that there is no warranty (or else, saying that you provide
+ a warranty) and that users may redistribute the program under
+ these conditions, and telling the user how to view a copy of this
+ License. (Exception: if the Program itself is interactive but
+ does not normally print such an announcement, your work based on
+ the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole. If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works. But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+ 3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+ a) Accompany it with the complete corresponding machine-readable
+ source code, which must be distributed under the terms of Sections
+ 1 and 2 above on a medium customarily used for software interchange; or,
+
+ b) Accompany it with a written offer, valid for at least three
+ years, to give any third party, for a charge no more than your
+ cost of physically performing source distribution, a complete
+ machine-readable copy of the corresponding source code, to be
+ distributed under the terms of Sections 1 and 2 above on a medium
+ customarily used for software interchange; or,
+
+ c) Accompany it with the information you received as to the offer
+ to distribute corresponding source code. (This alternative is
+ allowed only for noncommercial distribution and only if you
+ received the program in object code or executable form with such
+ an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it. For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable. However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+ 4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License. Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+ 5. You are not required to accept this License, since you have not
+signed it. However, nothing else grants you permission to modify or
+distribute the Program or its derivative works. These actions are
+prohibited by law if you do not accept this License. Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+ 6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions. You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+ 7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all. For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices. Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+ 8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded. In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+ 9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time. Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation. If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+ 10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission. For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this. Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+ NO WARRANTY
+
+ 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+ 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+ END OF TERMS AND CONDITIONS
+
+ How to Apply These Terms to Your New Programs
+
+ If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+ To do so, attach the following notices to the program. It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+ <one line to give the program's name and a brief idea of what it does.>
+ Copyright (C) 19yy <name of author>
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+ Gnomovision version 69, Copyright (C) 19yy name of author
+ Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+ This is free software, and you are welcome to redistribute it
+ under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License. Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary. Here is a sample; alter the names:
+
+ Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+ `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+ <signature of Ty Coon>, 1 April 1989
+ Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs. If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library. If this is what you want to do, use the GNU Library General
+Public License instead of this License.
diff --git a/sos-code-article6.75/Makefile b/sos-code-article6.75/Makefile
new file mode 100644
index 0000000..926f30b
--- /dev/null
+++ b/sos-code-article6.75/Makefile
@@ -0,0 +1,83 @@
+## Copyright (C) 2004,2005 The SOS Team
+##
+## This program is free software; you can redistribute it and/or
+## modify it under the terms of the GNU General Public License
+## as published by the Free Software Foundation; either version 2
+## of the License, or (at your option) any later version.
+##
+## This program is distributed in the hope that it will be useful,
+## but WITHOUT ANY WARRANTY; without even the implied warranty of
+## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+## GNU General Public License for more details.
+##
+## You should have received a copy of the GNU General Public License
+## along with this program; if not, write to the Free Software
+## Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+## USA.
+
+CC=i586-elf-gcc
+LD=i586-elf-ld
+CFLAGS = -Wall -nostdinc -ffreestanding -DKERNEL_SOS
+LDFLAGS = --warn-common -nostdlib
+OBJECTS = bootstrap/multiboot.o \
+ hwcore/idt.o hwcore/gdt.o \
+ hwcore/exception.o hwcore/exception_wrappers.o \
+ hwcore/irq.o hwcore/irq_wrappers.o hwcore/i8259.o \
+ hwcore/paging.o \
+ hwcore/i8254.o drivers/x86_videomem.o drivers/bochs.o \
+ hwcore/cpu_context.o hwcore/cpu_context_switch.o \
+ sos/kmem_vmm.o sos/kmem_slab.o sos/kmalloc.o \
+ sos/physmem.o sos/klibc.o \
+ sos/thread.o sos/kwaitq.o \
+ sos/time.o sos/sched.o sos/ksynch.o \
+ sos/assert.o sos/main.o sos/mouse_sim.o
+
+KERNEL_OBJ = sos.elf
+MULTIBOOT_IMAGE = sos.iso
+PWD := $(shell pwd)
+
+# Main target
+all: $(MULTIBOOT_IMAGE)
+
+$(MULTIBOOT_IMAGE): $(KERNEL_OBJ)
+ # ./support/build_image.sh $@ $<
+ if [ ! -e cdrom/boot/grub/stage2_eltorito ]; then \
+ mkdir -p cdrom/boot/grub; \
+ echo "Please copy grub's stage2_eltorito to cdrom/boot/grub."; \
+ exit -1; \
+ fi
+ cp $(KERNEL_OBJ) cdrom
+ echo timeout 0 > cdrom/boot/grub/menu.lst
+ echo title Simple OS >> cdrom/boot/grub/menu.lst
+ echo kernel /$(KERNEL_OBJ) >> cdrom/boot/grub/menu.lst
+ genisoimage -R -b boot/grub/stage2_eltorito -no-emul-boot -boot-load-size 4 \
+ -boot-info-table -input-charset ascii -A SOS -o $(MULTIBOOT_IMAGE) cdrom
+
+$(KERNEL_OBJ): $(OBJECTS) ./support/sos.lds
+ $(LD) $(LDFLAGS) -T ./support/sos.lds -o $@ $(OBJECTS)
+ -nm -C $@ | cut -d ' ' -f 1,3 > sos.map
+ size $@
+
+-include .mkvars
+
+# Create objects from C source code
+%.o: %.c
+ $(CC) -I$(PWD) -c $< $(CFLAGS) -o $@
+
+# Create objects from assembler (.S) source code
+%.o: %.S
+ $(CC) -I$(PWD) -c $< $(CFLAGS) -DASM_SOURCE=1 -o $@
+
+FORCE:
+ @
+
+# Clean directory
+clean:
+ $(RM) *.iso *.o mtoolsrc *~ menu.txt *.img *.elf *.bin *.map
+ $(RM) *.log *.out bochs*
+ $(RM) bootstrap/*.o bootstrap/*~
+ $(RM) drivers/*.o drivers/*~
+ $(RM) hwcore/*.o hwcore/*~
+ $(RM) sos/*.o sos/*~
+ $(RM) support/*~
+ $(RM) extra/*~
diff --git a/sos-code-article6.75/README b/sos-code-article6.75/README
new file mode 100644
index 0000000..efbbc89
--- /dev/null
+++ b/sos-code-article6.75/README
@@ -0,0 +1,90 @@
+
+ SOS: A Simple Operating System
+
+
+This is SOS, a Simple Operating System for i386-family
+processors. This is as simple as possible to show a way to program a
+basic Operating System on real common hardware (PC). The code should
+be easily readable and understandable thanks to frequent comments, and
+references to external documentation. We chose to implement the basic
+features of an OS, thus making design decisions targetting towards
+simplicity of understanding, covering most of the OS classical
+concepts, but not aiming at proposing yet another full-fledged
+competitive OS (Linux is quite good at it). However, for those who
+would like to propose some enhancements, we are open to any code
+suggestions (patches only, please). And yes, there might be bugs in
+the code, so please send us any bug report, and/or patches !
+
+The OS comes as a set of articles (in french) to be published in the
+journal "Linux Magazine France". Each month, the part of the code
+related to the current article's theme is released (see VERSION file),
+and the resulting OS can be successfully compiled and run, by booting
+it from a floppy on a real machine (tested AMD k7, Cyrix and Intel P4
+pentiums), or through an x86 emulator (bochs or qemu). The resulting
+OS is available as a multiboot compliant ELF kernel (sos.elf) and as a
+floppy image (fd.img). It provides a very very very basic demo whose
+aim is to understand how everything works, not to animate sprites on
+the screen with 5:1 dolby sound.
+
+The initial technical features and lack-of-features of the OS are:
+ - monolithic kernel, fully interruptible, non-preemptible (big kernel
+ lock), target machines = i386 PC or better
+ - compiles on any host where the gcc/binutils toolchain (target
+ i586-gnu) is available. Can be tested on real i486/pentium
+ hardware, or on any host that can run an i486/pentium PC emulator
+ (bochs or qemu)
+ - kernel loaded by grub, or by a sample bootsector (up to article 2
+ ONLY)
+ - clear separation of physical memory and virtual memory concepts,
+ even inside the kernel: no identity-mapping of the physical memory
+ inside the kernel (allows to move virtual mappings of kernel pages
+ at run-time, eg to free ISA DMA pages, and to avercome the 4G RAM
+ barrier)
+ - slab-type kernel memory allocation
+ - no swap, no reverse mapping
+ - VERY simple drivers: keyboard, x86 video memory, IDE disks
+ - logical devices: partitions, FAT filesystem, "hard-coded"
+ mountpoints only (~ MSDOS)
+ - no network stack
+ - user-level features: ELF loader (no shared libraries), processes,
+ user threads (kernel-level scheduling only), mmap API, basic VFS
+
+To understand where to look at for what, here is a brief description:
+ - Makefile: the (ONLY) makefile of the OS. Targets are basically
+ 'all' and 'clean'
+ - bootstrap/ directory: code to load the kernel. Both the stuff
+ needed for a multiboot-compliant loader (eg grub) AND a bootsector
+ are provided. The bootsector may only be used up to article 2.
+ - sos/ directory: the entry routine for the kernel (main.c), various
+ systemwide header files, a set of common useful C routines
+ ("nano-klibc"), and kernel subsystems (kernel memory management,
+ etc...)
+ - hwcore/ directory: Low-level CPU- and kernel-related routines
+ (interrupt/exception management, translation tables and segment
+ registers, ...)
+ - drivers/ directory: basic kernel drivers for various (non CPU)
+ devices (keyboard, x86 video memory, bochs 0xe9 port, ...). Used
+ mainly for debugging
+ - support/ directory: scripts and configuration files to build the
+ floppy images
+ - extra/ directory: a set of configuration files to be customized for
+ non-x86 host installations (yes, we primarily develop SOS on a ppc, for
+ the x86 target of course), or for grub-less installations. See
+ README file in this directory.
+
+The code is licensed under the terms of the GNU GPL version 2 (see
+LICENSE file).
+
+Enjoy !
+
+ David Decotigny, Thomas Petazzoni, the Kos team
+ http://sos.enix.org/
+ http://david.decotigny.free.fr/
+ http://kos.enix.org/~thomas/
+ http://kos.enix.org/
+
+
+--
+David Decotigny
+
+PS: Made with a Mac.
diff --git a/sos-code-article6.75/VERSION b/sos-code-article6.75/VERSION
new file mode 100644
index 0000000..084b9af
--- /dev/null
+++ b/sos-code-article6.75/VERSION
@@ -0,0 +1,13 @@
+SOS -- Simple OS
+Copyright (C) 2003,2004,2005 The SOS Team (David Decotigny & Thomas Petazzoni)
+
+Version "Article 6 (2nd part)" -- Basic kernel thread and synchronization API
+ with priority ordering and O(1)-style
+ scheduler (Linux)
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ See the LICENSE file included in the distribution.
diff --git a/sos-code-article6.75/bootstrap/multiboot.S b/sos-code-article6.75/bootstrap/multiboot.S
new file mode 100644
index 0000000..546d947
--- /dev/null
+++ b/sos-code-article6.75/bootstrap/multiboot.S
@@ -0,0 +1,85 @@
+/* Copyright (C) 1999 Free Software Foundation, Inc.
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+
+
+/* The operating system is booted by Grub, so we almost have nothing
+ to do to boot it. We only have to conform to the Multiboot
+ standard, as defined by the Grub documentation */
+
+#define ASM 1
+/* The multiboot.h header contains a lot of multiboot standard
+ definitions */
+#include "multiboot.h"
+
+ /* The multiboot header itself. It must come first. */
+.section ".multiboot"
+ /* Multiboot header must be aligned on a 4-byte boundary */
+ .align 4
+multiboot_header:
+ /* magic= */ .long MULTIBOOT_HEADER_MAGIC
+ /* flags= */ .long MULTIBOOT_HEADER_FLAGS
+ /* checksum= */ .long -(MULTIBOOT_HEADER_MAGIC \
+ +MULTIBOOT_HEADER_FLAGS)
+ /* header_addr= */ .long multiboot_header
+ /* load_addr= */ .long __b_load
+ /* load_end_addr=*/ .long __e_load
+ /* bss_end_addr= */ .long __e_kernel
+ /* entry_addr= */ .long multiboot_entry
+
+/* Here is the beginning of the code of our operating system */
+.text
+
+.globl start, _start
+start:
+_start:
+multiboot_entry:
+ /* Set up a stack */
+ movl $(stack + MULTIBOOT_STACK_SIZE), %ebp
+ movl %ebp, %esp
+
+ /* Set EFLAGS to 0 */
+ pushl $0
+ /* pop stack into the EFLAGS register */
+ popf
+
+ /* Push the magic and the address on the stack, so that they
+ will be the parameters of the cmain function */
+ pushl %ebx
+ pushl %eax
+
+ /* Call the cmain function (os.c) */
+ call EXT_C(sos_main)
+
+ /* Should never get there */
+loop:
+ hlt
+ jmp loop
+
+/* Here is the stack */
+.section ".init_stack", "aw", @nobits
+.size stack, MULTIBOOT_STACK_SIZE
+stack:
+ .space MULTIBOOT_STACK_SIZE
+
+/* Some data characterizing the stack addresses */
+.data
+ .globl bootstrap_stack_bottom
+bootstrap_stack_bottom: .long stack
+
+ .globl bootstrap_stack_size
+bootstrap_stack_size: .long MULTIBOOT_STACK_SIZE
diff --git a/sos-code-article6.75/bootstrap/multiboot.h b/sos-code-article6.75/bootstrap/multiboot.h
new file mode 100644
index 0000000..ee9cdbd
--- /dev/null
+++ b/sos-code-article6.75/bootstrap/multiboot.h
@@ -0,0 +1,133 @@
+#ifndef __MULTIBOOT_H__
+#define __MULTIBOOT_H__
+
+/* multiboot.h - the header for Multiboot */
+/* Copyright (C) 1999 Free Software Foundation, Inc.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+/* Macros. */
+
+/* The magic number for the Multiboot header. */
+#define MULTIBOOT_HEADER_MAGIC 0x1BADB002
+
+/* The flags for the Multiboot header. */
+#define MULTIBOOT_HEADER_FLAGS 0x00010003
+
+/* The magic number passed by a Multiboot-compliant boot loader. */
+#define MULTIBOOT_BOOTLOADER_MAGIC 0x2BADB002
+
+/* The size of our stack (16KB). */
+#define MULTIBOOT_STACK_SIZE 0x4000
+
+#define MULTIBOOT_CMDLINE 4
+#define MULTIBOOT_MODS 8
+
+/* C symbol format. HAVE_ASM_USCORE is defined by configure. */
+#ifdef HAVE_ASM_USCORE
+# define EXT_C(sym) _ ## sym
+#else
+# define EXT_C(sym) sym
+#endif
+
+#ifndef ASM
+/* Do not include here in the assembler sources. */
+
+#include <sos/types.h>
+
+/* The address of the stack of the bootstrap thread */
+extern sos_vaddr_t bootstrap_stack_bottom;
+extern sos_size_t bootstrap_stack_size;
+
+/* Types. */
+
+/* The Multiboot header. */
+typedef struct multiboot_header
+{
+ unsigned long magic;
+ unsigned long flags;
+ unsigned long checksum;
+ unsigned long header_addr;
+ unsigned long load_addr;
+ unsigned long load_end_addr;
+ unsigned long bss_end_addr;
+ unsigned long entry_addr;
+} multiboot_header_t;
+
+/* The symbol table for a.out. */
+typedef struct aout_symbol_table
+{
+ unsigned long tabsize;
+ unsigned long strsize;
+ unsigned long addr;
+ unsigned long reserved;
+} aout_symbol_table_t;
+
+/* The section header table for ELF. */
+typedef struct elf_section_header_table
+{
+ unsigned long num;
+ unsigned long size;
+ unsigned long addr;
+ unsigned long shndx;
+} elf_section_header_table_t;
+
+/* The Multiboot information. */
+typedef struct multiboot_info
+{
+ unsigned long flags;
+ unsigned long mem_lower;
+ unsigned long mem_upper;
+ unsigned long boot_device;
+ unsigned long cmdline;
+ unsigned long mods_count;
+ unsigned long mods_addr;
+ union
+ {
+ aout_symbol_table_t aout_sym;
+ elf_section_header_table_t elf_sec;
+ } u;
+ unsigned long mmap_length;
+ unsigned long mmap_addr;
+ unsigned long drives_length;
+ unsigned long drives_addr;
+} multiboot_info_t;
+
+/* The module structure. */
+typedef struct module
+{
+ unsigned long mod_start;
+ unsigned long mod_end;
+ unsigned long string;
+ unsigned long reserved;
+} module_t;
+
+/* The memory map. Be careful that the offset 0 is base_addr_low
+ but no size. */
+typedef struct memory_map
+{
+ unsigned long size;
+ unsigned long base_addr_low;
+ unsigned long base_addr_high;
+ unsigned long length_low;
+ unsigned long length_high;
+ unsigned long type;
+} memory_map_t;
+
+void dump_multiboot_info(multiboot_info_t *mbi);
+
+#endif /* ! ASM */
+
+#endif /* __MULTIBOOT_H__ */
diff --git a/sos-code-article6.75/cdrom/boot/grub/stage2_eltorito b/sos-code-article6.75/cdrom/boot/grub/stage2_eltorito
new file mode 100644
index 0000000..6d82f08
--- /dev/null
+++ b/sos-code-article6.75/cdrom/boot/grub/stage2_eltorito
Binary files differ
diff --git a/sos-code-article6.75/drivers/bochs.c b/sos-code-article6.75/drivers/bochs.c
new file mode 100644
index 0000000..f5b0bfb
--- /dev/null
+++ b/sos-code-article6.75/drivers/bochs.c
@@ -0,0 +1,123 @@
+/* Copyright (C) 2004 David Decotigny
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#include <hwcore/ioports.h>
+#include <sos/klibc.h>
+
+#include "bochs.h"
+
+/* This is a special hack that is only useful when running the
+ operating system under the Bochs emulator. */
+#define SOS_BOCHS_IOPORT 0xe9
+
+sos_ret_t sos_bochs_setup(void)
+{
+ return SOS_OK;
+}
+
+#define _putchar(chr) \
+ outb((chr), SOS_BOCHS_IOPORT)
+
+sos_ret_t sos_bochs_putchar(char c)
+{
+ _putchar(c);
+
+ return SOS_OK;
+}
+
+sos_ret_t sos_bochs_putstring(const char* str)
+{
+ for ( ; str && (*str != '\0') ; str++)
+ _putchar(*str);
+
+ return SOS_OK;
+}
+
+sos_ret_t sos_bochs_puthex(unsigned val, int nbytes)
+{
+ unsigned c;
+
+#define BOCHS_PRTHEX(q) \
+ ({ unsigned char r; if ((q) >= 10) r='a'+(q)-10; \
+ else r='0'+(q); _putchar(r); })
+
+ switch (nbytes)
+ {
+ case 4:
+ c = (val >> 24) & 0xff;
+ BOCHS_PRTHEX((c >> 4)&0xf);
+ BOCHS_PRTHEX(c&0xf);
+ case 3:
+ c = (val >> 16) & 0xff;
+ BOCHS_PRTHEX((c >> 4)&0xf);
+ BOCHS_PRTHEX(c&0xf);
+ case 2:
+ c = (val >> 8) & 0xff;
+ BOCHS_PRTHEX((c >> 4)&0xf);
+ BOCHS_PRTHEX(c&0xf);
+ case 1:
+ c = val & 0xff;
+ BOCHS_PRTHEX((c >> 4)&0xf);
+ BOCHS_PRTHEX(c&0xf);
+ }
+
+ return SOS_OK;
+}
+
+
+sos_ret_t sos_bochs_hexdump(const void* addr, int nbytes)
+{
+ int offs;
+ for (offs = 0 ; offs < nbytes ; offs++)
+ {
+ const unsigned char *c;
+
+ if ((offs % 16) == 0)
+ {
+ sos_bochs_putstring("0x");
+ sos_bochs_puthex(offs, 4);
+ }
+
+ if ((offs % 8) == 0)
+ sos_bochs_putstring(" ");
+
+ c = (const unsigned char*)(addr + offs);
+ sos_bochs_puthex(*c, 1);
+ sos_bochs_putstring(" ");
+
+ if (((offs + 1) % 16) == 0)
+ sos_bochs_putstring("\n");
+ }
+
+ if (offs % 16)
+ sos_bochs_putstring("\n");
+
+ return SOS_OK;
+}
+
+
+sos_ret_t sos_bochs_printf(const char *format, /* args */...)
+{
+ char buff[256];
+ va_list ap;
+
+ va_start(ap, format);
+ vsnprintf(buff, sizeof(buff), format, ap);
+ va_end(ap);
+
+ return sos_bochs_putstring(buff);
+}
diff --git a/sos-code-article6.75/drivers/bochs.h b/sos-code-article6.75/drivers/bochs.h
new file mode 100644
index 0000000..348506b
--- /dev/null
+++ b/sos-code-article6.75/drivers/bochs.h
@@ -0,0 +1,55 @@
+/* Copyright (C) 2004 David Decotigny
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#ifndef _SOS_BOCHS_H_
+#define _SOS_BOCHS_H_
+
+/**
+ * @file bochs.h
+ *
+ * If you compiled Bochs with the --enable-e9-hack, then any character
+ * printed to the 0xE9 I/O port is printed to the xterm that is
+ * running Bochs. This may appear to be a detail, but in fact, this
+ * functionnality is *VERY* precious for debugging purposes. This
+ * """driver""" handles this feature.
+ */
+
+#include <sos/errno.h>
+#include <sos/types.h>
+
+sos_ret_t sos_bochs_setup(void);
+
+sos_ret_t sos_bochs_putchar(char c);
+
+sos_ret_t sos_bochs_putstring(const char* str);
+
+/** Print the least signficant 32 (nbytes == 4), 24 (nbytes == 3), 16
+ (nbytes == 2) or 8 (nbytes == 1) bits of val in hexadecimal. */
+sos_ret_t sos_bochs_puthex(unsigned val, int nbytes);
+
+/** hexdump-style pretty printing */
+sos_ret_t sos_bochs_hexdump(const void* addr, int nbytes);
+
+/**
+ * Print the formatted string. Very restricted version of printf(3):
+ * 1/ can print max 255 chars, 2/ supports only %d/%i, %c, %s, %x
+ * without any support for flag charachters (eg %08x).
+ */
+sos_ret_t sos_bochs_printf(const char *format, /* args */...)
+ __attribute__ ((format (printf, 1, 2)));
+
+#endif
diff --git a/sos-code-article6.75/drivers/x86_videomem.c b/sos-code-article6.75/drivers/x86_videomem.c
new file mode 100644
index 0000000..9b9aafc
--- /dev/null
+++ b/sos-code-article6.75/drivers/x86_videomem.c
@@ -0,0 +1,127 @@
+/* Copyright (C) 2004 David Decotigny
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#include <sos/klibc.h>
+#include <hwcore/ioports.h>
+
+#include "x86_videomem.h"
+
+/* The text video memory starts at address 0xB8000. Odd bytes are the
+ ASCII value of the character, even bytes are attribute for the
+ preceding character. */
+#define VIDEO 0xb8000
+
+
+/* Console screen size */
+#define LINES 25
+#define COLUMNS 80
+
+
+/** The structure of a character element in the video memory. @see
+ http://webster.cs.ucr.edu/AoA DOS edition chapter 23 */
+typedef struct {
+ unsigned char character;
+ unsigned char attribute;
+} __attribute__ ((packed)) x86_video_mem[LINES*COLUMNS];
+
+
+
+/** The base pointer for the video memory */
+static volatile x86_video_mem *video = (volatile x86_video_mem*)VIDEO;
+
+sos_ret_t sos_x86_videomem_setup(void)
+{
+ /*
+ * Hide cursor. @see Ralf Brown's interrupt (and port) list
+ * http://www-2.cs.cmu.edu/~ralf/files.html
+ */
+#define CRT_REG_INDEX 0x3d4
+#define CRT_REG_DATA 0x3d5
+
+ /* CRT index port => ask for access to register 0xa ("cursor
+ start") */
+ outb(0x0a, CRT_REG_INDEX);
+
+ /* (RBIL Tables 708 & 654) CRT Register 0xa => bit 5 = cursor OFF */
+ outb(1 << 5, CRT_REG_DATA);
+
+ return SOS_OK;
+}
+
+
+sos_ret_t sos_x86_videomem_cls(unsigned char attribute)
+{
+ /* Clears the screen */
+ int i;
+ for(i = 0 ; i < LINES*COLUMNS ; i++)
+ {
+ (*video)[i].character = 0;
+ (*video)[i].attribute = attribute;
+ }
+
+ return SOS_OK;
+}
+
+
+sos_ret_t sos_x86_videomem_putstring(unsigned char row, unsigned char col,
+ unsigned char attribute,
+ const char *str)
+{
+ unsigned video_offs = row*COLUMNS + col;
+
+ if (video_offs >= LINES*COLUMNS)
+ return -SOS_EINVAL;
+
+ for ( ; str && *str && (video_offs < LINES*COLUMNS) ; str++, video_offs++)
+ {
+ (*video)[video_offs].character = (unsigned char)*str;
+ (*video)[video_offs].attribute = attribute;
+ }
+
+ return SOS_OK;
+}
+
+
+sos_ret_t sos_x86_videomem_putchar(unsigned char row, unsigned char col,
+ unsigned char attribute,
+ unsigned char c)
+{
+ unsigned video_offs = row*COLUMNS + col;
+
+ if (video_offs >= LINES*COLUMNS)
+ return -SOS_EINVAL;
+
+ (*video)[video_offs].character = c;
+ (*video)[video_offs].attribute = attribute;
+
+ return SOS_OK;
+}
+
+
+sos_ret_t sos_x86_videomem_printf(unsigned char row, unsigned char col,
+ unsigned char attribute,
+ const char *format, /* args */...)
+{
+ char buff[256];
+ va_list ap;
+
+ va_start(ap, format);
+ vsnprintf(buff, sizeof(buff), format, ap);
+ va_end(ap);
+
+ return sos_x86_videomem_putstring(row, col, attribute, buff);
+}
diff --git a/sos-code-article6.75/drivers/x86_videomem.h b/sos-code-article6.75/drivers/x86_videomem.h
new file mode 100644
index 0000000..e4b2f91
--- /dev/null
+++ b/sos-code-article6.75/drivers/x86_videomem.h
@@ -0,0 +1,97 @@
+/* Copyright (C) 2004 David Decotigny
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#ifndef _SOS_X86_VIDEOMEM_H_
+#define _SOS_X86_VIDEOMEM_H_
+
+/**
+ * @file x86_videomem.h
+ *
+ * On x86 PC platforms, the text mode screen memory (and CGA/EGA/VGA
+ * too) is mapped into physical memory. This file handles access to
+ * this screen, supposed to be set in text-mode, through this memory
+ * area. All the functions below print the characters directly to the
+ * memory, without interpreting the escaped characters (such as \n,
+ * \r...)
+ */
+
+#include <sos/errno.h>
+
+/**
+ * x86 video attributes
+ * See http://webster.cs.ucr.edu/AoA/DOS/ch23/CH23-1.html
+ */
+/* Normal and Dark/Light foreground */
+#define SOS_X86_VIDEO_FG_BLACK 0
+#define SOS_X86_VIDEO_FG_DKGRAY 8
+#define SOS_X86_VIDEO_FG_BLUE 1
+#define SOS_X86_VIDEO_FG_LTBLUE 9
+#define SOS_X86_VIDEO_FG_GREEN 2
+#define SOS_X86_VIDEO_FG_LTGREEN 10
+#define SOS_X86_VIDEO_FG_CYAN 3
+#define SOS_X86_VIDEO_FG_LTCYAN 11
+#define SOS_X86_VIDEO_FG_RED 4
+#define SOS_X86_VIDEO_FG_LTRED 12
+#define SOS_X86_VIDEO_FG_MAGENTA 5
+#define SOS_X86_VIDEO_FG_LTMAGENTA 13
+#define SOS_X86_VIDEO_FG_BROWN 6
+#define SOS_X86_VIDEO_FG_YELLOW 14
+#define SOS_X86_VIDEO_FG_LTGRAY 7
+#define SOS_X86_VIDEO_FG_WHITE 15
+/* Background */
+#define SOS_X86_VIDEO_BG_BLACK (0 << 4)
+#define SOS_X86_VIDEO_BG_BLUE (1 << 4)
+#define SOS_X86_VIDEO_BG_GREEN (2 << 4)
+#define SOS_X86_VIDEO_BG_CYAN (3 << 4)
+#define SOS_X86_VIDEO_BG_RED (4 << 4)
+#define SOS_X86_VIDEO_BG_MAGENTA (5 << 4)
+#define SOS_X86_VIDEO_BG_BROWN (6 << 4)
+#define SOS_X86_VIDEO_BG_LTGRAY (7 << 4)
+/* Blinking */
+#define SOS_X86_VIDEO_FG_BLINKING (1 << 7)
+
+
+/** Setup the video RAM mapping and clear the screen */
+sos_ret_t sos_x86_videomem_setup(void);
+
+/** Clears the screen and set the background color as given by
+ attribute */
+sos_ret_t sos_x86_videomem_cls(unsigned char attribute);
+
+/** Print the string on the scren with the given attribute. Does not
+ handle scrolling */
+sos_ret_t sos_x86_videomem_putstring(unsigned char row, unsigned char col,
+ unsigned char attribute,
+ const char *str);
+
+/** Print the character on the scren with the given attribute. Does not
+ handle scrolling */
+sos_ret_t sos_x86_videomem_putchar(unsigned char row, unsigned char col,
+ unsigned char attribute,
+ unsigned char c);
+
+/**
+ * Print the formatted string. Very restricted version of printf(3):
+ * 1/ can print max 255 chars, 2/ supports only %d/%i, %c, %s, %x
+ * without any support for flag charachters (eg %08x).
+ */
+sos_ret_t sos_x86_videomem_printf(unsigned char row, unsigned char col,
+ unsigned char attribute,
+ const char *format, /* args */...)
+ __attribute__ ((format (printf, 4, 5)));
+
+#endif /* _SOS_X86_VIDEOMEM_H_ */
diff --git a/sos-code-article6.75/extra/Makefile b/sos-code-article6.75/extra/Makefile
new file mode 100644
index 0000000..f858aa6
--- /dev/null
+++ b/sos-code-article6.75/extra/Makefile
@@ -0,0 +1,40 @@
+OBJCOPY=objcopy
+
+all: sos_qemu.img
+
+-include ../.mkvars
+
+# The image is the simple concatenation of the boot sector and the kernel
+# It may be use in bochs or on a real floppy, but NOT in qemu (see below)
+sos_bsect.img: bsect.bin sos.bin
+ cat $^ > $@
+ @echo "You can use the $@ image in bochs or on a real floppy (NOT qemu)"
+
+# For qemu, the trick is to tell it we have *more* than 1440 sectors (720kB).
+# Rtherwise the qemu disk geometry will be configured to be that of a 720kB
+# floppy, while our boot sector assumes it to be 1.44MB
+sos_qemu.img: sos_bsect.img
+ # Padding with 0s after the bsect/kernel image
+ cat $< /dev/zero | dd of=$@ bs=1k count=1440
+ @echo "You can use the $@ image in qemu, bochs, or on a real floppy"
+
+# we extract the boot sector from the main ELF binary
+bsect.bin: sos_bsect.elf
+ $(OBJCOPY) -v -O binary -j .bootsect $< $@
+
+# we extract the kernel code from the main ELF binary
+sos.bin: sos_bsect.elf
+ $(OBJCOPY) -v -O binary -R .bootsect $< $@
+
+# The main ELF binary contains the boot sector and the kernel code
+# linked together (hence we deal with a SINGLE image that we split
+# above) because they share some symbol definitions
+sos_bsect.elf: bootsect.o compile_kernel
+ $(LD) --warn-common -T ./sos_bsect.lds -o $@ \
+ bootsect.o $(wildcard ../hwcore/*.o ../drivers/*.o ../sos/*.o)
+
+compile_kernel:
+ $(MAKE) -C ..
+
+clean:
+ $(RM) *.img *.elf *.bin *~ *.o *.out
diff --git a/sos-code-article6.75/extra/README b/sos-code-article6.75/extra/README
new file mode 100644
index 0000000..0272f1f
--- /dev/null
+++ b/sos-code-article6.75/extra/README
@@ -0,0 +1,73 @@
+
+Contents of the extra/ directory
+================================
+
+Data and configuration files to support generation of sos on non-x86
+and/or grub-less hosts:
+ - dot.mkvars: file to copy as .mkvars in the root directory to
+ compile on a non-x86 host, and to generate the grub floppy image on
+ a grub-less host
+ - grub.img.gz: compressed image of a Grub floppy (without any
+ kernel). Used by dot.mkvars.
+ - mtoolsrc: file needed by .mkvars to compile a the floppy image
+
+Support of a sos-specific boot sector:
+ - Makefile: rules to compile sos_bsect.img, the floppy image with the
+ boot sector and the Sos
+ - bootsect.S: x86 Sos boot sector (GNU as). Depends on sos_bsect.lds
+ - sos_bsect.lds: ld script to bind the boot sector with the remaining
+ of the kernel
+
+Misc:
+ - qemu-port-e9.diff: patch over qemu to support the bochs "port 0xe9 hack"
+
+
+What you can do with these files
+================================
+
+
+*** Compile SOS from another architecture:
+------------------------------------------
+ - compile a cross-compiler for the i586-gnu target. This involves
+ compiling the binutils and gcc. Here are example configuration
+ options for them:
+ binutils (replace sparc-cun-solaris with your arch):
+ ../binutils-2.13/configure --prefix=/udd/ddecotig/temp_dd/xgcc/host-sparc-solaris7/stow/binutils-2.11 --host=sparc-sun-solaris2.7 i586-gnu
+ make && make install
+ gcc (ditto):
+ CFLAGS="-O2 -Dinhibit_libc" ../gcc-3.2/configure --target=i586-gnu --prefix=/udd/ddecotig/temp_dd/xgcc/host-sparc-solaris7/stow/gcc-3.2 --with-as=/udd/ddecotig/temp_dd/xgcc/host-sparc-solaris7/bin/as --with-ld=/udd/ddecotig/temp_dd/xgcc/host-sparc-solaris7/bin/ld --with-gnu-as --with-gnu-ld --enable-languages=c --disable-shared --disable-multilib --disable-nls --enable-threads=single
+ make && make install
+ - compile the mtools
+ - copy dot.mkvars to the root directory of SOS, as ".mkvars"
+ - customize the CC/LD/... variables to suit your cross-compiler
+ installatioon
+ - now you may run make from the SOS root directory, it should
+ generate the Grub boot floppy image. The following warning is
+ normal:
+ .mkvars:16: attention : écrasement des commandes pour la cible « grub-sos.img »
+ Makefile:92: attention : anciennes commandes ignorées pour la cible « grub-sos.img »
+
+
+*** To compile SOS from an x86 where grub is not or incorrectly installed:
+--------------------------------------------------------------------------
+ - copy dot.mkvars to the root directory of SOS, as ".mkvars"
+ - customize the CC/LD/... variables to suit your cross-compiler
+ installatioon
+ - now you may run make from the SOS root directory, it should
+ generate the Grub boot floppy image. The following warning is
+ normal:
+ .mkvars:16: attention : écrasement des commandes pour la cible « grub-sos.img »
+ Makefile:92: attention : anciennes commandes ignorées pour la cible « grub-sos.img »
+
+
+*** To compile SOS with its own bootloader:
+-------------------------------------------
+ - for cross-architecture compilation: see above
+ - cd to this extra/ directory
+ - run 'make'
+ - the floppy image is: sos_bsect.img
+ NOTE : SOS will not boot correctly this way after article 2 !
+
+
+--
+David Decotigny
diff --git a/sos-code-article6.75/extra/bootsect.S b/sos-code-article6.75/extra/bootsect.S
new file mode 100644
index 0000000..8d6ef8f
--- /dev/null
+++ b/sos-code-article6.75/extra/bootsect.S
@@ -0,0 +1,406 @@
+
+/*
+ * @(#) $Id: bootsect.S,v 1.8 2004/11/20 16:00:11 d2 Exp $
+ * Description : Bootsecteur en syntaxe AT&T
+ * Auteurs : Thomas Petazzoni & Fabrice Gautier & Emmanuel Marty
+ * Jerome Petazzoni & Bernard Cassagne & coffeeman
+ * David Decotigny
+ * Bug reports to kos-misc@enix.org
+ */
+
+/*
+ * But global de ce bootsecteur :
+ *
+ * - Initialiser la becane
+ * - Charger le kernel
+ * - Passer en mode protege
+ * - Executer le kernel
+ *
+ * Taille restante : Je vous rappelle qu'un bootsecteur ne peut faire
+ * qu'au maximum 512 octets dont 2 octets obligatoires 0xAA55. Sur
+ * les 510 octets reellement utilisables, il reste 3 octets dispo (60
+ * si on decide d'enlever le BPB un jour) !!!
+ *
+ * thomas_petazzoni : - detection des codes d'erreurs de chargement
+ * David_Decotigny : - Passage en GNU as
+ * David_Decotigny : - Chargement du noyau au-dela du 1er Mega (taille
+ * max = 0x9e000 octets = 632ko), pour avoir le
+ * meme noyau sous grub et avec le bootsecteur
+ */
+
+ /*
+ * Sequence d'operations :
+ * - Le BIOS charge le bootsect en 0x7c00 (BOOT_ADRESS). On choisit
+ * la representation 0x7c0:0000 pour que le .org 0 reste valide
+ * - Le bootsect se deplace de lui-meme en 0x9f000 (COPY_ADRESS). On
+ * choisit la representation 0x9f00:0000 pour que le .org 0 reste
+ * valide
+ * - Le bootsect verifie que le processeur est du type 386+
+ * - Il charge le noyau depuis la disquette en memoire a partir de
+ * 0x1000 (LOAD_ADRESS). Le noyau peut au max tenir sur
+ * SECTORS_TO_LOAD secteurs
+ * - Il passe en pmode flat (apres ouverture a20)
+ * - Il recopie le noyau (situe en LOAD_ADRESS) vers son adresse
+ * finale (FINAL_ADDRESS = 2Mo). La recopie se fait sur tout l'espace
+ * LOAD_ADRESS ---> COPY_ADRESS, c'est a dire sur 0x9e000 octets =
+ * 632ko. Le noyau peut donc au max faire 632ko. Le nombre max de
+ * secteurs de disquette qu'on peut charger est donc 1264
+ */
+
+
+/* La taille de la pile */
+#define BOOT_STACK_SIZE 0x4000
+
+ .file "bootsect.S"
+
+ /* Tout est place dans une seule section */
+ .section ".bootsect"
+
+ /* L'essentiel du bootsector (sauf les 1eres instructions)
+ sont a un offset 0. On fait en sorte que le compilo soit
+ d'accord la-dessus. Quand on a des adresse realm exotiques
+ (0x7c00, 0x9f000, ...), on s'arrange toujours pour avoir un
+ offset de 0 => on choisira le segment adapte (0x7c0,
+ 0x9f00, ...). Il ne faut pas oublier le ld -Ttext 0 */
+ .org 0
+
+ /* Pour que gas genere du 16bits, afin que ca marche en realm */
+ .code16
+
+#define SECTORS_TO_LOAD 128 /* 64 ko */ /* MAX=1264 */
+
+/*
+ * Parametres de la disquette. Comme c'est chiant de faire une
+ * procedure de detection auto, et que ca prend de la place, on fait
+ * ca "a la main". Par exemple, une DD 720 Ko a 9 secteurs/piste, une
+ * 1.44 Mo a 18 secteurs/pistes
+ */
+#define CYLS 80
+#define HEADS 1
+#define SECTS 18
+
+#define BOOT_ADRESS 0x07C00 /* Adresse de demarrage (lineaire) */
+#define BOOT_SEG (BOOT_ADRESS>>4) /* Segment de Boot */
+#define BOOT_SIZE 512 /* Taille bu bootsecteur */
+#define COPY_ADRESS 0x9F000 /* La ou on va copier le
+ bootsecteur (lineaire) */
+#define COPY_SEG (COPY_ADRESS>>4) /* Segment de la ou on va
+ copier le bootsecteur */
+#define LOAD_ADRESS 0x01000 /* 1er chargement du systeme */
+#define LOAD_SEG (LOAD_ADRESS>>4) /* Segment du 1er chargement du */
+#define MAX_KERN_LEN COPY_ADRESS-LOAD_ADRESS /* Taille noyau maxi */
+
+/* IMPORTANT : Cette valeur DOIT etre identique a l'adresse presente
+ dans sos.lds ! */
+#define FINAL_ADDRESS 0x200000 /* Adresse finale (physique de 0 a 4G)
+ ou est charge le noyau */
+
+#define OP16 .byte 0x66 ;
+#define OP32 .byte 0x66 ;
+
+/*
+ * Procedure qui vide le buffer clavier.
+ */
+#define WAITKB \
+ 1: ;\
+ .word 0xeb ;\
+ .word 0xeb ;\
+ inb $0x64, %al ;\
+ andb $0x2, %al ;\
+ jnz 1b
+
+ /* Le point d'entree dans le bootsect */
+.globl _bsect
+_bsect:
+
+ /*
+ * La portion qui suit est situee a un offset 0x7c00 en
+ * memoire. Attention donc aux references memoire dans cette
+ * partie. On choisit de rester en offset 0 (.org 0), mais on
+ * charge correctement les segments a 0x7c0.
+ */
+
+ movw $BOOT_SEG, %ax /* le bootsecteur est a 0x7C00 en lineaire */
+ movw %ax, %ds /* on le copie a l'adresse COPY_ADRESS */
+ xorw %si, %si /* comme cette adresse est la plus haute de la mem */
+ xorw %di, %di /* on pourra charger un kernel + gros */
+ movw $(BOOT_SIZE>>1), %cx
+ movw $COPY_SEG, %ax
+ movw %ax, %es
+ cld
+ rep ; movsw
+
+ /* on continue a executer le bootsecteur, mais maintenant a
+ partir de 0x9F000, qu'on represente sous la forme
+ 0x9f00:offset */
+ ljmp $COPY_SEG, $here
+
+ /*
+ * A partir de maintenant, on est a un offset 0 en memoire
+ * (segment 0x9f00), conformement a ce que veut le compilo.
+ */
+here:
+ movw %ax, %ds
+
+ /* Petite pile temporaire (1k - 3.84k en RAM ; les adresses 0-1k
+ correspondent au vecteur d'interruptions). */
+ movw %ax, %ss
+ movw $(LOAD_ADRESS - 0x10), %sp
+
+ /* Efface l'ecran */
+ movb $0x0, %ah
+ movb $0x3, %al
+ int $0x10
+
+ /* Affiche les messages d'attente */
+ movw $loadkern, %si
+ call message
+ movw $check, %si
+ call message
+
+check386:
+ /*
+ * la attention, plus complexe : on teste si le proc est un
+ * 386+ pour cela, on va essayer de modifier les bits 12 ? 14
+ * du registre E-flag si la modification reste, alors le proc
+ * est un 386+, sinon, c'est =< 286
+ *
+ * Merci a Emmanuel Marty pour la compatibilite avec les 386
+ * "pre-jurassique"
+ */
+
+ pushf /* on sauvegarde le E-Flag */
+ movb $0x70, %ah
+ pushw %ax
+ popf
+ pushf
+ popw %ax
+ orb %ah, %ah
+ je no386 /* si la modif n'est pas valable, alors on saute a
+ no386 */
+ popf /* on les restaure ? la fin ... */
+
+ /* Message de confirmation de 386+ et d'attente */
+ movw $found386, %si
+ call message
+ movw $loading, %si
+ call message
+
+/* Copie du noyau disquette => RAM a partir de 0x1000
+ L'adresse de destination est définie par es:0, où es vaut
+ initialement 0x100 (ie correspond alors à l'adresse 256*16, soit 4
+ ko). Chaque itération incrémente ce registre es de 32, ce qui
+ correspond à un bond de 32*16 en mémoire, soit la taille d'un
+ secteur. De cette façon, puisqu'on joue sur les segments plutôt que
+ sur les offsets, la taille du noyau n'est pas limitée à 64 ko. Elle
+ est limitée par contre à la taille de la mémoire disponible sous
+ les 1Mo, \ie 640 ko (0x9f000 - 0x1000). */
+copyKernel:
+ /* Chargement du noyau en LOAD_SEG:0 */
+ /* 3 iterateurs :
+ - load_size : le nbre de secteurs a charger
+ - cl : le secteur ou on en est pour le
+ cylindre en cours (<= SECTS)
+ - dh : la tete en cours (0/1)
+ */
+ movb $0, %dl
+ movw $LOAD_SEG, %ax
+ movw %ax, %es
+
+ xorw %bx, %bx
+ xorw %dx, %dx
+ movw $1, %cx /* premier secteur */
+
+.nextsector: /* prochain secteur */
+ incb %cl /* en incrementant CL */
+ cmpb $SECTS, %cl /* si CL =< SECTS (=nbre de secteurs/pistes)
+ alors on charge */
+ jbe .sector
+ movb $1, %cl /* sinon on revient au secteur 1 */
+ incb %dh /* mais sur l'autre tete */
+ cmpb $1, %dh /* on recompare, si DH =< 1 */
+ je .sector /* on charge */
+ movb $0, %dh /* sinon on repasse a la tete 0 */
+ incb %ch /* mais on change de cylindre */
+
+.sector:
+ pushw %es
+ movw $0x0201, %ax /* service 0x2, chargement 0x1 seecteur */
+ int $0x13 /* Go ! */
+ jc halt /* erreur */
+ popw %ax
+ addw $32, %ax /* on a charge un secteur, donc on doit
+ charger 512 bytes plus loin */
+ movw %ax, %es /* on avance donc le segment du buffer de
+ 32bytes, ie 1 secteur en RAM (car 32*16=512) */
+
+ movw $(0x0E*256+'.'), %ax /* affiche un point */
+ int $0x10
+
+ decw (load_size) /* et on repart pour le prochain secteur
+ tant qu'on n'a pas fini ! */
+ jnz .nextsector
+
+after:
+ movw $0x03f2, %dx
+ inb %dx, %al /* stoppe le moteur */
+ andb $0x0f, %al
+ outb %al, %dx
+
+ cli /* on interdit les interruptions */
+
+fincopie:
+ pushw %cs
+ popw %ds
+
+ /* on ouvre la porte A20 */
+ WAITKB /* on vide le buffer */
+ movb $0xd1, %al /* on met a jour le port */
+ outb %al, $0x64
+ WAITKB
+ movb $0xdf, %al /* bit 2 = ouverture/fermeture */
+ outb %al, $0x60
+
+ /*
+ * init gdt
+ */
+InitGDT:
+ /* Préparation du flat mode */
+ lgdt gdtr
+
+GoPMode:
+ /* Passage en mode protégé */
+ movl %cr0, %eax
+ orb $1, %al /* set PE bit to 1 */
+ movl %eax, %cr0
+
+ /* we are not yet in Pmode jump 'in' pmode clearing prefetch
+ * queue and loading a new selector */
+ movw $0x10, %ax
+ movw %ax, %ds
+ movw %ax, %es
+ movw %ax, %fs
+ movw %ax, %gs
+
+/*
+ * Code 32 bits ============================================================
+ */
+ .code32
+
+JumpToHere32: /* Se deplace a l'endroit actuel, en passant en 32bits
+ et en utilisant la gdt, et vide la prefetch queue */
+ .byte 0x66 /* Prefixe 32bits : en realite, jusqu'au jmp, on est
+ encore en 16 bits */
+ ljmp $0x8, $(COPY_ADRESS+(Here32))
+Here32:
+ /* Et voila : On est en 32 bits vrai */
+
+MoveKernelToFinalAddr: /* Deplace le noyau (en LOAD_ADDRESS) vers sa
+ destination finale (FINAL_ADDRESS) */
+ movl $0x10, %eax
+ movl %eax, %ds /* Seg Src = DSeg */
+ movl %eax, %es /* Sed Dest = DSeg */
+ cld
+ movl $LOAD_ADRESS, %esi /* On commence la copie au debut du noyau */
+ movl $FINAL_ADDRESS, %edi /* On copie vers cette adresse */
+ movl $MAX_KERN_LEN, %ecx /* Taille recopie */
+ shrl $2, %ecx
+ rep
+ movsl
+
+LaunchKernel:
+ /* Met en place une pile au niveau du symbole "stack" */
+ movl %eax, %ss
+ movl $(stack + BOOT_STACK_SIZE), %ebp
+ movl %ebp, %esp
+
+ /* Saut vers le noyau. La GDT est en place (flat mode), les
+ * selecteurs aussi, a20 est ouverte, et les interruptions sont
+ * cli + pas de idt. Le PIC n'est pas programme */
+ ljmp $0x8, $sos_main
+
+/*
+ * Utilities ============================================================
+ */
+ .code16
+
+message:
+ lodsb /* charge ds:si dans al et incremente si */
+ orb %al, %al /* si al = 0 */
+ jz 1f
+ movb $0x0e, %ah /* service 0Eh (affichage d'un caractere) */
+ movw $0x0007, %bx /* Parametres : blanc sur fond noir */
+ int $0x10 /* Appel de l'interruption 10h */
+ jmp message /* On repart au début ... */
+ 1: ret /* si la chaine est finie alors on retourne
+ dans la fonction appelante */
+
+halt:
+ pushw %cs
+ popw %es
+ movw $haltmsg, %si
+ call message
+ cli
+ 1: jmp 1b
+ ret
+
+no386:
+ movw $need386, %si
+ call message
+ call halt
+
+ /*
+ * GDT
+ */
+
+gdt:
+gdtr:
+NULL_Desc:
+ .word (EndGDT)-(gdt)-1 /* Taille GDT */
+ .long (gdt)+COPY_ADRESS
+unused:
+ .word 0
+
+CS_Desc: /* 0x8 */
+ .word 0xFFFF, 0
+ .byte 0, 0x9B, 0xCF, 0
+
+DS_Desc: /* 0x10 */
+ .word 0xFFFF, 0
+ .byte 0, 0x93, 0xCF, 0
+
+EndGDT:
+
+ /* quelques messages */
+
+loadkern: .string "-= S O S =- : The Simple Operating System \r\n"
+check: .string "Checking for a 386+ processor... "
+found386: .string " [OK]\r\n"
+need386: .string " [FAILED]\r\n"
+diskerror: .string "Disk Error\r\n"
+loading: .string "Loading... "
+haltmsg: .string "System Halted\r\n"
+
+/*** Les code/données du boot secteur se terminent ICI. le marqueur de
+ * fin (aa55) est ajouté automatiquement par le script ld
+ * sos_bsect.lds ***/
+
+/* La pile de 16k qu'on utilise au niveau de LaunchKernel se trouve
+ declaree avec le noyau, dans sa section ".init_stack", cad HORS du boot
+ secteur ! (sinon ca depasserait 512B, forcément). On aurait pu la
+ définir directement dans le sos_bsect.lds, ou dans un fichier .c
+ auxiliaire pour plus de clarté */
+/* Here is the stack */
+.section ".init_stack", "aw", @nobits
+.p2align 4
+.size stack, BOOT_STACK_SIZE
+stack:
+ .space BOOT_STACK_SIZE
+
+/* Some data characterizing the stack addresses */
+.data
+ .globl bootstrap_stack_bottom
+bootstrap_stack_bottom: .long stack
+
+ .globl bootstrap_stack_size
+bootstrap_stack_size: .long BOOT_STACK_SIZE
diff --git a/sos-code-article6.75/extra/dot.mkvars b/sos-code-article6.75/extra/dot.mkvars
new file mode 100644
index 0000000..1f7dca5
--- /dev/null
+++ b/sos-code-article6.75/extra/dot.mkvars
@@ -0,0 +1,29 @@
+# For cross-compilation and/or installations without grub available,
+# copy this file as .mkvars to the root directory of the SOS sources,
+# and customize the CC/LD/... variables. You still need the mtools
+# installed and running
+
+CC := i586-gnu-gcc
+LD := i586-gnu-ld
+OBJCOPY := i586-gnu-objcopy
+CFLAGS += -O3
+
+# Configuration of mtools
+MTOOLSRC = extra/mtoolsrc
+export MTOOLSRC
+
+$(MULTIBOOT_IMAGE): $(KERNEL_OBJ) menu.txt
+ gzip -dc < extra/grub.img.gz > $@
+ mcopy menu.txt v:/boot/grub/
+ mmd v:/system
+ mcopy sos.elf v:/system/sos.elf
+
+menu.txt:
+ echo timeout 0 > $@
+ echo default 0 >> $@
+ echo title SOS >> $@
+ echo "root (fd0)" >> $@
+ echo kernel /system/sos.elf >> $@
+
+runbochs: all
+ echo c | bochs -q
diff --git a/sos-code-article6.75/extra/grub.img.gz b/sos-code-article6.75/extra/grub.img.gz
new file mode 100644
index 0000000..4f98e74
--- /dev/null
+++ b/sos-code-article6.75/extra/grub.img.gz
Binary files differ
diff --git a/sos-code-article6.75/extra/mtoolsrc b/sos-code-article6.75/extra/mtoolsrc
new file mode 100644
index 0000000..df1a26e
--- /dev/null
+++ b/sos-code-article6.75/extra/mtoolsrc
@@ -0,0 +1,2 @@
+# For older versions of mtools, you may have to remove "filter"
+drive v: file="fd.img" 1.44M filter
diff --git a/sos-code-article6.75/extra/qemu-port-e9.diff b/sos-code-article6.75/extra/qemu-port-e9.diff
new file mode 100644
index 0000000..d8be044
--- /dev/null
+++ b/sos-code-article6.75/extra/qemu-port-e9.diff
@@ -0,0 +1,73 @@
+--- Makefile.target 17 Mar 2004 23:46:04 -0000 1.19
++++ Makefile.target 18 Mar 2004 14:20:29 -0000
+@@ -217,7 +217,8 @@
+ # must use static linking to avoid leaving stuff in virtual address space
+ VL_OBJS=vl.o osdep.o block.o monitor.o \
+ ide.o ne2000.o pckbd.o vga.o sb16.o dma.o oss.o \
+- fdc.o mc146818rtc.o serial.o i8259.o i8254.o pc.o
++ fdc.o mc146818rtc.o serial.o i8259.o i8254.o pc.o \
++ port-e9.o
+ ifeq ($(TARGET_ARCH), ppc)
+ VL_OBJS+= hw.o
+ endif
+--- hw/pc.c 14 Mar 2004 21:46:48 -0000 1.2
++++ hw/pc.c 18 Mar 2004 14:20:29 -0000
+@@ -371,6 +371,7 @@
+ SB16_init();
+
+ fdctrl_init(6, 2, 0, 0x3f0, fd_table);
++ port_e9_init();
+
+ cmos_init(ram_size, boot_device);
+ }
+--- /dev/null 2003-01-30 11:24:37.000000000 +0100
++++ port-e9.c 2004-03-18 15:18:52.660493187 +0100
+@@ -0,0 +1,38 @@
++/*
++ * QEMU Port 0xe9 hack
++ *
++ * Copyright (c) 2000-2004 E. Marty, the bochs team, D. Decotigny
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to deal
++ * in the Software without restriction, including without limitation the rights
++ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
++ * copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in
++ * all copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
++ * THE SOFTWARE.
++ */
++#include <stdio.h>
++#include <unistd.h>
++#include <inttypes.h>
++
++#include "vl.h"
++
++static void bochs_e9_write(void *opaque, uint32_t address, uint32_t data)
++{
++ write(fileno(stdout), &data, 1);
++}
++
++void port_e9_init ()
++{
++ register_ioport_write(0xe9, 1, 1, bochs_e9_write, NULL);
++}
+--- vl.h 17 Mar 2004 23:17:16 -0000 1.14
++++ vl.h 18 Mar 2004 14:29:06 -0000
+@@ -268,4 +268,7 @@
+ void term_flush(void);
+ void term_print_help(void);
+
++/* port-e9.c */
++void port_e9_init(void);
++
+ #endif /* VL_H */
diff --git a/sos-code-article6.75/extra/sos_bsect.lds b/sos-code-article6.75/extra/sos_bsect.lds
new file mode 100644
index 0000000..ac42f23
--- /dev/null
+++ b/sos-code-article6.75/extra/sos_bsect.lds
@@ -0,0 +1,61 @@
+/* Copyright (C) 2004, David Decotigny
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+
+SECTIONS
+{
+ /* ***********************************************
+ * The bootsector is here. We link it against the remaining of the kernel
+ * in order to automatically figure out its size that must be loaded
+ * from file to memory (see the load_size definition below)
+ */
+
+ /* If we use one, we put the boot sector here. We don't set its
+ * address to 0x7c000 (aka 0x7c00:0), since it reloads itself to
+ * 0x9f000, causing the 0x7c000 address to be meaningless too. So we
+ * chose to pretend that the address is 0x0, and to make a little
+ * address arithmetic in bootsect.S */
+ .bootsect 0x0 :
+ {
+ /* The code for the boot sector goes here */
+ *(.bootsect);
+
+ /* The load_size symbol contains the size of the area (in
+ * sectors, aka 512 Bytes) that the boot sector should copy from
+ * the disk. The bss section is not included since it uses 0
+ * bytes on disk */
+ load_size = .;
+ LONG((__e_load - __b_load + 511) >> 9);
+ /* ---> This is equivalent to ceil( (__e_load - __b_load) / 512 ) */
+
+ /* At offsets 511 and 512, we set the boot sector signature (AA55h) */
+ . = 0x1fe;
+ SHORT(0xAA55);
+ }
+}
+
+
+/* This is to avoid a cut/paste here. Please notice that a multiboot
+ * section WILL be inserted, which is NOT mandatory (we could have
+ * removed it without getting into trouble). Please note however that
+ * the *.bin files will NOT be multiboot compatible (they are not in ELF
+ * format): they are expected to be directly booted by the BIOS (or
+ * by the "chainloader" command of Grub). */
+INCLUDE ../support/sos.lds
+
+/* We overload the entry set in sos.lds, just to avoid an ld warning */
+ENTRY(sos_main);
diff --git a/sos-code-article6.75/hwcore/cpu_context.c b/sos-code-article6.75/hwcore/cpu_context.c
new file mode 100644
index 0000000..770452d
--- /dev/null
+++ b/sos-code-article6.75/hwcore/cpu_context.c
@@ -0,0 +1,407 @@
+/* Copyright (C) 2005 David Decotigny
+ Copyright (C) 2000-2004, The KOS team
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+
+
+#include <sos/assert.h>
+#include <sos/klibc.h>
+#include <drivers/bochs.h>
+#include <drivers/x86_videomem.h>
+#include <hwcore/segment.h>
+
+#include "cpu_context.h"
+
+
+/**
+ * Here is the definition of a CPU context for IA32 processors. This
+ * is a SOS convention, not a specification given by the IA32
+ * spec. However there is a strong constraint related to the x86
+ * interrupt handling specification: the top of the stack MUST be
+ * compatible with the 'iret' instruction, ie there must be the
+ * err_code (might be 0), eip, cs and eflags of the destination
+ * context in that order (see Intel x86 specs vol 3, figure 5-4).
+ *
+ * @note IMPORTANT: This definition MUST be consistent with the way
+ * the registers are stored on the stack in
+ * irq_wrappers.S/exception_wrappers.S !!! Hence the constraint above.
+ */
+struct sos_cpu_state {
+ /* (Lower addresses) */
+
+ /* These are SOS convention */
+ sos_ui16_t gs;
+ sos_ui16_t fs;
+ sos_ui16_t es;
+ sos_ui16_t ds;
+ sos_ui16_t cpl0_ss; /* This is ALWAYS the Stack Segment of the
+ Kernel context (CPL0) of the interrupted
+ thread, even for a user thread */
+ sos_ui16_t alignment_padding; /* unused */
+ sos_ui32_t eax;
+ sos_ui32_t ebx;
+ sos_ui32_t ecx;
+ sos_ui32_t edx;
+ sos_ui32_t esi;
+ sos_ui32_t edi;
+ sos_ui32_t ebp;
+
+ /* MUST NEVER CHANGE (dependent on the IA32 iret instruction) */
+ sos_ui32_t error_code;
+ sos_vaddr_t eip;
+ sos_ui32_t cs; /* 32bits according to the specs ! However, the CS
+ register is really 16bits long */
+ sos_ui32_t eflags;
+
+ /* (Higher addresses) */
+} __attribute__((packed));
+
+
+/**
+ * The CS value pushed on the stack by the CPU upon interrupt, and
+ * needed by the iret instruction, is 32bits long while the real CPU
+ * CS register is 16bits only: this macro simply retrieves the CPU
+ * "CS" register value from the CS value pushed on the stack by the
+ * CPU upon interrupt.
+ *
+ * The remaining 16bits pushed by the CPU should be considered
+ * "reserved" and architecture dependent. IMHO, the specs don't say
+ * anything about them. Considering that some architectures generate
+ * non-zero values for these 16bits (at least Cyrix), we'd better
+ * ignore them.
+ */
+#define GET_CPU_CS_REGISTER_VALUE(pushed_ui32_cs_value) \
+ ( (pushed_ui32_cs_value) & 0xffff )
+
+
+/**
+ * Structure of an interrupted Kernel thread's context
+ */
+struct sos_cpu_kstate
+{
+ struct sos_cpu_state regs;
+} __attribute__((packed));
+
+
+/**
+ * THE main operation of a kernel thread. This routine calls the
+ * kernel thread function start_func and calls exit_func when
+ * start_func returns.
+ */
+static void core_routine (sos_cpu_kstate_function_arg1_t *start_func,
+ sos_ui32_t start_arg,
+ sos_cpu_kstate_function_arg1_t *exit_func,
+ sos_ui32_t exit_arg)
+ __attribute__((noreturn));
+
+static void core_routine (sos_cpu_kstate_function_arg1_t *start_func,
+ sos_ui32_t start_arg,
+ sos_cpu_kstate_function_arg1_t *exit_func,
+ sos_ui32_t exit_arg)
+{
+ start_func(start_arg);
+ exit_func(exit_arg);
+
+ SOS_ASSERT_FATAL(! "The exit function of the thread should NOT return !");
+ for(;;);
+}
+
+
+sos_ret_t sos_cpu_kstate_init(struct sos_cpu_state **ctxt,
+ sos_cpu_kstate_function_arg1_t *start_func,
+ sos_ui32_t start_arg,
+ sos_vaddr_t stack_bottom,
+ sos_size_t stack_size,
+ sos_cpu_kstate_function_arg1_t *exit_func,
+ sos_ui32_t exit_arg)
+{
+ /* We are initializing a Kernel thread's context */
+ struct sos_cpu_kstate *kctxt;
+
+ /* This is a critical internal function, so that it is assumed that
+ the caller knows what he does: we legitimally assume that values
+ for ctxt, start_func, stack_* and exit_func are allways VALID ! */
+
+ /* Setup the stack.
+ *
+ * On x86, the stack goes downward. Each frame is configured this
+ * way (higher addresses first):
+ *
+ * - (optional unused space. As of gcc 3.3, this space is 24 bytes)
+ * - arg n
+ * - arg n-1
+ * - ...
+ * - arg 1
+ * - return instruction address: The address the function returns to
+ * once finished
+ * - local variables
+ *
+ * The remaining of the code should be read from the end upward to
+ * understand how the processor will handle it.
+ */
+
+ sos_vaddr_t tmp_vaddr = stack_bottom + stack_size;
+ sos_ui32_t *stack = (sos_ui32_t*)tmp_vaddr;
+
+ /* If needed, poison the stack */
+#ifdef SOS_CPU_STATE_DETECT_UNINIT_KERNEL_VARS
+ memset((void*)stack_bottom, SOS_CPU_STATE_STACK_POISON, stack_size);
+#elif defined(SOS_CPU_STATE_DETECT_KERNEL_STACK_OVERFLOW)
+ sos_cpu_state_prepare_detect_kernel_stack_overflow(stack_bottom, stack_size);
+#endif
+
+ /* Simulate a call to the core_routine() function: prepare its
+ arguments */
+ *(--stack) = exit_arg;
+ *(--stack) = (sos_ui32_t)exit_func;
+ *(--stack) = start_arg;
+ *(--stack) = (sos_ui32_t)start_func;
+ *(--stack) = 0; /* Return address of core_routine => force page fault */
+
+ /*
+ * Setup the initial context structure, so that the CPU will execute
+ * the function core_routine() once this new context has been
+ * restored on CPU
+ */
+
+ /* Compute the base address of the structure, which must be located
+ below the previous elements */
+ tmp_vaddr = ((sos_vaddr_t)stack) - sizeof(struct sos_cpu_kstate);
+ kctxt = (struct sos_cpu_kstate*)tmp_vaddr;
+
+ /* Initialize the CPU context structure */
+ memset(kctxt, 0x0, sizeof(struct sos_cpu_kstate));
+
+ /* Tell the CPU context structure that the first instruction to
+ execute will be that of the core_routine() function */
+ kctxt->regs.eip = (sos_ui32_t)core_routine;
+
+ /* Setup the segment registers */
+ kctxt->regs.cs
+ = SOS_BUILD_SEGMENT_REG_VALUE(0, FALSE, SOS_SEG_KCODE); /* Code */
+ kctxt->regs.ds
+ = SOS_BUILD_SEGMENT_REG_VALUE(0, FALSE, SOS_SEG_KDATA); /* Data */
+ kctxt->regs.es
+ = SOS_BUILD_SEGMENT_REG_VALUE(0, FALSE, SOS_SEG_KDATA); /* Data */
+ kctxt->regs.cpl0_ss
+ = SOS_BUILD_SEGMENT_REG_VALUE(0, FALSE, SOS_SEG_KDATA); /* Stack */
+ /* fs and gs unused for the moment. */
+
+ /* The newly created context is initially interruptible */
+ kctxt->regs.eflags = (1 << 9); /* set IF bit */
+
+ /* Finally, update the generic kernel/user thread context */
+ *ctxt = (struct sos_cpu_state*) kctxt;
+
+ return SOS_OK;
+}
+
+
+#if defined(SOS_CPU_STATE_DETECT_KERNEL_STACK_OVERFLOW)
+void
+sos_cpu_state_prepare_detect_kernel_stack_overflow(const struct sos_cpu_state *ctxt,
+ sos_vaddr_t stack_bottom,
+ sos_size_t stack_size)
+{
+ sos_size_t poison_size = SOS_CPU_STATE_DETECT_KERNEL_STACK_OVERFLOW;
+ if (poison_size > stack_size)
+ poison_size = stack_size;
+
+ memset((void*)stack_bottom, SOS_CPU_STATE_STACK_POISON, poison_size);
+}
+
+
+void
+sos_cpu_state_detect_kernel_stack_overflow(const struct sos_cpu_state *ctxt,
+ sos_vaddr_t stack_bottom,
+ sos_size_t stack_size)
+{
+ unsigned char *c;
+ int i;
+
+ /* On SOS, "ctxt" corresponds to the address of the esp register of
+ the saved context in Kernel mode (always, even for the interrupted
+ context of a user thread). Here we make sure that this stack
+ pointer is within the allowed stack area */
+ SOS_ASSERT_FATAL(((sos_vaddr_t)ctxt) >= stack_bottom);
+ SOS_ASSERT_FATAL(((sos_vaddr_t)ctxt) + sizeof(struct sos_cpu_kstate)
+ <= stack_bottom + stack_size);
+
+ /* Check that the bottom of the stack has not been altered */
+ for (c = (unsigned char*) stack_bottom, i = 0 ;
+ (i < SOS_CPU_STATE_DETECT_KERNEL_STACK_OVERFLOW) && (i < stack_size) ;
+ c++, i++)
+ {
+ SOS_ASSERT_FATAL(SOS_CPU_STATE_STACK_POISON == *c);
+ }
+}
+#endif
+
+
+/* =======================================================================
+ * Public Accessor functions
+ */
+
+
+sos_vaddr_t sos_cpu_context_get_PC(const struct sos_cpu_state *ctxt)
+{
+ SOS_ASSERT_FATAL(NULL != ctxt);
+
+ /* This is the PC of the interrupted context (ie kernel or user
+ context). */
+ return ctxt->eip;
+}
+
+
+sos_vaddr_t sos_cpu_context_get_SP(const struct sos_cpu_state *ctxt)
+{
+ SOS_ASSERT_FATAL(NULL != ctxt);
+
+ /* On SOS, "ctxt" corresponds to the address of the esp register of
+ the saved context in Kernel mode (always, even for the interrupted
+ context of a user thread). */
+ return (sos_vaddr_t)ctxt;
+}
+
+
+void sos_cpu_context_dump(const struct sos_cpu_state *ctxt)
+{
+ char buf[128];
+ snprintf(buf, sizeof(buf),
+ "CPU: eip=%x esp=%x eflags=%x cs=%x ds=%x ss=%x err=%x",
+ (unsigned)ctxt->eip, (unsigned)ctxt, (unsigned)ctxt->eflags,
+ (unsigned)GET_CPU_CS_REGISTER_VALUE(ctxt->cs), (unsigned)ctxt->ds,
+ (unsigned)ctxt->cpl0_ss,
+ (unsigned)ctxt->error_code);
+ sos_bochs_putstring(buf); sos_bochs_putstring("\n");
+ sos_x86_videomem_putstring(23, 0,
+ SOS_X86_VIDEO_FG_BLACK | SOS_X86_VIDEO_BG_LTGRAY,
+ buf);
+}
+
+
+/* =======================================================================
+ * Public Accessor functions TO BE USED ONLY BY Exception handlers
+ */
+
+
+sos_ui32_t sos_cpu_context_get_EX_info(const struct sos_cpu_state *ctxt)
+{
+ SOS_ASSERT_FATAL(NULL != ctxt);
+ return ctxt->error_code;
+}
+
+
+sos_vaddr_t
+sos_cpu_context_get_EX_faulting_vaddr(const struct sos_cpu_state *ctxt)
+{
+ sos_ui32_t cr2;
+
+ /*
+ * See Intel Vol 3 (section 5.14): the address of the faulting
+ * virtual address of a page fault is stored in the cr2
+ * register.
+ *
+ * Actually, we do not store the cr2 register in a saved
+ * kernel thread's context. So we retrieve the cr2's value directly
+ * from the processor. The value we retrieve in an exception handler
+ * is actually the correct one because an exception is synchronous
+ * with the code causing the fault, and cannot be interrupted since
+ * the IDT entries in SOS are "interrupt gates" (ie IRQ are
+ * disabled).
+ */
+ asm volatile ("movl %%cr2, %0"
+ :"=r"(cr2)
+ : );
+
+ return cr2;
+}
+
+
+/* =======================================================================
+ * Backtrace facility. To be used for DEBUGging purpose ONLY.
+ */
+
+
+sos_ui32_t sos_backtrace(const struct sos_cpu_state *cpu_state,
+ sos_ui32_t max_depth,
+ sos_vaddr_t stack_bottom,
+ sos_size_t stack_size,
+ sos_backtrace_callback_t * backtracer,
+ void *custom_arg)
+{
+ int depth;
+ sos_vaddr_t callee_PC, caller_frame;
+
+ /*
+ * Layout of a frame on the x86 (compiler=gcc):
+ *
+ * funcA calls funcB calls funcC
+ *
+ * ....
+ * funcB Argument 2
+ * funcB Argument 1
+ * funcA Return eip
+ * frameB: funcA ebp (ie previous stack frame)
+ * ....
+ * (funcB local variables)
+ * ....
+ * funcC Argument 2
+ * funcC Argument 1
+ * funcB Return eip
+ * frameC: funcB ebp (ie previous stack frame == A0) <---- a frame address
+ * ....
+ * (funcC local variables)
+ * ....
+ *
+ * The presence of "ebp" on the stack depends on 2 things:
+ * + the compiler is gcc
+ * + the source is compiled WITHOUT the -fomit-frame-pointer option
+ * In the absence of "ebp", chances are high that the value pushed
+ * at that address is outside the stack boundaries, meaning that the
+ * function will return -SOS_ENOSUP.
+ */
+
+ if (cpu_state)
+ {
+ callee_PC = cpu_state->eip;
+ caller_frame = cpu_state->ebp;
+ }
+ else
+ {
+ /* Skip the sos_backtrace() frame */
+ callee_PC = (sos_vaddr_t)__builtin_return_address(0);
+ caller_frame = (sos_vaddr_t)__builtin_frame_address(1);
+ }
+
+ for(depth=0 ; depth < max_depth ; depth ++)
+ {
+ /* Call the callback */
+ backtracer(callee_PC, caller_frame + 8, depth, custom_arg);
+
+ /* If the frame address is funky, don't go further */
+ if ( (caller_frame < stack_bottom)
+ || (caller_frame + 4 >= stack_bottom + stack_size) )
+ return depth;
+
+ /* Go to caller frame */
+ callee_PC = *((sos_vaddr_t*) (caller_frame + 4));
+ caller_frame = *((sos_vaddr_t*) caller_frame);
+ }
+
+ return depth;
+}
diff --git a/sos-code-article6.75/hwcore/cpu_context.h b/sos-code-article6.75/hwcore/cpu_context.h
new file mode 100644
index 0000000..43b3718
--- /dev/null
+++ b/sos-code-article6.75/hwcore/cpu_context.h
@@ -0,0 +1,270 @@
+/* Copyright (C) 2005 David Decotigny
+ Copyright (C) 2000-2004, The KOS team
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#ifndef _SOS_CPUCTXT_H_
+#define _SOS_CPUCTXT_H_
+
+
+/**
+ * @file cpu_context.h
+ *
+ * Low level API to manage kernel and user thread CPU contexts. Should
+ * be some kind of architecture-independent.
+ */
+
+#include <sos/types.h>
+#include <sos/errno.h>
+
+
+/**
+ * Opaque structure storing the CPU context of an inactive kernel or
+ * user thread, as saved by the low level primitives below or by the
+ * interrupt/exception handlers.
+ *
+ * @note This is an (architecture-independent) forward declaration:
+ * see cpu_context.c and the *.S files for its
+ * (architecture-dependent) definition.
+ */
+struct sos_cpu_state;
+
+
+/**
+ * The type of the functions passed as arguments to the Kernel thread
+ * related functions.
+ */
+typedef void (sos_cpu_kstate_function_arg1_t(sos_ui32_t arg1));
+
+
+/**
+ * Function to create an initial context for a kernel thread starting
+ * its execution at function start_func with the argument initial_arg,
+ * and having the stack defined by stack_bottom/stack_size. When the
+ * start_func function returns, the function exit_func is called with
+ * argument exit_arg.
+ *
+ * @param kctxt The kernel thread CPU context to initialize. The
+ * address of the newly-initialized struct sos_cpu_state will be
+ * stored in this variable. The contents of this struct sos_cpu_state
+ * are actually located /inside/ the stack.
+ *
+ * @param start_func The address of the first instruction that will be
+ * executed when this context will be first transferred on
+ * CPU. Practically speaking, this is the address of a function that
+ * is assumed to take 1 argument.
+ *
+ * @param start_arg The value that will be passed as the argument to
+ * start_func when the thread starts. The stack will be setup
+ * accordingly to simulate a real call to the function and really
+ * passing this arguement.
+ *
+ * @param stack_bottom The lowest address of the stack.
+ *
+ * @param stack_size The size of the stack.
+ *
+ * @param exit_func The address of the instruction executed after the
+ * function start_func has returned. This function takes 1 parameter
+ * as argument: exit_arg.
+ *
+ * @param exit_arg The argument passed to the function exit_func.
+ *
+ * @note the newly created context is INTERRUPTIBLE by default !
+ */
+sos_ret_t sos_cpu_kstate_init(struct sos_cpu_state **kctxt,
+ sos_cpu_kstate_function_arg1_t *start_func,
+ sos_ui32_t start_arg,
+ sos_vaddr_t stack_bottom,
+ sos_size_t stack_size,
+ sos_cpu_kstate_function_arg1_t *exit_func,
+ sos_ui32_t exit_arg);
+
+
+/**
+ * Function that performs an immediate context-switch from one
+ * kernel/user thread to another one. It stores the current executing
+ * context in from_ctxt, and restores to_context on CPU.
+ *
+ * @param from_ctxt The address of the struct sos_cpu_state will be
+ * stored in this variable. Must NOT be NULL.
+ *
+ * @param to_ctxt The CPU will resume its execution with the struct
+ * sos_cpu_state located at this address. Must NOT be NULL.
+ */
+void sos_cpu_context_switch(struct sos_cpu_state **from_ctxt,
+ struct sos_cpu_state *to_ctxt);
+
+
+/*
+ * Switch to the new given context (of a kernel/user thread) without
+ * saving the old context (of another kernel/user thread), and call
+ * the function reclaiming_func passing it the recalining_arg
+ * argument. The reclaining function is called from within the stack
+ * of the new context, so that it can (among other things) safely
+ * destroy the stack of the former context.
+ *
+ * @param switch_to_ctxt The context that will be restored on the CPU
+ *
+ * @param reclaiming_func The address of the function that will be
+ * called after having changed the stack, but before restoring the CPU
+ * context to switch_to_ctxt.
+ */
+void
+sos_cpu_context_exit_to(struct sos_cpu_state *switch_to_ctxt,
+ sos_cpu_kstate_function_arg1_t *reclaiming_func,
+ sos_ui32_t reclaiming_arg) __attribute__((noreturn));
+
+/* =======================================================================
+ * Public Accessor functions
+ */
+
+
+/**
+ * Return Program Counter stored in the saved kernel/user context
+ */
+sos_vaddr_t sos_cpu_context_get_PC(const struct sos_cpu_state *ctxt);
+
+
+/**
+ * Return Stack Pointer stored in the saved kernel/user context
+ */
+sos_vaddr_t sos_cpu_context_get_SP(const struct sos_cpu_state *ctxt);
+
+
+/**
+ * Dump the contents of the CPU context (bochs + x86_videomem)
+ */
+void sos_cpu_context_dump(const struct sos_cpu_state *ctxt);
+
+
+/* =======================================================================
+ * Public Accessor functions TO BE USED ONLY BY Exception handlers
+ */
+
+
+/**
+ * Return the argument passed by the CPU upon exception, as stored in the
+ * saved context
+ */
+sos_ui32_t sos_cpu_context_get_EX_info(const struct sos_cpu_state *ctxt);
+
+
+/**
+ * Return the faulting address of the exception
+ */
+sos_vaddr_t
+sos_cpu_context_get_EX_faulting_vaddr(const struct sos_cpu_state *ctxt);
+
+
+/* =======================================================================
+ * Macros controlling stack poisoning.
+ * Stack poisoning can be used to detect:
+ * - unitialized local variables
+ * - when the thread might have gone too deep in the stack
+ */
+/** The signature of the poison */
+#define SOS_CPU_STATE_STACK_POISON 0xa5
+
+/**
+ * When set, mean that the whole stack is poisoned to detect use of
+ * unititialized variables
+ */
+#define SOS_CPU_STATE_DETECT_UNINIT_KERNEL_VARS
+/* #undef SOS_CPU_STATE_DETECT_UNINIT_KERNEL_VARS */
+
+/**
+ * When set, mean that the bottom of the stack is poisoned to detect
+ * probable stack overflow. Its value indicates the number of bytes
+ * used for this detection.
+ */
+#define SOS_CPU_STATE_DETECT_KERNEL_STACK_OVERFLOW 64
+/* #undef SOS_CPU_STATE_DETECT_KERNEL_STACK_OVERFLOW */
+
+#if defined(SOS_CPU_STATE_DETECT_KERNEL_STACK_OVERFLOW)
+void
+sos_cpu_state_prepare_detect_kernel_stack_overflow(const struct sos_cpu_state *ctxt,
+ sos_vaddr_t kernel_stack_bottom,
+ sos_size_t kernel_stack_size);
+void sos_cpu_state_detect_kernel_stack_overflow(const struct sos_cpu_state *ctxt,
+ sos_vaddr_t kernel_stack_bottom,
+ sos_size_t kernel_stack_size);
+#else
+# define sos_cpu_state_prepare_detect_kernel_stack_overflow(ctxt,stkbottom,stksize) \
+ ({ /* nop */ })
+# define sos_cpu_state_detect_kernel_stack_overflow(ctxt,stkbottom,stksize) \
+ ({ /* nop */ })
+#endif
+
+
+/* =======================================================================
+ * Backtrace facility. To be used for DEBUGging purpose ONLY.
+ */
+
+
+/**
+ * The function called at each step of the backtrace iterations
+ *
+ * @param PC The address of the next instruction of the function that
+ * will be executed
+ *
+ * @param params The address of the array of the parameteres that have
+ * been passed to the function considered
+ *
+ * @param depth The index of the iteration (ie the depth of the
+ * current frame into the stack)
+ *
+ * @param custom_arg Whatever you want: this is the argument passed as
+ * custom_arg to sos_backtrace()
+ */
+typedef void (sos_backtrace_callback_t)(sos_vaddr_t PC,
+ sos_vaddr_t params,
+ sos_ui32_t depth,
+ void *custom_arg);
+
+
+/**
+ * Call the backtracer callback on each frame stored in the cpu_state
+ *
+ * @param cpu_state The CPU context we want to explore. MUST be the
+ * context of a thread in Kernel mode, or NULL. When NULL: backtrace
+ * the current CPU context.
+ *
+ * @param max_depth The maximum number of frames to explore
+ *
+ * @param stack_bottom The lower boundary of the stack. This is used
+ * to make sure that the frame addresses fit inside the stack
+ * boudaries (ie are potentially correct).
+ *
+ * @param stack_size The size of the stack. Same comment.
+ *
+ * @param backtracer The function to call to handle the frame for each
+ * iteration
+ *
+ * @param custom_arg The arg passed as custom_arg to the backtracer
+ *
+ * @return The number of frames explored.
+ *
+ * @note Might be inaccurate when gcc's -fomit-frame-pointer has been
+ * used.
+ */
+sos_ui32_t sos_backtrace(const struct sos_cpu_state *cpu_state,
+ sos_ui32_t max_depth,
+ sos_vaddr_t stack_bottom,
+ sos_size_t stack_size,
+ sos_backtrace_callback_t * backtracer,
+ void *custom_arg);
+
+#endif /* _SOS_CPUCTXT_H_ */
diff --git a/sos-code-article6.75/hwcore/cpu_context_switch.S b/sos-code-article6.75/hwcore/cpu_context_switch.S
new file mode 100644
index 0000000..4499c91
--- /dev/null
+++ b/sos-code-article6.75/hwcore/cpu_context_switch.S
@@ -0,0 +1,128 @@
+/* Copyright (C) 2005 David Decotigny
+ Copyright (C) 2000-2004, The KOS team
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#define ASM_SOURCE 1
+
+
+.file "cpu_context_switch.S"
+
+.text
+
+
+.globl sos_cpu_context_switch
+.type sos_cpu_context_switch, @function
+sos_cpu_context_switch:
+ // arg2= to_context -- esp+64
+ // arg1= from_context -- esp+60
+ // caller ip -- esp+56
+ pushf // (eflags) esp+52
+ pushl %cs // (cs) esp+48
+ pushl $resume_pc // (ip) esp+44
+ pushl $0 // (error code) esp+40
+ pushl %ebp // esp+36
+ pushl %edi // esp+32
+ pushl %esi // esp+28
+ pushl %edx // esp+24
+ pushl %ecx // esp+20
+ pushl %ebx // esp+16
+ pushl %eax // esp+12
+ subl $2, %esp // (alignment) esp+10
+ pushw %ss // esp+8
+ pushw %ds // esp+6
+ pushw %es // esp+4
+ pushw %fs // esp+2
+ pushw %gs // esp
+
+ /*
+ * Now that the original eax/ebx are stored, we can use them safely
+ */
+
+ /* Store the address of the saved context */
+ movl 60(%esp), %ebx
+ movl %esp, (%ebx)
+
+ /* This is the proper context switch ! We change the stack here */
+ movl 64(%esp), %esp
+
+ /* Restore the CPU context */
+ popw %gs
+ popw %fs
+ popw %es
+ popw %ds
+ popw %ss
+ addl $2,%esp
+ popl %eax
+ popl %ebx
+ popl %ecx
+ popl %edx
+ popl %esi
+ popl %edi
+ popl %ebp
+ addl $4, %esp /* Ignore "error code" */
+
+ /* This restores the eflags, the cs and the eip registers */
+ iret /* equivalent to: popfl ; ret */
+
+resume_pc:
+ // Same context as that when sos_cpu_context_switch got called
+ // arg2= to_context -- esp+8
+ // arg1= from_context -- esp+4
+ // caller ip -- esp
+ ret
+
+
+
+/* ------------------------- */
+.globl sos_cpu_context_exit_to
+.type sos_cpu_context_exit_to, @function
+sos_cpu_context_exit_to:
+ // arg3= reclaiming_arg -- esp+12
+ // arg2= reclaiming_func -- esp+8
+ // arg1= to_context -- esp+4
+ // caller ip -- esp
+
+ /* Store the current SP in a temporary register */
+ movl %esp, %eax
+
+ /* This is the proper context switch ! We change the stack here */
+ movl 4(%eax), %esp
+
+ /* Call the reclaiming function (remember: the old frame address
+ is stored in eax) */
+ pushl 12(%eax)
+ call *8(%eax)
+ addl $4, %esp
+
+ /* Restore the CPU context */
+ popw %gs
+ popw %fs
+ popw %es
+ popw %ds
+ popw %ss
+ addl $2,%esp
+ popl %eax
+ popl %ebx
+ popl %ecx
+ popl %edx
+ popl %esi
+ popl %edi
+ popl %ebp
+ addl $4, %esp /* Ignore "error code" */
+
+ /* This restores the eflags, the cs and the eip registers */
+ iret /* equivalent to: popfl ; ret */
diff --git a/sos-code-article6.75/hwcore/exception.c b/sos-code-article6.75/hwcore/exception.c
new file mode 100644
index 0000000..ffad632
--- /dev/null
+++ b/sos-code-article6.75/hwcore/exception.c
@@ -0,0 +1,167 @@
+/* Copyright (C) 2004 David Decotigny
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#include "idt.h"
+#include "irq.h"
+
+#include <sos/assert.h>
+#include "exception.h"
+
+/* array of exception wrappers, defined in exception_wrappers.S */
+extern sos_vaddr_t sos_exception_wrapper_array[SOS_EXCEPT_NUM];
+
+/* arrays of exception handlers, shared with exception_wrappers.S */
+sos_exception_handler_t sos_exception_handler_array[SOS_EXCEPT_NUM] =
+ { NULL, };
+
+/* List of exception names for the x86 architecture */
+static const char * sos_x86_exnames[] = {
+ [SOS_EXCEPT_DIVIDE_ERROR] = "Division by zero",
+ [SOS_EXCEPT_DEBUG] = "Debug",
+ [SOS_EXCEPT_NMI_INTERRUPT] = "Non Maskable Interrupt",
+ [SOS_EXCEPT_BREAKPOINT] = "Breakpoint",
+ [SOS_EXCEPT_OVERFLOW] = "Overflow",
+ [SOS_EXCEPT_BOUND_RANGE_EXCEDEED] = "Bound Range Exceeded",
+ [SOS_EXCEPT_INVALID_OPCODE] = "Invalid Opcode",
+ [SOS_EXCEPT_DEVICE_NOT_AVAILABLE] = "Device Unavailable",
+ [SOS_EXCEPT_DOUBLE_FAULT] = "Double Fault",
+ [SOS_EXCEPT_COPROCESSOR_SEGMENT_OVERRUN] = "Coprocessor Segment Overrun",
+ [SOS_EXCEPT_INVALID_TSS] = "Invalid TSS",
+ [SOS_EXCEPT_SEGMENT_NOT_PRESENT] = "Segment Not Present",
+ [SOS_EXCEPT_STACK_SEGMENT_FAULT] = "Stack Segfault",
+ [SOS_EXCEPT_GENERAL_PROTECTION] = "General Protection",
+ [SOS_EXCEPT_PAGE_FAULT] = "Page Fault",
+ [SOS_EXCEPT_INTEL_RESERVED_1] = "INTEL1",
+ [SOS_EXCEPT_FLOATING_POINT_ERROR] = "FP Error",
+ [SOS_EXCEPT_ALIGNEMENT_CHECK] = "Alignment Check",
+ [SOS_EXCEPT_MACHINE_CHECK] = "Machine Check",
+ [SOS_EXCEPT_INTEL_RESERVED_2] = "INTEL2",
+ [SOS_EXCEPT_INTEL_RESERVED_3] = "INTEL3",
+ [SOS_EXCEPT_INTEL_RESERVED_4] = "INTEL4",
+ [SOS_EXCEPT_INTEL_RESERVED_5] = "INTEL5",
+ [SOS_EXCEPT_INTEL_RESERVED_6] = "INTEL6",
+ [SOS_EXCEPT_INTEL_RESERVED_7] = "INTEL7",
+ [SOS_EXCEPT_INTEL_RESERVED_8] = "INTEL8",
+ [SOS_EXCEPT_INTEL_RESERVED_9] = "INTEL9",
+ [SOS_EXCEPT_INTEL_RESERVED_10] = "INTEL10",
+ [SOS_EXCEPT_INTEL_RESERVED_11] = "INTEL11",
+ [SOS_EXCEPT_INTEL_RESERVED_12] = "INTEL12",
+ [SOS_EXCEPT_INTEL_RESERVED_13] = "INTEL13",
+ [SOS_EXCEPT_INTEL_RESERVED_14] = "INTEL14"
+};
+
+
+/* Catch-all exception handler */
+static void sos_generic_ex(int exid, const struct sos_cpu_state *ctxt)
+{
+ const char *exname = sos_exception_get_name(exid);
+
+ sos_display_fatal_error("Exception %s in Kernel at instruction 0x%x (info=%x)!\n",
+ exname,
+ sos_cpu_context_get_PC(ctxt),
+ (unsigned)sos_cpu_context_get_EX_info(ctxt));
+}
+
+
+sos_ret_t sos_exception_subsystem_setup(void)
+{
+ sos_ret_t retval;
+ int exid;
+
+ /* Setup the generic exception handler by default for everybody
+ except for the double fault exception */
+ for (exid = 0 ; exid < SOS_EXCEPT_NUM ; exid ++)
+ {
+ /* Skip double fault (see below) */
+ if (exid == SOS_EXCEPT_DOUBLE_FAULT)
+ continue;
+
+ retval = sos_exception_set_routine(exid, sos_generic_ex);
+ if (SOS_OK != retval)
+ return retval;
+ }
+
+
+ /* We inidicate that the double fault exception handler is defined,
+ and give its address. this handler is a do-nothing handler (see
+ exception_wrappers.S), and it can NOT be overriden by the
+ functions below */
+ return sos_idt_set_handler(SOS_EXCEPT_BASE + SOS_EXCEPT_DOUBLE_FAULT,
+ (sos_vaddr_t) sos_exception_wrapper_array[SOS_EXCEPT_DOUBLE_FAULT],
+ 0 /* CPL0 routine */);
+}
+
+
+sos_ret_t sos_exception_set_routine(int exception_number,
+ sos_exception_handler_t routine)
+{
+ sos_ret_t retval;
+ sos_ui32_t flags;
+
+ if ((exception_number < 0) || (exception_number >= SOS_EXCEPT_NUM))
+ return -SOS_EINVAL;
+
+ /* Double fault not supported */
+ if (exception_number == SOS_EXCEPT_DOUBLE_FAULT)
+ return -SOS_ENOSUP;
+
+ sos_disable_IRQs(flags);
+
+ retval = SOS_OK;
+
+ /* Set the exception routine to be called by the exception wrapper */
+ sos_exception_handler_array[exception_number] = routine;
+
+ /* If the exception is to be enabled, update the IDT with the exception
+ wrapper */
+ if (routine != NULL)
+ retval
+ = sos_idt_set_handler(SOS_EXCEPT_BASE + exception_number,
+ (sos_vaddr_t) sos_exception_wrapper_array[exception_number],
+ 0 /* CPL0 routine */);
+ else /* Disable the IDT entry */
+ retval
+ = sos_idt_set_handler(SOS_EXCEPT_BASE + exception_number,
+ (sos_vaddr_t)NULL /* No routine => disable IDTE */,
+ 0 /* don't care */);
+
+ sos_restore_IRQs(flags);
+ return retval;
+}
+
+
+sos_exception_handler_t sos_exception_get_routine(int exception_number)
+{
+ if ((exception_number < 0) || (exception_number >= SOS_EXCEPT_NUM))
+ return NULL;
+
+ /* Double fault not supported */
+ if (exception_number == SOS_EXCEPT_DOUBLE_FAULT)
+ return NULL;
+
+ /* Expected to be atomic */
+ return sos_exception_handler_array[exception_number];
+}
+
+
+const char * sos_exception_get_name(int exception_number)
+{
+ if ((exception_number < 0) || (exception_number >= SOS_EXCEPT_NUM))
+ return NULL;
+
+ return sos_x86_exnames[exception_number];
+}
diff --git a/sos-code-article6.75/hwcore/exception.h b/sos-code-article6.75/hwcore/exception.h
new file mode 100644
index 0000000..c58bbb2
--- /dev/null
+++ b/sos-code-article6.75/hwcore/exception.h
@@ -0,0 +1,83 @@
+/* Copyright (C) 2004 David Decotigny
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#ifndef _SOS_HWEXCEPT_H_
+#define _SOS_HWEXCEPT_H_
+
+/**
+ * @file exception.c
+ *
+ * Hardware exception routines management.
+ */
+
+#ifndef ASM_SOURCE
+# include <sos/errno.h>
+# include "cpu_context.h"
+#endif
+
+/**
+ * Standard Intel x86 exceptions.
+ *
+ * @see Intel x86 doc vol 3, section 5.12.
+ */
+#define SOS_EXCEPT_DIVIDE_ERROR 0 // No error code
+#define SOS_EXCEPT_DEBUG 1 // No error code
+#define SOS_EXCEPT_NMI_INTERRUPT 2 // No error code
+#define SOS_EXCEPT_BREAKPOINT 3 // No error code
+#define SOS_EXCEPT_OVERFLOW 4 // No error code
+#define SOS_EXCEPT_BOUND_RANGE_EXCEDEED 5 // No error code
+#define SOS_EXCEPT_INVALID_OPCODE 6 // No error code
+#define SOS_EXCEPT_DEVICE_NOT_AVAILABLE 7 // No error code
+#define SOS_EXCEPT_DOUBLE_FAULT 8 // Yes (Zero)
+#define SOS_EXCEPT_COPROCESSOR_SEGMENT_OVERRUN 9 // No error code
+#define SOS_EXCEPT_INVALID_TSS 10 // Yes
+#define SOS_EXCEPT_SEGMENT_NOT_PRESENT 11 // Yes
+#define SOS_EXCEPT_STACK_SEGMENT_FAULT 12 // Yes
+#define SOS_EXCEPT_GENERAL_PROTECTION 13 // Yes
+#define SOS_EXCEPT_PAGE_FAULT 14 // Yes
+#define SOS_EXCEPT_INTEL_RESERVED_1 15 // No
+#define SOS_EXCEPT_FLOATING_POINT_ERROR 16 // No
+#define SOS_EXCEPT_ALIGNEMENT_CHECK 17 // Yes (Zero)
+#define SOS_EXCEPT_MACHINE_CHECK 18 // No
+#define SOS_EXCEPT_INTEL_RESERVED_2 19 // No
+#define SOS_EXCEPT_INTEL_RESERVED_3 20 // No
+#define SOS_EXCEPT_INTEL_RESERVED_4 21 // No
+#define SOS_EXCEPT_INTEL_RESERVED_5 22 // No
+#define SOS_EXCEPT_INTEL_RESERVED_6 23 // No
+#define SOS_EXCEPT_INTEL_RESERVED_7 24 // No
+#define SOS_EXCEPT_INTEL_RESERVED_8 25 // No
+#define SOS_EXCEPT_INTEL_RESERVED_9 26 // No
+#define SOS_EXCEPT_INTEL_RESERVED_10 27 // No
+#define SOS_EXCEPT_INTEL_RESERVED_11 28 // No
+#define SOS_EXCEPT_INTEL_RESERVED_12 29 // No
+#define SOS_EXCEPT_INTEL_RESERVED_13 30 // No
+#define SOS_EXCEPT_INTEL_RESERVED_14 31 // No
+
+#ifndef ASM_SOURCE
+
+typedef void (*sos_exception_handler_t)(int exception_number,
+ const struct sos_cpu_state *cpu_kstate);
+
+sos_ret_t sos_exception_subsystem_setup(void);
+sos_ret_t sos_exception_set_routine(int exception_number,
+ sos_exception_handler_t routine);
+sos_exception_handler_t sos_exception_get_routine(int exception_number);
+
+const char * sos_exception_get_name(int exception_number);
+#endif /* ! ASM_SOURCE */
+
+#endif /* _SOS_HWEXCEPT_H_ */
diff --git a/sos-code-article6.75/hwcore/exception_wrappers.S b/sos-code-article6.75/hwcore/exception_wrappers.S
new file mode 100644
index 0000000..369614a
--- /dev/null
+++ b/sos-code-article6.75/hwcore/exception_wrappers.S
@@ -0,0 +1,221 @@
+/* Copyright (C) 2004 The KOS Team
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#include "exception.h"
+
+.file "exception_wrappers.S"
+
+.text
+
+/* The address of the table of handlers (defined in exception.c) */
+.extern sos_exception_handler_array
+
+/* The address of the table of wrappers (defined below, and shared
+ with exception.c */
+.globl sos_exception_wrapper_array
+
+/**
+ * For exceptions with/without error code, refer to Intel x86 doc vol 3,
+ * section 5.12
+ */
+
+/* These wrappers are for exceptions without error code */
+.irp id, \
+ SOS_EXCEPT_DIVIDE_ERROR, \
+ SOS_EXCEPT_DEBUG, \
+ SOS_EXCEPT_NMI_INTERRUPT, \
+ SOS_EXCEPT_BREAKPOINT, \
+ SOS_EXCEPT_OVERFLOW, \
+ SOS_EXCEPT_BOUND_RANGE_EXCEDEED, \
+ SOS_EXCEPT_INVALID_OPCODE, \
+ SOS_EXCEPT_DEVICE_NOT_AVAILABLE, \
+ SOS_EXCEPT_COPROCESSOR_SEGMENT_OVERRUN, \
+ SOS_EXCEPT_INTEL_RESERVED_1, \
+ SOS_EXCEPT_FLOATING_POINT_ERROR, \
+ SOS_EXCEPT_MACHINE_CHECK, \
+ SOS_EXCEPT_INTEL_RESERVED_2, \
+ SOS_EXCEPT_INTEL_RESERVED_3, \
+ SOS_EXCEPT_INTEL_RESERVED_4, \
+ SOS_EXCEPT_INTEL_RESERVED_5, \
+ SOS_EXCEPT_INTEL_RESERVED_6, \
+ SOS_EXCEPT_INTEL_RESERVED_7, \
+ SOS_EXCEPT_INTEL_RESERVED_8, \
+ SOS_EXCEPT_INTEL_RESERVED_9, \
+ SOS_EXCEPT_INTEL_RESERVED_10, \
+ SOS_EXCEPT_INTEL_RESERVED_11, \
+ SOS_EXCEPT_INTEL_RESERVED_12, \
+ SOS_EXCEPT_INTEL_RESERVED_13, \
+ SOS_EXCEPT_INTEL_RESERVED_14
+
+ .p2align 2, 0x90
+ sos_exception_wrapper_\id:
+ .type sos_exception_wrapper_\id,@function
+
+ /* Fake error code */
+ pushl $0
+ /* Backup the context */
+ pushl %ebp
+ movl %esp, %ebp
+
+ pushl %edi
+ pushl %esi
+ pushl %edx
+ pushl %ecx
+ pushl %ebx
+ pushl %eax
+ subl $2,%esp
+ pushw %ss
+ pushw %ds
+ pushw %es
+ pushw %fs
+ pushw %gs
+
+ /*
+ * Call the handler with the exception number and the
+ * address of the stored CPU context as arguments
+ */
+ pushl %esp
+ pushl $\id
+ leal sos_exception_handler_array,%edi
+ call *\id*4(%edi)
+ /* Unallocate the arguments passed to the handler */
+ addl $8, %esp
+
+ /* Restore the context */
+ popw %gs
+ popw %fs
+ popw %es
+ popw %ds
+ popw %ss
+ addl $2,%esp
+ popl %eax
+ popl %ebx
+ popl %ecx
+ popl %edx
+ popl %esi
+ popl %edi
+
+ popl %ebp
+ /* Remove fake error code */
+ addl $4, %esp
+ iret
+.endr
+
+ /* These wrappers are for exceptions with error code */
+.irp id, \
+ SOS_EXCEPT_INVALID_TSS, \
+ SOS_EXCEPT_SEGMENT_NOT_PRESENT, \
+ SOS_EXCEPT_STACK_SEGMENT_FAULT, \
+ SOS_EXCEPT_GENERAL_PROTECTION, \
+ SOS_EXCEPT_PAGE_FAULT, \
+ SOS_EXCEPT_ALIGNEMENT_CHECK
+
+ .p2align 2, 0x90
+ sos_exception_wrapper_\id:
+ .type sos_exception_wrapper_\id,@function
+
+ /* ret eflags */
+ /* ret cs */
+ /* ret eip */
+ /* Error code */
+
+ /* Backup the context */
+ pushl %ebp
+ movl %esp, %ebp
+
+ pushl %edi
+ pushl %esi
+ pushl %edx
+ pushl %ecx
+ pushl %ebx
+ pushl %eax
+ subl $2,%esp
+ pushw %ss
+ pushw %ds
+ pushw %es
+ pushw %fs
+ pushw %gs
+
+ /*
+ * Call the handler with the exception number and the
+ * address of the stored CPU context as arguments
+ */
+ pushl %esp
+ pushl $\id
+ leal sos_exception_handler_array,%edi
+ call *\id*4(%edi)
+ /* Unallocate the arguments passed to the handler */
+ addl $8, %esp
+
+ /* Restore the context */
+ popw %gs
+ popw %fs
+ popw %es
+ popw %ds
+ popw %ss
+ addl $2,%esp
+ popl %eax
+ popl %ebx
+ popl %ecx
+ popl %edx
+ popl %esi
+ popl %edi
+ popl %ebp
+
+ /* Error code isn't compatible with iretd */
+ addl $4, %esp
+
+ iret
+.endr
+
+
+/* Double fault handler not supported. We must define it since we
+ define an entry for it in the sos_exception_wrapper_array. It
+ simply uses an alternate stack to display a message and stop the
+ system. qemu won't handle it correctly (see comment in qemu's
+ sources). */
+#define ALTERNATE_DOUBLE_FAULT_STACK_SIZE 512
+.irp id, SOS_EXCEPT_DOUBLE_FAULT
+.p2align 2, 0x90
+sos_exception_wrapper_\id:
+.type sos_exception_wrapper_\id,@function
+1: cli /* Not necessary */
+ movl $double_fault_alternate_stack, %eax
+ addl $ALTERNATE_DOUBLE_FAULT_STACK_SIZE, %eax
+ movl %eax, %esp
+ pushl $msg_double_fault_not_supported
+ call sos_display_fatal_error ; jmp 1b /* Not necessary */
+.endr
+
+.section ".rodata"
+msg_double_fault_not_supported:
+ .string "exception_wrappers.S: Double fault detected ! NOT SUPPORTED yet. System Halted."
+
+/* Build the sos_irq_wrapper_array, shared with interrupt.c */
+.p2align 5, 0x0
+sos_exception_wrapper_array:
+ .irp id, 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15, \
+ 16,17,18,19,20,21,22,23,24,25,26,27,29,30,31
+ .long (sos_exception_wrapper_\id)
+ .endr
+
+/* Alternate stack for double fault handler */
+.bss
+.p2align 2, 0x0
+.size double_fault_alternate_stack, ALTERNATE_DOUBLE_FAULT_STACK_SIZE
+double_fault_alternate_stack:
+ .fill ALTERNATE_DOUBLE_FAULT_STACK_SIZE, 1, 0x0
diff --git a/sos-code-article6.75/hwcore/gdt.c b/sos-code-article6.75/hwcore/gdt.c
new file mode 100644
index 0000000..781c9ca
--- /dev/null
+++ b/sos-code-article6.75/hwcore/gdt.c
@@ -0,0 +1,152 @@
+/* Copyright (C) 2004 David Decotigny
+ Copyright (C) 2003 Thomas Petazzoni
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#include "segment.h"
+
+#include "gdt.h"
+
+
+/**
+ * The sructure of a segment descriptor.
+ *
+ * @see Intel x86 doc, Vol 3, section 3.4.3, figure 3-8. For segment
+ * types, see section 3.5
+ */
+struct x86_segment_descriptor
+{
+ /* Lowest dword */
+ sos_ui16_t limit_15_0; /* Segment limit, bits 15..0 */
+ sos_ui16_t base_paged_addr_15_0; /* Base address, bits 15..0 */
+
+ /* Highest dword */
+ sos_ui8_t base_paged_addr_23_16; /* Base address bits 23..16 */
+ sos_ui8_t segment_type:4; /* Section 3.4.3.1 (code/data)
+ and 3.5 (system) of Intel x86 vol 3 */
+ sos_ui8_t descriptor_type:1; /* 0=system, 1=Code/Data */
+ sos_ui8_t dpl:2; /* Descriptor privilege level */
+ sos_ui8_t present:1;
+
+ sos_ui8_t limit_19_16:4; /* Segment limit, bits 19..16 */
+ sos_ui8_t custom:1;
+ sos_ui8_t zero:1;
+ sos_ui8_t op_size:1; /* 0=16bits instructions, 1=32bits */
+ sos_ui8_t granularity:1; /* 0=limit in bytes, 1=limit in pages */
+
+ sos_ui8_t base_paged_addr_31_24; /* Base address bits 31..24 */
+} __attribute__ ((packed, aligned (8)));
+
+
+/**
+ * The GDT register, which stores the address and size of the
+ * GDT.
+ *
+ * @see Intel x86 doc vol 3, section 2.4, figure 2-4; and section
+ * 3.5.1
+ */
+struct x86_gdt_register {
+ /* The maximum GDT offset allowed to access an entry in the GDT */
+ sos_ui16_t limit;
+
+ /* This is not exactly a "virtual" address, ie an adddress such as
+ those of instructions and data; this is a "linear" address, ie an
+ address in the paged memory. However, in SOS we configure the
+ segmented memory as a "flat" space: the 0-4GB segment-based (ie
+ "virtual") addresses directly map to the 0-4GB paged memory (ie
+ "linear"), so that the "linear" addresses are numerically equal
+ to the "virtual" addresses: this base_addr will thus be the same
+ as the address of the gdt array */
+ sos_ui32_t base_addr;
+} __attribute__((packed, aligned(8)));
+
+
+/**
+ * Helper macro that builds a Segment descriptor for the virtual
+ * 0..4GB addresses to be mapped to the linear 0..4GB linear
+ * addresses.
+ */
+#define BUILD_GDTE(descr_privilege_level,is_code) \
+ ((struct x86_segment_descriptor) { \
+ .limit_15_0= 0xffff, \
+ .base_paged_addr_15_0= 0, \
+ .base_paged_addr_23_16= 0, \
+ .segment_type= ((is_code)?0xb:0x3), \
+ /* With descriptor_type (below) = 1 (code/data), \
+ * see Figure 3-1 of section 3.4.3.1 in Intel \
+ * x86 vol 3: \
+ * - Code (bit 3 = 1): \
+ * bit 0: 1=Accessed \
+ * bit 1: 1=Readable \
+ * bit 2: 0=Non-Conforming \
+ * - Data (bit 3 = 0): \
+ * bit 0: 1=Accessed \
+ * bit 1: 1=Writable \
+ * bit 2: 0=Expand up (stack-related) \
+ * For Conforming/non conforming segments, see \
+ * Intel x86 Vol 3 section 4.8.1.1 \
+ */ \
+ .descriptor_type= 1, /* 1=Code/Data */ \
+ .dpl= ((descr_privilege_level) & 0x3), \
+ .present= 1, \
+ .limit_19_16= 0xf, \
+ .custom= 0, \
+ .op_size= 1, /* 32 bits instr/data */ \
+ .granularity= 1 /* limit is in 4kB Pages */ \
+ })
+
+
+/** The actual GDT */
+static struct x86_segment_descriptor gdt[] = {
+ [SOS_SEG_NULL] = (struct x86_segment_descriptor){ 0, },
+ [SOS_SEG_KCODE] = BUILD_GDTE(0, 1),
+ [SOS_SEG_KDATA] = BUILD_GDTE(0, 0),
+};
+
+sos_ret_t sos_gdt_subsystem_setup(void)
+{
+ struct x86_gdt_register gdtr;
+
+ /* Address of the GDT */
+ gdtr.base_addr = (sos_ui32_t) gdt;
+
+ /* The limit is the maximum offset in bytes from the base address of
+ the GDT */
+ gdtr.limit = sizeof(gdt) - 1;
+
+ /* Commit the GDT into the CPU, and update the segment
+ registers. The CS register may only be updated with a long jump
+ to an absolute address in the given segment (see Intel x86 doc
+ vol 3, section 4.8.1). */
+ asm volatile ("lgdt %0 \n\
+ ljmp %1,$1f \n\
+ 1: \n\
+ movw %2, %%ax \n\
+ movw %%ax, %%ss \n\
+ movw %%ax, %%ds \n\
+ movw %%ax, %%es \n\
+ movw %%ax, %%fs \n\
+ movw %%ax, %%gs"
+ :
+ :"m"(gdtr),
+ "i"(SOS_BUILD_SEGMENT_REG_VALUE(0, FALSE, SOS_SEG_KCODE)),
+ "i"(SOS_BUILD_SEGMENT_REG_VALUE(0, FALSE, SOS_SEG_KDATA))
+ :"memory","eax");
+
+ return SOS_OK;
+}
+
+
diff --git a/sos-code-article6.75/hwcore/gdt.h b/sos-code-article6.75/hwcore/gdt.h
new file mode 100644
index 0000000..323b784
--- /dev/null
+++ b/sos-code-article6.75/hwcore/gdt.h
@@ -0,0 +1,42 @@
+/* Copyright (C) 2004 David Decotigny
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#ifndef _SOS_GDT_H_
+#define _SOS_GDT_H_
+
+/**
+ * @file gdt.h
+ *
+ * The routines that manage the GDT, the table that maps the virtual
+ * addresses (data/instructions, segment-relative), to "linear"
+ * addresses (ie paged-memory). In SOS/x86, we use a "flat" virtual
+ * space, ie the virtual and linear spaces are equivalent.
+ *
+ * @see Intel x86 doc vol 3, chapter 3
+ */
+
+#include <sos/types.h>
+#include <sos/errno.h>
+
+/**
+ * Configure the virtual space as a direct mapping to the linear
+ * address space (ie "flat" virtual space).
+ */
+sos_ret_t sos_gdt_subsystem_setup(void);
+
+
+#endif /* _SOS_GDT_H_ */
diff --git a/sos-code-article6.75/hwcore/i8254.c b/sos-code-article6.75/hwcore/i8254.c
new file mode 100644
index 0000000..5198129
--- /dev/null
+++ b/sos-code-article6.75/hwcore/i8254.c
@@ -0,0 +1,79 @@
+/* Copyright (C) 2004 The KOS Team
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#include <hwcore/ioports.h>
+
+#include "i8254.h"
+
+/** 82c54 clock frequency */
+#define I8254_MAX_FREQ 1193180
+
+/* Ports to communicate with the 82c54 */
+#define I8254_TIMER0 0x40
+#define I8254_TIMER1 0x41
+#define I8254_TIMER2 0x42
+#define I8254_CONTROL 0x43
+
+/**
+ * Configure the first timer of the 82c54 chip as a rate generator,
+ * which will raise an IRQ0 on a regular periodic basis, as given by
+ * the freq parameter. Second (RAM refresh) and third (speaker) timers
+ * are left unchanged. Maximum frequency is that of the 8254 clock, ie
+ * 1193180 Hz.
+ *
+ * Ahhh PC systems are nice toys: this maximum "strange" frequency
+ * equals that of the NTSC clock (14.31818 MHz) divided by 12. In
+ * turn, the famous 4.77 MHz cpu clock frequency of the first IBM PC
+ * is this same NTSC frequency divided by 3. Why the NTSC frequency as
+ * a base "standard" ? Because the 14.31818 MHz quartz were cheap at
+ * that time, and because it allows to simply drive altogether the
+ * cpu, the "time of day" timer, and the video signal generators.
+ */
+sos_ret_t sos_i8254_set_frequency(unsigned int freq)
+{
+ unsigned int nb_tick;
+
+ if (freq <= 0)
+ return -SOS_EINVAL;
+
+ /* Compute counter value */
+ nb_tick = I8254_MAX_FREQ / freq;
+
+ /* Counter must be between 1 and 65536 */
+ if (nb_tick > 65536)
+ return -SOS_EINVAL;
+ if (nb_tick <= 0)
+ return -SOS_EINVAL;
+
+ /* The i8254 interprets 0 to mean counter == 65536, because 65536
+ cannot be coded on 16bits */
+ if (nb_tick == 65536)
+ nb_tick = 0;
+
+ /* We want to configure timer0, we want to send both LSB+MSB to set
+ timer0 freq (-> 0x30), and we configure timer0 in mode 2, ie as a
+ rate generator (-> 0x4) ==> 0x34 */
+ outb(0x34, I8254_CONTROL);
+
+ /* Send LSB of counter first */
+ outb((nb_tick & 0xFF), I8254_TIMER0);
+
+ /* Send MSB of counter */
+ outb((nb_tick >> 8) & 0xFF, I8254_TIMER0);
+
+ return SOS_OK;
+}
diff --git a/sos-code-article6.75/hwcore/i8254.h b/sos-code-article6.75/hwcore/i8254.h
new file mode 100644
index 0000000..406b713
--- /dev/null
+++ b/sos-code-article6.75/hwcore/i8254.h
@@ -0,0 +1,35 @@
+/* Copyright (C) 2004 David Decotigny
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#ifndef _SOS_i8259_H_
+#define _SOS_i8259_H_
+
+#include <sos/errno.h>
+
+/**
+ * @file i8254.h PC programmable timer
+ *
+ * Programmable timer routines. See the Intel 82C54 datasheet (on kos
+ * website).
+ *
+ * @see i82C54 datasheet on Kos website.
+ */
+
+/** Change timer interrupt (IRQ 0) frequency */
+sos_ret_t sos_i8254_set_frequency(unsigned int freq);
+
+#endif /* _SOS_i8259_H_ */
diff --git a/sos-code-article6.75/hwcore/i8259.c b/sos-code-article6.75/hwcore/i8259.c
new file mode 100644
index 0000000..d6c6c60
--- /dev/null
+++ b/sos-code-article6.75/hwcore/i8259.c
@@ -0,0 +1,79 @@
+/* Copyright (C) 2004 The KOS Team
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#include "ioports.h"
+
+#include "i8259.h"
+
+#define PIC_MASTER 0x20
+#define PIC_SLAVE 0xa0
+
+/** Setup the 8259 PIC */
+sos_ret_t sos_i8259_subsystem_setup(void)
+{
+ /* Send ICW1: 8086 mode + NOT Single ctrl + call address
+ interval=8 */
+ outb(0x11, PIC_MASTER);
+ outb(0x11, PIC_SLAVE);
+
+ /* Send ICW2: ctrl base address */
+ outb(0x20, PIC_MASTER+1);
+ outb(0x28, PIC_SLAVE+1);
+
+ /* Send ICW3 master: mask where slaves are connected */
+ outb(0x4, PIC_MASTER+1);
+ /* Send ICW3 slave: index where the slave is connected on master */
+ outb(0x2, PIC_SLAVE+1);
+
+ /* Send ICW4: 8086 mode, fully nested, not buffered, no implicit EOI */
+ outb(0x1, PIC_MASTER+1);
+ outb(0x1, PIC_SLAVE+1);
+
+ /* Send OCW1:
+ * Closing all IRQs : waiting for a correct handler The only IRQ
+ * enabled is the cascade (that's why we use 0xFB for the master) */
+ outb(0xFB, PIC_MASTER+1);
+ outb(0xFF, PIC_SLAVE+1);
+
+ return SOS_OK;
+}
+
+
+sos_ret_t sos_i8259_enable_irq_line(int numirq)
+{
+ if(numirq < 8)
+ /* irq on master PIC */
+ outb((inb(PIC_MASTER+1) & ~(1 << numirq)), PIC_MASTER+1);
+ else
+ /* irq on slave PIC */
+ outb((inb(PIC_SLAVE+1) & ~(1 << (numirq-8))), PIC_SLAVE+1);
+
+ return SOS_OK;
+}
+
+
+sos_ret_t sos_i8259_disable_irq_line(int numirq)
+{
+ if(numirq < 8)
+ /* irq on master PIC */
+ outb((inb(PIC_MASTER+1) | (1 << numirq)), PIC_MASTER+1);
+ else
+ /* irq on slave PIC */
+ outb((inb(PIC_SLAVE+1) | (1 << (numirq-8))), PIC_SLAVE+1);
+
+ return SOS_OK;
+}
diff --git a/sos-code-article6.75/hwcore/i8259.h b/sos-code-article6.75/hwcore/i8259.h
new file mode 100644
index 0000000..0820524
--- /dev/null
+++ b/sos-code-article6.75/hwcore/i8259.h
@@ -0,0 +1,40 @@
+/* Copyright (C) 2004 David Decotigny
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#ifndef _SOS_i8259_H_
+#define _SOS_i8259_H_
+
+#include <sos/errno.h>
+
+/**
+ * @file i8259.h PIC
+ *
+ * PIC Management routines. See the Intel 8259A datasheet (on kos
+ * website), page 9+. Should be not be used directly: only interrupt.c
+ * should use this.
+ *
+ * @see i8259A datasheet on Kos website.
+ */
+
+/** Setup PIC and Disable all IRQ lines */
+sos_ret_t sos_i8259_subsystem_setup(void);
+
+sos_ret_t sos_i8259_enable_irq_line(int numirq);
+
+sos_ret_t sos_i8259_disable_irq_line(int numirq);
+
+#endif /* _SOS_i8259_H_ */
diff --git a/sos-code-article6.75/hwcore/idt.c b/sos-code-article6.75/hwcore/idt.c
new file mode 100644
index 0000000..07db4ab
--- /dev/null
+++ b/sos-code-article6.75/hwcore/idt.c
@@ -0,0 +1,159 @@
+/* Copyright (C) 2004 David Decotigny
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#include "segment.h"
+
+#include "idt.h"
+
+/**
+ * An entry in the IDT, or "IDTE" in the following, ie a reference to
+ * a interrupt/trap routine or a task gate to handle the sw/hw
+ * interrupts and exceptions.
+ *
+ * @see figure 5-2, intel x86 doc, vol 3
+ */
+struct x86_idt_entry
+{
+ /* Low dword */
+ sos_ui16_t offset_low; /* 15..0, offset of the routine in the segment */
+ sos_ui16_t seg_sel; /* 31..16, the ID of the segment */
+
+ /* High dword */
+ sos_ui8_t reserved:5; /* 4..0 */
+ sos_ui8_t flags:3; /* 7..5 */
+ sos_ui8_t type:3; /* 10..8 (interrupt gate, trap gate...) */
+ sos_ui8_t op_size:1; /* 11 (0=16bits instructions, 1=32bits instr.) */
+ sos_ui8_t zero:1; /* 12 */
+ sos_ui8_t dpl:2; /* 14..13 */
+ sos_ui8_t present:1; /* 15 */
+ sos_ui16_t offset_high; /* 31..16 */
+} __attribute__((packed));
+
+
+/**
+ * The IDT register, which stores the address and size of the
+ * IDT.
+ *
+ * @see Intel x86 doc vol 3, section 2.4, figure 2-4
+ */
+struct x86_idt_register
+{
+ /* The maximum GDT offset allowed to access an entry in the GDT */
+ sos_ui16_t limit;
+
+ /* This is not exactly a "virtual" address, ie an adddress such as
+ those of instructions and data; this is a "linear" address, ie an
+ address in the paged memory. However, in SOS we configure the
+ segmented memory as a "flat" space: the 0-4GB segment-based (ie
+ "virtual") addresses directly map to the 0-4GB paged memory (ie
+ "linear"), so that the "linear" addresses are numerically equal
+ to the "virtual" addresses: this base_addr will thus be the same
+ as the address of the gdt array */
+ sos_ui32_t base_addr;
+} __attribute__((packed, aligned (8)));
+
+
+static struct x86_idt_entry idt[SOS_IDTE_NUM];
+
+sos_ret_t sos_idt_subsystem_setup()
+{
+ struct x86_idt_register idtr;
+ int i;
+
+ for (i = 0 ;
+ i < SOS_IDTE_NUM ;
+ i++)
+ {
+ struct x86_idt_entry *idte = idt + i;
+
+ /* Setup an empty IDTE interrupt gate, see figure 5-2 in Intel
+ x86 doc, vol 3 */
+ idte->seg_sel = SOS_BUILD_SEGMENT_REG_VALUE(0, FALSE, SOS_SEG_KCODE);
+ idte->reserved = 0;
+ idte->flags = 0;
+ idte->type = 0x6; /* Interrupt gate (110b) */
+ idte->op_size = 1; /* 32bits instructions */
+ idte->zero = 0;
+
+ /* Disable this IDT entry for the moment */
+ sos_idt_set_handler(i, (sos_vaddr_t)NULL, 0/* Don't care */);
+ }
+
+ /*
+ * Setup the IDT register, see Intel x86 doc vol 3, section 5.8.
+ */
+
+ /* Address of the IDT */
+ idtr.base_addr = (sos_ui32_t) idt;
+
+ /* The limit is the maximum offset in bytes from the base address of
+ the IDT */
+ idtr.limit = sizeof(idt) - 1;
+
+ /* Commit the IDT into the CPU */
+ asm volatile ("lidt %0\n"::"m"(idtr):"memory");
+
+ return SOS_OK;
+}
+
+
+sos_ret_t sos_idt_set_handler(int index,
+ sos_vaddr_t handler_address,
+ int lowest_priviledge /* 0..3 */)
+{
+ struct x86_idt_entry *idte;
+
+ if ((index < 0) || (index >= SOS_IDTE_NUM))
+ return -SOS_EINVAL;
+ if ((lowest_priviledge < 0) || (lowest_priviledge > 3))
+ return -SOS_EINVAL;
+
+ idte = idt + index;
+ if (handler_address != (sos_vaddr_t)NULL)
+ {
+ idte->offset_low = handler_address & 0xffff;
+ idte->offset_high = (handler_address >> 16) & 0xffff;
+ idte->dpl = lowest_priviledge;
+ idte->present = 1; /* Yes, there is a handler */
+ }
+ else /* Disable this IDT entry */
+ {
+ idte->offset_low = 0;
+ idte->offset_high = 0;
+ idte->dpl = 0;
+ idte->present = 0; /* No, there is no handler */
+ }
+
+ return SOS_OK;
+}
+
+
+sos_ret_t sos_idt_get_handler(int index,
+ sos_vaddr_t *handler_address,
+ int *lowest_priviledge)
+{
+ if ((index < 0) || (index >= SOS_IDTE_NUM))
+ return -SOS_EINVAL;
+
+ if (handler_address != NULL)
+ *handler_address = idt[index].offset_low
+ | (idt[index].offset_high << 16);
+ if (lowest_priviledge != NULL)
+ *lowest_priviledge = idt[index].dpl;
+
+ return SOS_OK;
+}
diff --git a/sos-code-article6.75/hwcore/idt.h b/sos-code-article6.75/hwcore/idt.h
new file mode 100644
index 0000000..2d165b0
--- /dev/null
+++ b/sos-code-article6.75/hwcore/idt.h
@@ -0,0 +1,84 @@
+/* Copyright (C) 2004 David Decotigny
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#ifndef _SOS_IDT_H_
+#define _SOS_IDT_H_
+
+/**
+ * @file idt.h
+ *
+ * Manage the x86 Interrupt Descriptor Table, the table which maps the
+ * hardware interrupt lines, hardware exceptions, and software
+ * interrupts, to software routines. We only define "interrupt gate"
+ * IDT entries. Don't use it directly; refer instead to interrupt.c,
+ * exceptions.c and syscall.c.
+ *
+ * @see Intel x86 doc, Vol 3, chapter 5
+ */
+
+#include <sos/errno.h>
+#include <sos/types.h>
+
+/* Mapping of the CPU exceptions in the IDT (imposed by Intel
+ standards) */
+#define SOS_EXCEPT_BASE 0
+#define SOS_EXCEPT_NUM 32
+#define SOS_EXCEPT_MAX (SOS_HWEXCEPT_BASE + SOS_HWEXCEPT_NUM - 1)
+
+/* Mapping of the IRQ lines in the IDT */
+#define SOS_IRQ_BASE 32
+#define SOS_IRQ_NUM 16
+#define SOS_IRQ_MAX (SOS_IRQ_BASE + SOS_IRQ_NUM - 1)
+
+/**
+ * Number of IDT entries.
+ *
+ * @note Must be large enough to map the hw interrupts, the exceptions
+ * (=> total is 48 entries), and the syscall(s). Since our syscall
+ * will be 0x42, it must be >= 0x43. Intel doc limits this to 256
+ * entries, we use this limit.
+ */
+#define SOS_IDTE_NUM 256 /* 0x100 */
+
+/** Initialization routine: all the IDT entries (or "IDTE") are marked
+ "not present". */
+sos_ret_t sos_idt_subsystem_setup(void);
+
+/**
+ * Enable the IDT entry if handler_address != NULL, with the given
+ * lowest_priviledge.\ Disable the IDT entry when handler_address ==
+ * NULL (the lowest_priviledge parameter is then ignored). Intel doc
+ * says that there must not be more than 256 entries.
+ *
+ * @note IRQ Unsafe
+ */
+sos_ret_t sos_idt_set_handler(int index,
+ sos_vaddr_t handler_address,
+ int lowest_priviledge /* 0..3 */);
+
+
+/**
+ * @note IRQ Unsafe
+ *
+ * @return the handler address and DPL in the 2nd and 3rd
+ * parameters
+ */
+sos_ret_t sos_idt_get_handler(int index,
+ sos_vaddr_t *handler_address,
+ int *lowest_priviledge);
+
+#endif /* _SOS_IDT_H_ */
diff --git a/sos-code-article6.75/hwcore/ioports.h b/sos-code-article6.75/hwcore/ioports.h
new file mode 100644
index 0000000..69c6d15
--- /dev/null
+++ b/sos-code-article6.75/hwcore/ioports.h
@@ -0,0 +1,46 @@
+/* Copyright (C) 2004 All GPL'ed OS
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#ifndef _SOS_IOPORTS_H_
+#define _SOS_IOPORTS_H_
+
+/**
+ * @ioports.h
+ *
+ * Intel-specific I/O space access routines.
+ */
+
+/* This macro allows to write to an I/O port */
+#define outb(value, port) \
+ __asm__ volatile ( \
+ "outb %b0,%w1" \
+ ::"a" (value),"Nd" (port) \
+ ) \
+
+// read one byte from port
+#define inb(port) \
+({ \
+ unsigned char _v; \
+ __asm__ volatile ( \
+ "inb %w1,%0" \
+ :"=a" (_v) \
+ :"Nd" (port) \
+ ); \
+ _v; \
+})
+
+#endif /* _SOS_IOPORTS_H_ */
diff --git a/sos-code-article6.75/hwcore/irq.c b/sos-code-article6.75/hwcore/irq.c
new file mode 100644
index 0000000..6722027
--- /dev/null
+++ b/sos-code-article6.75/hwcore/irq.c
@@ -0,0 +1,100 @@
+/* Copyright (C) 2004 David Decotigny
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#include "idt.h"
+#include "i8259.h"
+
+#include "irq.h"
+
+/** array of IRQ wrappers, defined in irq_wrappers.S */
+extern sos_vaddr_t sos_irq_wrapper_array[SOS_IRQ_NUM];
+
+/** arrays of IRQ handlers, shared with irq_wrappers.S */
+sos_irq_handler_t sos_irq_handler_array[SOS_IRQ_NUM] = { NULL, };
+
+/** Number of interrupt handlers that are currently executing */
+sos_ui32_t sos_irq_nested_level_counter;
+
+sos_ret_t sos_irq_subsystem_setup(void)
+{
+ sos_irq_nested_level_counter = 0;
+ return sos_i8259_subsystem_setup();
+}
+
+
+sos_ret_t sos_irq_set_routine(int irq_level,
+ sos_irq_handler_t routine)
+{
+ sos_ret_t retval;
+ sos_ui32_t flags;
+
+ if ((irq_level < 0) || (irq_level >= SOS_IRQ_NUM))
+ return -SOS_EINVAL;
+
+ sos_disable_IRQs(flags);
+
+ retval = SOS_OK;
+
+ /* Set the irq routine to be called by the IRQ wrapper */
+ sos_irq_handler_array[irq_level] = routine;
+
+ /* If the irq is to be enabled, update the IDT with the IRQ
+ wrapper */
+ if (routine != NULL)
+ {
+ retval
+ = sos_idt_set_handler(SOS_IRQ_BASE + irq_level,
+ (sos_vaddr_t) sos_irq_wrapper_array[irq_level],
+ 0 /* CPL0 routine */);
+ /* A problem occured */
+ if (retval != SOS_OK)
+ sos_irq_handler_array[irq_level] = NULL;
+ }
+ else /* Disable this idt entry */
+ {
+ retval
+ = sos_idt_set_handler(SOS_IRQ_BASE + irq_level,
+ (sos_vaddr_t)NULL /* Disable IDTE */,
+ 0 /* Don't care */);
+ }
+
+ /* Update the PIC only if an IRQ handler has been set */
+ if (sos_irq_handler_array[irq_level] != NULL)
+ sos_i8259_enable_irq_line(irq_level);
+ else
+ sos_i8259_disable_irq_line(irq_level);
+
+ sos_restore_IRQs(flags);
+ return retval;
+}
+
+
+sos_irq_handler_t sos_irq_get_routine(int irq_level)
+{
+ if ((irq_level < 0) || (irq_level >= SOS_IRQ_NUM))
+ return NULL;
+
+ /* Expected to be atomic */
+ return sos_irq_handler_array[irq_level];
+}
+
+
+sos_ui32_t sos_irq_get_nested_level()
+{
+ /* No need to disable interrupts here */
+ return sos_irq_nested_level_counter;
+}
diff --git a/sos-code-article6.75/hwcore/irq.h b/sos-code-article6.75/hwcore/irq.h
new file mode 100644
index 0000000..c067cc4
--- /dev/null
+++ b/sos-code-article6.75/hwcore/irq.h
@@ -0,0 +1,97 @@
+/* Copyright (C) 2004 David Decotigny
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#ifndef _SOS_HWINTR_H_
+#define _SOS_HWINTR_H_
+
+
+/**
+ * @file irq.c
+ *
+ * Hardware interrupts routines management.
+ */
+
+
+#include <sos/errno.h>
+#include "cpu_context.h"
+
+
+#define sos_save_flags(flags) \
+ asm volatile("pushfl ; popl %0":"=g"(flags)::"memory")
+#define sos_restore_flags(flags) \
+ asm volatile("push %0; popfl"::"g"(flags):"memory")
+
+
+#define sos_disable_IRQs(flags) \
+ ({ sos_save_flags(flags); asm("cli\n"); })
+#define sos_restore_IRQs(flags) \
+ sos_restore_flags(flags)
+
+
+/* Usual IRQ levels */
+#define SOS_IRQ_TIMER 0
+#define SOS_IRQ_KEYBOARD 1
+#define SOS_IRQ_SLAVE_PIC 2
+#define SOS_IRQ_COM2 3
+#define SOS_IRQ_COM1 4
+#define SOS_IRQ_LPT2 5
+#define SOS_IRQ_FLOPPY 6
+#define SOS_IRQ_LPT1 7
+#define SOS_IRQ_8_NOT_DEFINED 8
+#define SOS_IRQ_RESERVED_1 9
+#define SOS_IRQ_RESERVED_2 10
+#define SOS_IRQ_RESERVED_3 11
+#define SOS_IRQ_RESERVED_4 12
+#define SOS_IRQ_COPROCESSOR 13
+#define SOS_IRQ_HARDDISK 14
+#define SOS_IRQ_RESERVED_5 15
+
+
+/** Definition of an hardware IRQ handler */
+typedef void (*sos_irq_handler_t)(int irq_level);
+
+
+/** Setup the PIC */
+sos_ret_t sos_irq_subsystem_setup(void);
+
+
+/**
+ * If the routine is not NULL, the IDT is setup to call an IRQ
+ * wrapper upon interrupt, which in turn will call the routine, and
+ * the PIC is programmed to raise an irq.\ If the routine is
+ * NULL, we disable the irq line.
+ */
+sos_ret_t sos_irq_set_routine(int irq_level,
+ sos_irq_handler_t routine);
+
+sos_irq_handler_t sos_irq_get_routine(int irq_level);
+
+
+/**
+ * Tell how many nested IRQ handler have been fired
+ */
+sos_ui32_t sos_irq_get_nested_level();
+
+
+/**
+ * Return TRUE when we are currently executing in interrupt context
+ */
+#define sos_servicing_irq() \
+ (sos_irq_get_nested_level() > 0)
+
+
+#endif /* _SOS_HWINTR_H_ */
diff --git a/sos-code-article6.75/hwcore/irq_wrappers.S b/sos-code-article6.75/hwcore/irq_wrappers.S
new file mode 100644
index 0000000..8945123
--- /dev/null
+++ b/sos-code-article6.75/hwcore/irq_wrappers.S
@@ -0,0 +1,220 @@
+/* Copyright (C) 2004 The KOS Team
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+
+.file "irq_wrappers.S"
+
+.text
+
+/** The address of the table of handlers (defined in irq.c) */
+.extern sos_irq_handler_array
+
+/** The address of the table of wrappers (defined below, and shared
+ with irq.c */
+.globl sos_irq_wrapper_array
+
+/** The variable holding the nested level of the IRQ handlers */
+.extern sos_irq_nested_level_counter
+
+/* These pre-handlers are for IRQ (Master PIC) */
+.irp id, 0,1,2,3,4,5,6,7
+
+ .p2align 2, 0x90
+
+ sos_irq_wrapper_\id:
+ .type sos_irq_wrapper_\id,@function
+
+ /*
+ * Backup the CPU context
+ */
+
+ /* Fake error code */
+ pushl $0
+
+ /* Backup the actual context */
+ pushl %ebp
+ movl %esp, %ebp
+
+ pushl %edi
+ pushl %esi
+ pushl %edx
+ pushl %ecx
+ pushl %ebx
+ pushl %eax
+ subl $2,%esp
+ pushw %ss
+ pushw %ds
+ pushw %es
+ pushw %fs
+ pushw %gs
+
+ /*
+ * Increment IRQ nested level
+ */
+ incl sos_irq_nested_level_counter
+
+ /* Send EOI to PIC. See Intel 8259 datasheet
+ available on Kos website */
+ movb $0x20, %al
+ outb %al, $0x20
+
+ /*
+ * Call the handler with IRQ number as argument
+ */
+ pushl $\id
+ leal sos_irq_handler_array,%edi
+ call *\id*4(%edi)
+ addl $4, %esp
+
+ /*
+ * Decrement IRQ nested level
+ */
+ cli /* Just in case we messed up everything in the handler */
+ subl $1, sos_irq_nested_level_counter
+
+ /* sos_irq_nested_level_counter went below 0 ?! */
+ jnc 2f
+
+ 1: /* Yes: Print fatal error message */
+ pushl $msg_nested_level_overflow
+ call sos_display_fatal_error
+ addl $4, %esp ; jmp 1b
+ /* Never returns */
+
+ 2: /* No: all right ! */
+
+ /* Restore the context */
+ popw %gs
+ popw %fs
+ popw %es
+ popw %ds
+ popw %ss
+ addl $2,%esp
+ popl %eax
+ popl %ebx
+ popl %ecx
+ popl %edx
+ popl %esi
+ popl %edi
+ popl %ebp
+
+ /* Remove fake error code */
+ addl $4, %esp
+
+ iret
+ .endr
+
+
+/* These pre-handlers are for IRQ (Slave PIC) */
+.irp id, 8,9,10,11,12,13,14,15
+
+ .p2align 2, 0x90
+
+ sos_irq_wrapper_\id:
+ .type sos_irq_wrapper_\id,@function
+
+ /*
+ * Backup the CPU context
+ */
+
+ /* Fake error code */
+ pushl $0
+
+ /* Backup the actual context */
+ pushl %ebp
+ movl %esp, %ebp
+
+ pushl %edi
+ pushl %esi
+ pushl %edx
+ pushl %ecx
+ pushl %ebx
+ pushl %eax
+ subl $2,%esp
+ pushw %ss
+ pushw %ds
+ pushw %es
+ pushw %fs
+ pushw %gs
+
+ /*
+ * Increment IRQ nested level
+ */
+ incl sos_irq_nested_level_counter
+
+ /* Send EOI to PIC. See Intel 8259 datasheet
+ available on Kos website */
+ movb $0x20, %al
+ outb %al, $0xa0
+ outb %al, $0x20
+
+ /*
+ * Call the handler with IRQ number as argument
+ */
+ pushl $\id
+ leal sos_irq_handler_array,%edi
+ call *\id*4(%edi)
+ addl $4, %esp
+
+ /*
+ * Decrement IRQ nested level
+ */
+ cli /* Just in case we messed up everything in the handler */
+ subl $1, sos_irq_nested_level_counter
+
+ /* sos_irq_nested_level_counter went below 0 ?! */
+ jnc 2f
+
+ 1: /* Yes: Print fatal error message */
+ pushl $msg_nested_level_overflow
+ call sos_display_fatal_error
+ addl $4, %esp ; jmp 1b
+ /* Never returns */
+
+ 2: /* No: all right ! */
+
+ /* Restore the context */
+ popw %gs
+ popw %fs
+ popw %es
+ popw %ds
+ popw %ss
+ addl $2,%esp
+ popl %eax
+ popl %ebx
+ popl %ecx
+ popl %edx
+ popl %esi
+ popl %edi
+ popl %ebp
+
+ /* Remove fake error code */
+ addl $4, %esp
+
+ iret
+ .endr
+
+.section ".rodata"
+msg_nested_level_overflow:
+ .string "irq_wrappers.S: IRQ Nested level overflow ! System halted."
+
+/* Build the sos_irq_wrapper_array, shared with irq.c */
+.p2align 5, 0x0
+sos_irq_wrapper_array:
+ .irp id, 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15
+ .long (sos_irq_wrapper_\id)
+ .endr
diff --git a/sos-code-article6.75/hwcore/paging.c b/sos-code-article6.75/hwcore/paging.c
new file mode 100644
index 0000000..11f3da6
--- /dev/null
+++ b/sos-code-article6.75/hwcore/paging.c
@@ -0,0 +1,465 @@
+/* Copyright (C) 2004 David Decotigny
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#include <sos/physmem.h>
+#include <sos/klibc.h>
+#include <sos/assert.h>
+
+#include "paging.h"
+
+
+/** The structure of a page directory entry. See Intel vol 3 section
+ 3.6.4 */
+struct x86_pde
+{
+ sos_ui32_t present :1; /* 1=PT mapped */
+ sos_ui32_t write :1; /* 0=read-only, 1=read/write */
+ sos_ui32_t user :1; /* 0=supervisor, 1=user */
+ sos_ui32_t write_through :1; /* 0=write-back, 1=write-through */
+ sos_ui32_t cache_disabled :1; /* 1=cache disabled */
+ sos_ui32_t accessed :1; /* 1=read/write access since last clear */
+ sos_ui32_t zero :1; /* Intel reserved */
+ sos_ui32_t page_size :1; /* 0=4kB, 1=4MB or 2MB (depending on PAE) */
+ sos_ui32_t global_page :1; /* Ignored (Intel reserved) */
+ sos_ui32_t custom :3; /* Do what you want with them */
+ sos_ui32_t pt_paddr :20;
+} __attribute__ ((packed));
+
+
+/** The structure of a page table entry. See Intel vol 3 section
+ 3.6.4 */
+struct x86_pte
+{
+ sos_ui32_t present :1; /* 1=PT mapped */
+ sos_ui32_t write :1; /* 0=read-only, 1=read/write */
+ sos_ui32_t user :1; /* 0=supervisor, 1=user */
+ sos_ui32_t write_through :1; /* 0=write-back, 1=write-through */
+ sos_ui32_t cache_disabled :1; /* 1=cache disabled */
+ sos_ui32_t accessed :1; /* 1=read/write access since last clear */
+ sos_ui32_t dirty :1; /* 1=write access since last clear */
+ sos_ui32_t zero :1; /* Intel reserved */
+ sos_ui32_t global_page :1; /* 1=No TLB invalidation upon cr3 switch
+ (when PG set in cr4) */
+ sos_ui32_t custom :3; /* Do what you want with them */
+ sos_ui32_t paddr :20;
+} __attribute__ ((packed));
+
+
+/** Structure of the x86 CR3 register: the Page Directory Base
+ Register. See Intel x86 doc Vol 3 section 2.5 */
+struct x86_pdbr
+{
+ sos_ui32_t zero1 :3; /* Intel reserved */
+ sos_ui32_t write_through :1; /* 0=write-back, 1=write-through */
+ sos_ui32_t cache_disabled :1; /* 1=cache disabled */
+ sos_ui32_t zero2 :7; /* Intel reserved */
+ sos_ui32_t pd_paddr :20;
+} __attribute__ ((packed));
+
+
+/**
+ * Helper macro to control the MMU: invalidate the TLB entry for the
+ * page located at the given virtual address. See Intel x86 vol 3
+ * section 3.7.
+ */
+#define invlpg(vaddr) \
+ do { \
+ __asm__ __volatile__("invlpg %0"::"m"(*((unsigned *)(vaddr)))); \
+ } while(0)
+
+
+/**
+ * Helper macro to control the MMU: invalidate the whole TLB. See
+ * Intel x86 vol 3 section 3.7.
+ */
+#define flush_tlb() \
+ do { \
+ unsigned long tmpreg; \
+ asm volatile("movl %%cr3,%0\n\tmovl %0,%%cr3" :"=r" \
+ (tmpreg) : :"memory"); \
+ } while (0)
+
+
+/**
+ * Helper macro to compute the index in the PD for the given virtual
+ * address
+ */
+#define virt_to_pd_index(vaddr) \
+ (((unsigned)(vaddr)) >> 22)
+
+
+/**
+ * Helper macro to compute the index in the PT for the given virtual
+ * address
+ */
+#define virt_to_pt_index(vaddr) \
+ ( (((unsigned)(vaddr)) >> 12) & 0x3ff )
+
+
+/**
+ * Helper macro to compute the offset in the page for the given virtual
+ * address
+ */
+#define virt_to_page_offset(vaddr) \
+ (((unsigned)(vaddr)) & SOS_PAGE_MASK)
+
+
+/**
+ * Helper function to map a page in the pd.\ Suppose that the RAM
+ * is identity mapped to resolve PT actual (CPU) address from the PD
+ * entry
+ */
+static sos_ret_t paging_setup_map_helper(struct x86_pde * pd,
+ sos_paddr_t ppage,
+ sos_vaddr_t vaddr)
+{
+ /* Get the page directory entry and table entry index for this
+ address */
+ unsigned index_in_pd = virt_to_pd_index(vaddr);
+ unsigned index_in_pt = virt_to_pt_index(vaddr);
+
+ /* Make sure the page table was mapped */
+ struct x86_pte * pt;
+ if (pd[index_in_pd].present)
+ {
+ pt = (struct x86_pte*) (pd[index_in_pd].pt_paddr << 12);
+
+ /* If we allocate a new entry in the PT, increase its reference
+ count. This test will always be TRUE here, since the setup
+ routine scans the kernel pages in a strictly increasing
+ order: at each step, the map will result in the allocation of
+ a new PT entry. For the sake of clarity, we keep the test
+ here. */
+ if (! pt[index_in_pt].present)
+ sos_physmem_ref_physpage_at((sos_paddr_t)pt);
+
+ /* The previous test should always be TRUE */
+ else
+ SOS_ASSERT_FATAL(FALSE); /* indicate a fatal error */
+ }
+ else
+ {
+ /* No : allocate a new one */
+ pt = (struct x86_pte*) sos_physmem_ref_physpage_new(FALSE);
+ if (! pt)
+ return -SOS_ENOMEM;
+
+ memset((void*)pt, 0x0, SOS_PAGE_SIZE);
+
+ pd[index_in_pd].present = TRUE;
+ pd[index_in_pd].write = 1; /* It would be too complicated to
+ determine whether it
+ corresponds to a real R/W area
+ of the kernel code/data or
+ read-only */
+ pd[index_in_pd].pt_paddr = ((sos_paddr_t)pt) >> 12;
+ }
+
+
+ /* Map the page in the page table */
+ pt[index_in_pt].present = 1;
+ pt[index_in_pt].write = 1; /* It would be too complicated to
+ determine whether it corresponds to
+ a real R/W area of the kernel
+ code/data or R/O only */
+ pt[index_in_pt].user = 0;
+ pt[index_in_pt].paddr = ppage >> 12;
+
+ return SOS_OK;
+}
+
+
+sos_ret_t sos_paging_subsystem_setup(sos_paddr_t identity_mapping_base,
+ sos_paddr_t identity_mapping_top)
+{
+ /* The PDBR we will setup below */
+ struct x86_pdbr cr3;
+
+ /* Get the PD for the kernel */
+ struct x86_pde * pd
+ = (struct x86_pde*) sos_physmem_ref_physpage_new(FALSE);
+
+ /* The iterator for scanning the kernel area */
+ sos_paddr_t paddr;
+
+ /* Reset the PD. For the moment, there is still an IM for the whole
+ RAM, so that the paddr are also vaddr */
+ memset((void*)pd,
+ 0x0,
+ SOS_PAGE_SIZE);
+
+ /* Identity-map the identity_mapping_* area */
+ for (paddr = identity_mapping_base ;
+ paddr < identity_mapping_top ;
+ paddr += SOS_PAGE_SIZE)
+ {
+ if (paging_setup_map_helper(pd, paddr, paddr))
+ return -SOS_ENOMEM;
+ }
+
+ /* Identity-map the PC-specific BIOS/Video area */
+ for (paddr = BIOS_N_VIDEO_START ;
+ paddr < BIOS_N_VIDEO_END ;
+ paddr += SOS_PAGE_SIZE)
+ {
+ if (paging_setup_map_helper(pd, paddr, paddr))
+ return -SOS_ENOMEM;
+ }
+
+ /* Ok, kernel is now identity mapped in the PD. We still have to set
+ up the mirroring */
+ pd[virt_to_pd_index(SOS_PAGING_MIRROR_VADDR)].present = TRUE;
+ pd[virt_to_pd_index(SOS_PAGING_MIRROR_VADDR)].write = 1;
+ pd[virt_to_pd_index(SOS_PAGING_MIRROR_VADDR)].user = 0;
+ pd[virt_to_pd_index(SOS_PAGING_MIRROR_VADDR)].pt_paddr
+ = ((sos_paddr_t)pd)>>12;
+
+ /* We now just have to configure the MMU to use our PD. See Intel
+ x86 doc vol 3, section 3.6.3 */
+ memset(& cr3, 0x0, sizeof(struct x86_pdbr)); /* Reset the PDBR */
+ cr3.pd_paddr = ((sos_paddr_t)pd) >> 12;
+
+ /* Actual loading of the PDBR in the MMU: setup cr3 + bits 31[Paging
+ Enabled] and 16[Write Protect] of cr0, see Intel x86 doc vol 3,
+ sections 2.5, 3.6.1 and 4.11.3 + note table 4-2 */
+ asm volatile ("movl %0,%%cr3\n\t"
+ "movl %%cr0,%%eax\n\t"
+ "orl $0x80010000, %%eax\n\t" /* bit 31 | bit 16 */
+ "movl %%eax,%%cr0\n\t"
+ "jmp 1f\n\t"
+ "1:\n\t"
+ "movl $2f, %%eax\n\t"
+ "jmp *%%eax\n\t"
+ "2:\n\t" ::"r"(cr3):"memory","eax");
+
+ /*
+ * Here, the only memory available is:
+ * - The BIOS+video area
+ * - the identity_mapping_base .. identity_mapping_top area
+ * - the PD mirroring area (4M)
+ * All accesses to other virtual addresses will generate a #PF
+ */
+
+ return SOS_OK;
+}
+
+
+/* Suppose that the current address is configured with the mirroring
+ * enabled to access the PD and PT. */
+sos_ret_t sos_paging_map(sos_paddr_t ppage_paddr,
+ sos_vaddr_t vpage_vaddr,
+ sos_bool_t is_user_page,
+ sos_ui32_t flags)
+{
+ /* Get the page directory entry and table entry index for this
+ address */
+ unsigned index_in_pd = virt_to_pd_index(vpage_vaddr);
+ unsigned index_in_pt = virt_to_pt_index(vpage_vaddr);
+
+ /* Get the PD of the current context */
+ struct x86_pde *pd = (struct x86_pde*)
+ (SOS_PAGING_MIRROR_VADDR
+ + SOS_PAGE_SIZE*virt_to_pd_index(SOS_PAGING_MIRROR_VADDR));
+
+ /* Address of the PT in the mirroring */
+ struct x86_pte * pt = (struct x86_pte*) (SOS_PAGING_MIRROR_VADDR
+ + SOS_PAGE_SIZE*index_in_pd);
+
+ /* The mapping of anywhere in the PD mirroring is FORBIDDEN ;) */
+ if ((vpage_vaddr >= SOS_PAGING_MIRROR_VADDR)
+ && (vpage_vaddr < SOS_PAGING_MIRROR_VADDR + SOS_PAGING_MIRROR_SIZE))
+ return -SOS_EINVAL;
+
+ /* Map a page for the PT if necessary */
+ if (! pd[index_in_pd].present)
+ {
+
+ /* No : allocate a new one */
+ sos_paddr_t pt_ppage
+ = sos_physmem_ref_physpage_new(! (flags & SOS_VM_MAP_ATOMIC));
+ if (! pt_ppage)
+ {
+ return -SOS_ENOMEM;
+ }
+
+ pd[index_in_pd].present = TRUE;
+ pd[index_in_pd].write = 1; /* Ignored in supervisor mode, see
+ Intel vol 3 section 4.12 */
+ pd[index_in_pd].user = (is_user_page)?1:0;
+ pd[index_in_pd].pt_paddr = ((sos_paddr_t)pt_ppage) >> 12;
+
+ /*
+ * The PT is now mapped in the PD mirroring
+ */
+
+ /* Invalidate TLB for the page we just added */
+ invlpg(pt);
+
+ /* Reset this new PT */
+ memset((void*)pt, 0x0, SOS_PAGE_SIZE);
+ }
+
+ /* If we allocate a new entry in the PT, increase its reference
+ count. */
+ else if (! pt[index_in_pt].present)
+ sos_physmem_ref_physpage_at(pd[index_in_pd].pt_paddr << 12);
+
+ /* Otherwise, that means that a physical page is implicitely
+ unmapped */
+ else
+ sos_physmem_unref_physpage(pt[index_in_pt].paddr << 12);
+
+ /* Map the page in the page table */
+ pt[index_in_pt].present = TRUE;
+ pt[index_in_pt].write = (flags & SOS_VM_MAP_PROT_WRITE)?1:0;
+ pt[index_in_pt].user = (is_user_page)?1:0;
+ pt[index_in_pt].paddr = ppage_paddr >> 12;
+ sos_physmem_ref_physpage_at(ppage_paddr);
+
+ /*
+ * The page is now mapped in the current address space
+ */
+
+ /* Invalidate TLB for the page we just added */
+ invlpg(vpage_vaddr);
+
+ return SOS_OK;
+}
+
+
+sos_ret_t sos_paging_unmap(sos_vaddr_t vpage_vaddr)
+{
+ sos_ret_t pt_unref_retval;
+
+ /* Get the page directory entry and table entry index for this
+ address */
+ unsigned index_in_pd = virt_to_pd_index(vpage_vaddr);
+ unsigned index_in_pt = virt_to_pt_index(vpage_vaddr);
+
+ /* Get the PD of the current context */
+ struct x86_pde *pd = (struct x86_pde*)
+ (SOS_PAGING_MIRROR_VADDR
+ + SOS_PAGE_SIZE*virt_to_pd_index(SOS_PAGING_MIRROR_VADDR));
+
+ /* Address of the PT in the mirroring */
+ struct x86_pte * pt = (struct x86_pte*) (SOS_PAGING_MIRROR_VADDR
+ + SOS_PAGE_SIZE*index_in_pd);
+
+ /* No page mapped at this address ? */
+ if (! pd[index_in_pd].present)
+ return -SOS_EINVAL;
+ if (! pt[index_in_pt].present)
+ return -SOS_EINVAL;
+
+ /* The unmapping of anywhere in the PD mirroring is FORBIDDEN ;) */
+ if ((vpage_vaddr >= SOS_PAGING_MIRROR_VADDR)
+ && (vpage_vaddr < SOS_PAGING_MIRROR_VADDR + SOS_PAGING_MIRROR_SIZE))
+ return -SOS_EINVAL;
+
+ /* Reclaim the physical page */
+ sos_physmem_unref_physpage(pt[index_in_pt].paddr << 12);
+
+ /* Unmap the page in the page table */
+ memset(pt + index_in_pt, 0x0, sizeof(struct x86_pte));
+
+ /* Invalidate TLB for the page we just unmapped */
+ invlpg(vpage_vaddr);
+
+ /* Reclaim this entry in the PT, which may free the PT */
+ pt_unref_retval = sos_physmem_unref_physpage(pd[index_in_pd].pt_paddr << 12);
+ SOS_ASSERT_FATAL(pt_unref_retval >= 0);
+ if (pt_unref_retval == TRUE)
+ /* If the PT is now completely unused... */
+ {
+ union { struct x86_pde pde; sos_ui32_t ui32; } u;
+
+ /*
+ * Reset the PDE
+ */
+
+ /* Mark the PDE as unavailable */
+ u.ui32 = 0;
+
+ /* Update the PD */
+ pd[index_in_pd] = u.pde;
+
+ /* Update the TLB */
+ invlpg(pt);
+ }
+
+ return SOS_OK;
+}
+
+
+int sos_paging_get_prot(sos_vaddr_t vaddr)
+{
+ int retval;
+
+ /* Get the page directory entry and table entry index for this
+ address */
+ unsigned index_in_pd = virt_to_pd_index(vaddr);
+ unsigned index_in_pt = virt_to_pt_index(vaddr);
+
+ /* Get the PD of the current context */
+ struct x86_pde *pd = (struct x86_pde*)
+ (SOS_PAGING_MIRROR_VADDR
+ + SOS_PAGE_SIZE*virt_to_pd_index(SOS_PAGING_MIRROR_VADDR));
+
+ /* Address of the PT in the mirroring */
+ struct x86_pte * pt = (struct x86_pte*) (SOS_PAGING_MIRROR_VADDR
+ + SOS_PAGE_SIZE*index_in_pd);
+
+ /* No page mapped at this address ? */
+ if (! pd[index_in_pd].present)
+ return SOS_VM_MAP_PROT_NONE;
+ if (! pt[index_in_pt].present)
+ return SOS_VM_MAP_PROT_NONE;
+
+ /* Default access right of an available page is "read" on x86 */
+ retval = SOS_VM_MAP_PROT_READ;
+ if (pd[index_in_pd].write && pt[index_in_pt].write)
+ retval |= SOS_VM_MAP_PROT_WRITE;
+
+ return retval;
+}
+
+
+sos_paddr_t sos_paging_get_paddr(sos_vaddr_t vaddr)
+{
+ /* Get the page directory entry and table entry index for this
+ address */
+ unsigned index_in_pd = virt_to_pd_index(vaddr);
+ unsigned index_in_pt = virt_to_pt_index(vaddr);
+ unsigned offset_in_page = virt_to_page_offset(vaddr);
+
+ /* Get the PD of the current context */
+ struct x86_pde *pd = (struct x86_pde*)
+ (SOS_PAGING_MIRROR_VADDR
+ + SOS_PAGE_SIZE*virt_to_pd_index(SOS_PAGING_MIRROR_VADDR));
+
+ /* Address of the PT in the mirroring */
+ struct x86_pte * pt = (struct x86_pte*) (SOS_PAGING_MIRROR_VADDR
+ + SOS_PAGE_SIZE*index_in_pd);
+
+ /* No page mapped at this address ? */
+ if (! pd[index_in_pd].present)
+ return (sos_paddr_t)NULL;
+ if (! pt[index_in_pt].present)
+ return (sos_paddr_t)NULL;
+
+ return (pt[index_in_pt].paddr << 12) + offset_in_page;
+}
diff --git a/sos-code-article6.75/hwcore/paging.h b/sos-code-article6.75/hwcore/paging.h
new file mode 100644
index 0000000..24b9fc9
--- /dev/null
+++ b/sos-code-article6.75/hwcore/paging.h
@@ -0,0 +1,132 @@
+/* Copyright (C) 2004 David Decotigny
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#ifndef _SOS_PAGING_H_
+#define _SOS_PAGING_H_
+
+/**
+ * @file paging.h
+ *
+ * MMU management routines (arch-dependent). Setup the MMU without
+ * identity-mapping physical<->virtual addresses over the whole
+ * physical address space: a single, restricted and known, area is
+ * identity-mapped, the remaining kernel/user space is not. To access
+ * and manage the MMU translation tables (PD/PT on x86), we rely on a
+ * particular configuration, called "mirroring", where the top-level
+ * translation table (PD on x86) maps itself at a known and fixed (virtual)
+ * address. The only assumption for this to be possible is that the
+ * structure of the translation table entries are compatible at the
+ * different levels of vadddr->paddr translation process (PDE and PTE
+ * on x86 are Ok). Credits go to Christophe Avoinne for that.
+ */
+
+#include <sos/types.h>
+#include <sos/errno.h>
+
+
+/**
+ * Basic SOS virtual memory organization
+ */
+/** Frontier between kernel and user space virtual addresses */
+#define SOS_PAGING_BASE_USER_ADDRESS (0x40000000) /* 1GB */
+#define SOS_PAGING_TOP_USER_ADDRESS (0xFFFFFFFF) /* 4GB */
+
+/** Length of the space reserved for the mirroring in the kernel
+ virtual space */
+#define SOS_PAGING_MIRROR_SIZE (1 << 22) /* 1 PD = 1024 Page Tables = 4MB */
+
+/** Virtual address where the mirroring takes place */
+#define SOS_PAGING_MIRROR_VADDR \
+ (SOS_PAGING_BASE_USER_ADDRESS - SOS_PAGING_MIRROR_SIZE)
+
+
+/**
+ * sos_paging_map flags
+ */
+/** Usual virtual memory access rights */
+#define SOS_VM_MAP_PROT_NONE 0
+#define SOS_VM_MAP_PROT_READ (1<<0)
+#define SOS_VM_MAP_PROT_WRITE (1<<1)
+/* EXEC not supported */
+
+/** Mapping a page may involve an physical page allocation (for a new
+ PT), hence may potentially block */
+#define SOS_VM_MAP_ATOMIC (1<<31)
+
+
+/**
+ * Setup initial page directory structure where the kernel is
+ * identically-mapped, and the mirroring. This routine also
+ * identity-maps the BIOS and video areas, to allow some debugging
+ * text to be printed to the console. Finally, this routine installs
+ * the whole configuration into the MMU.
+ */
+sos_ret_t sos_paging_subsystem_setup(sos_paddr_t identity_mapping_base,
+ sos_paddr_t identity_mapping_top);
+
+/**
+ * Map the given physical page at the given virtual address in the
+ * current address space.
+ *
+ * @note *IMPORTANT*: The physical page ppage_paddr *MUST* have been
+ * referenced by the caller through either a call to
+ * sos_physmem_ref_physpage_new() or sos_physmem_ref_physpage_at(). It
+ * would work if this were untrue, but this would be INCORRECT (it is
+ * expected that one is owning the page before mapping it, or
+ * otherwise the page could have been stolen by an interrupt or
+ * another thread).
+ *
+ * @param ppage_paddr The address of a physical page (page-aligned)
+ * @param vpage_vaddr The address of the virtual page (page-aligned)
+ * @param is_user_page TRUE when the page is available from user space
+ * @param flags A mask made of SOS_VM_* bits
+ *
+ * @note Unless the SOS_VM_MAP_ATOMIC bit is set in the flags, the
+ * function may potentially block, because a physical page may be
+ * allocated for a new PT.
+ */
+sos_ret_t sos_paging_map(sos_paddr_t ppage_paddr,
+ sos_vaddr_t vpage_vaddr,
+ sos_bool_t is_user_page,
+ sos_ui32_t flags);
+
+/**
+ * Undo the mapping from vaddr to the underlying physical page (if any)
+ * @param vpage_vaddr The address of the virtual page (page-aligned)
+ */
+sos_ret_t sos_paging_unmap(sos_vaddr_t vpage_vaddr);
+
+/**
+ * Return the page protection flags (SOS_VM_MAP_PROT_*) associated
+ * with the address, or SOS_VM_MAP_PROT_NONE when page is not mapped
+ */
+int sos_paging_get_prot(sos_vaddr_t vaddr);
+
+/**
+ * Return the physical address of the given virtual address. Since page
+ * at physical addr 0 is not mapped, the NULL result means "page not
+ * mapped".
+ */
+sos_paddr_t sos_paging_get_paddr(sos_vaddr_t vaddr);
+
+/**
+ * Tell whether the address is physically mapped
+ */
+#define sos_paging_check_present(vaddr) \
+ (sos_paging_get_paddr(vaddr) != NULL)
+
+#endif /* _SOS_PAGING_H_ */
diff --git a/sos-code-article6.75/hwcore/segment.h b/sos-code-article6.75/hwcore/segment.h
new file mode 100644
index 0000000..4487216
--- /dev/null
+++ b/sos-code-article6.75/hwcore/segment.h
@@ -0,0 +1,70 @@
+/* Copyright (C) 2004 The SOS Team
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#ifndef _SOS_HWSEGS_H_
+#define _SOS_HWSEGS_H_
+
+/**
+ * @file segments.h
+ *
+ * Global and local (GDT/LDT) segment descriptor definition and
+ * structure. These segments map virtual addresses (ie
+ * data/instruction addresses, relative to these segment descriptors)
+ * to linear addresses (ie addresses in the paged-memory space).
+ *
+ * @see Intel x86 doc, vol 3 chapter 3.
+ */
+
+
+/*
+ * Global segment selectors (GDT) for SOS/x86.
+ *
+ * @see gdt.h
+ */
+#define SOS_SEG_NULL 0 /* NULL segment, unused by the procesor */
+#define SOS_SEG_KCODE 1 /* Kernel code segment */
+#define SOS_SEG_KDATA 2 /* Kernel data segment */
+
+
+#ifndef ASM_SOURCE
+/**
+ * Helper macro that builds a segment register's value
+ */
+#define SOS_BUILD_SEGMENT_REG_VALUE(desc_privilege,in_ldt,seg_index) \
+ ( (((desc_privilege) & 0x3) << 0) \
+ | (((in_ldt)?1:0) << 2) \
+ | ((seg_index) << 3) )
+#else
+/*
+ * Assembler-compliant version.
+ *
+ * Caution: In assembler code, "in_ldt" MUST be either 1 or 0, nothing
+ * else.
+ */
+#define SOS_BUILD_SEGMENT_REG_VALUE(desc_privilege,in_ldt,seg_index) \
+ ( (((desc_privilege) & 0x3) << 0) \
+ | ((in_ldt & 1) << 2) \
+ | ((seg_index) << 3) )
+#endif
+
+
+/*
+ * Local segment selectors (LDT) for SOS/x86
+ */
+/* None */
+
+#endif /* _SOS_HWSEGS_H_ */
diff --git a/sos-code-article6.75/sos.map b/sos-code-article6.75/sos.map
new file mode 100644
index 0000000..566ed06
--- /dev/null
+++ b/sos-code-article6.75/sos.map
@@ -0,0 +1,329 @@
+0020ae48 a.1066
+0020d700 active_queue
+00208153 _add_action
+00208581 add_in_ready_queue
+0020a70f AffectMovement
+0020d930 arg_b.1463
+0020d940 arg_c.1464
+0020d950 arg_d.1465
+0020d960 arg_e.1466
+0020d970 arg_R.1467
+0020d980 arg_S.1468
+00208f0c backtracer.1422
+00201000 __b_kernel
+00200000 __b_load
+0020aca8 bootstrap_stack_bottom
+0020acac bootstrap_stack_size
+00204ab7 cache_add_slab
+00204c08 cache_grow
+00204978 cache_initialize
+0020d6b0 cache_of_struct_kslab
+0020d6ac cache_of_struct_kslab_cache
+00204cfb cache_release_slab
+0020d6dc cache_thread
+00207395 _change_waitq_priorities
+0020d9b0 CheeseCount
+0020a41f ChoosePosition
+00208ecf clk_it
+0020d928 clock_count.1410
+002033e8 core_routine
+00204eaf create_cache_of_caches
+00204fd9 create_cache_of_ranges
+00209c09 CreateMap
+0020aa53 CreateMouse
+00203b02 create_range
+0020d6d4 current_thread
+00207009 delete_thread
+0020d92c demand_paging_count.1433
+0020924f demo_thread
+00208e44 display_bits
+0020d460 double_fault_alternate_stack
+00209cd4 DrawMap
+00209a78 DrawPixel
+00209070 dump_backtrace
+00212000 __e_kernel
+00209f31 ElementInit
+0020cbc7 __e_load
+0020a610 EvaluatePositions
+0020d704 expired_queue
+0020394e find_suitable_free_range
+002058fa free_object
+0020d6bc free_ppage
+0020acb0 gdt
+002038f8 get_closest_preceding_kmem_range
+002062be get_page_descr_at_paddr
+002097ac idle_thread
+0020cbe0 idt
+00209dfb InitMapInput
+00209e96 InitMapOutput
+0020399e insert_range
+0020a8a9 IsCollision
+0020ad80 kmalloc_cache
+0020d6a0 kmem_free_range_list
+0020d6a8 kmem_range_cache
+0020d6a4 kmem_used_range_list
+0020d6b4 kslab_cache_list
+002077ef _kwaitq_add_entry
+00207b02 _kwaitq_remove_entry
+0020d6ec last_tick_time
+00203a4b lookup_range
+00201011 loop
+00206697 memcmp
+00206640 memcpy
+00206671 memset
+0020a0f6 Mouse
+0020d9ac MouseCount
+0020aa12 MouseCreator
+0020a244 MouseMove
+00209ab4 MouseSim
+0020ae50 MouseSpeed
+0020b020 msg_double_fault_not_supported
+0020b100 msg_nested_level_overflow
+00201000 multiboot_entry
+00200000 multiboot_header
+0020d9b4 ObstacleCount
+0020248c paging_setup_map_helper
+002090e5 pgflt_ex
+0020d6b8 physical_page_descr_array
+0020d6c4 physmem_base
+0020d6c8 physmem_top
+0020d6cc physmem_total_pages
+0020d6d0 physmem_used_pages
+0020d990 pMap
+0020bc88 __PRETTY_FUNCTION__.1040
+0020b726 __PRETTY_FUNCTION__.1064
+0020b733 __PRETTY_FUNCTION__.1073
+0020b3d4 __PRETTY_FUNCTION__.1093
+0020c277 __PRETTY_FUNCTION__.1096
+0020b740 __PRETTY_FUNCTION__.1101
+0020b1df __PRETTY_FUNCTION__.1111
+0020b400 __PRETTY_FUNCTION__.1121
+0020bce8 __PRETTY_FUNCTION__.1124
+0020b42b __PRETTY_FUNCTION__.1131
+0020b75d __PRETTY_FUNCTION__.1132
+0020b442 __PRETTY_FUNCTION__.1136
+0020bac2 __PRETTY_FUNCTION__.1137
+0020b1f7 __PRETTY_FUNCTION__.1145
+0020b459 __PRETTY_FUNCTION__.1145
+0020bae0 __PRETTY_FUNCTION__.1177
+0020c372 __PRETTY_FUNCTION__.1188
+0020c385 __PRETTY_FUNCTION__.1206
+0020c1d3 __PRETTY_FUNCTION__.1211
+0020c39f __PRETTY_FUNCTION__.1224
+0020bb07 __PRETTY_FUNCTION__.1227
+0020c1e5 __PRETTY_FUNCTION__.1238
+0020bb1c __PRETTY_FUNCTION__.1242
+0020bb40 __PRETTY_FUNCTION__.1262
+0020c079 __PRETTY_FUNCTION__.1285
+0020c090 __PRETTY_FUNCTION__.1290
+0020cbb8 __PRETTY_FUNCTION__.1298
+0020c09d __PRETTY_FUNCTION__.1320
+0020cbc1 __PRETTY_FUNCTION__.1337
+0020c0ad __PRETTY_FUNCTION__.1338
+0020c0c4 __PRETTY_FUNCTION__.1349
+0020c0dd __PRETTY_FUNCTION__.1374
+0020c0eb __PRETTY_FUNCTION__.1384
+0020c8bb __PRETTY_FUNCTION__.1437
+0020c8c4 __PRETTY_FUNCTION__.1451
+0020c8d0 __PRETTY_FUNCTION__.1493
+0020ae44 q.1067
+0020ae4c r.1068
+00206888 random
+0020ae40 _random_seed
+002083ad _remove_action
+002038cf resume_pc
+0020d720 sched_queue
+0020d994 SemMap
+0020d9a0 SemMouse
+00206ccd _set_current
+0020b478 sizeof_struct_sos_kmem_range
+002074ff sleep_timeout
+00206c4a snprintf
+002037f0 sos_backtrace
+002032dd sos_bochs_hexdump
+002033a2 sos_bochs_printf
+002030c2 sos_bochs_putchar
+002030ff sos_bochs_puthex
+002030da sos_bochs_putstring
+002030b8 sos_bochs_setup
+002036c1 sos_cpu_context_dump
+002038d0 sos_cpu_context_exit_to
+002037df sos_cpu_context_get_EX_faulting_vaddr
+00203798 sos_cpu_context_get_EX_info
+00203636 sos_cpu_context_get_PC
+0020367d sos_cpu_context_get_SP
+0020388c sos_cpu_context_switch
+00203437 sos_cpu_kstate_init
+0020354f sos_cpu_state_detect_kernel_stack_overflow
+00203518 sos_cpu_state_prepare_detect_kernel_stack_overflow
+00206e37 sos_create_kernel_thread
+00208dcc sos_display_fatal_error
+00201382 sos_exception_get_name
+00201353 sos_exception_get_routine
+0020d3e0 sos_exception_handler_array
+002012c0 sos_exception_set_routine
+00201260 sos_exception_subsystem_setup
+002013a4 sos_exception_wrapper_0
+002013e8 sos_exception_wrapper_1
+00201a48 sos_exception_wrapper_10
+00201a8c sos_exception_wrapper_11
+00201ad0 sos_exception_wrapper_12
+00201b14 sos_exception_wrapper_13
+00201b58 sos_exception_wrapper_14
+00201608 sos_exception_wrapper_15
+0020164c sos_exception_wrapper_16
+00201b9c sos_exception_wrapper_17
+00201690 sos_exception_wrapper_18
+002016d4 sos_exception_wrapper_19
+0020142c sos_exception_wrapper_2
+00201718 sos_exception_wrapper_20
+0020175c sos_exception_wrapper_21
+002017a0 sos_exception_wrapper_22
+002017e4 sos_exception_wrapper_23
+00201828 sos_exception_wrapper_24
+0020186c sos_exception_wrapper_25
+002018b0 sos_exception_wrapper_26
+002018f4 sos_exception_wrapper_27
+00201938 sos_exception_wrapper_28
+0020197c sos_exception_wrapper_29
+00201470 sos_exception_wrapper_3
+002019c0 sos_exception_wrapper_30
+00201a04 sos_exception_wrapper_31
+002014b4 sos_exception_wrapper_4
+002014f8 sos_exception_wrapper_5
+0020153c sos_exception_wrapper_6
+00201580 sos_exception_wrapper_7
+00201be0 sos_exception_wrapper_8
+002015c4 sos_exception_wrapper_9
+0020b080 sos_exception_wrapper_array
+002011e4 sos_gdt_subsystem_setup
+00201218 sos_generic_ex
+00202e44 sos_i8254_set_frequency
+00202432 sos_i8259_disable_irq_line
+002023d4 sos_i8259_enable_irq_line
+00202384 sos_i8259_subsystem_setup
+00201174 sos_idt_get_handler
+002010b9 sos_idt_set_handler
+00201014 sos_idt_subsystem_setup
+00201cfe sos_irq_get_nested_level
+00201cdc sos_irq_get_routine
+0020d660 sos_irq_handler_array
+0020d9b8 sos_irq_nested_level_counter
+00201c13 sos_irq_set_routine
+00201bfc sos_irq_subsystem_setup
+00201d08 sos_irq_wrapper_0
+00201d6c sos_irq_wrapper_1
+00202114 sos_irq_wrapper_10
+0020217c sos_irq_wrapper_11
+002021e4 sos_irq_wrapper_12
+0020224c sos_irq_wrapper_13
+002022b4 sos_irq_wrapper_14
+0020231c sos_irq_wrapper_15
+00201dd4 sos_irq_wrapper_2
+00201e3c sos_irq_wrapper_3
+00201ea4 sos_irq_wrapper_4
+00201f0c sos_irq_wrapper_5
+00201f74 sos_irq_wrapper_6
+00201fdc sos_irq_wrapper_7
+00202044 sos_irq_wrapper_8
+002020ac sos_irq_wrapper_9
+0020b140 sos_irq_wrapper_array
+00205e4b sos_kfree
+00205da9 sos_kmalloc
+00205ce0 sos_kmalloc_subsystem_setup
+0020565e sos_kmem_cache_alloc
+002054cb sos_kmem_cache_create
+002055cf sos_kmem_cache_destroy
+00205bc8 sos_kmem_cache_free
+00205c11 sos_kmem_cache_release_struct_range
+002054af sos_kmem_cache_subsystem_setup_commit
+002050f1 sos_kmem_cache_subsystem_setup_prepare
+0020488b sos_kmem_vmm_alloc
+0020432f sos_kmem_vmm_del_range
+002048c2 sos_kmem_vmm_free
+00204954 sos_kmem_vmm_is_valid_vaddr
+002040cf sos_kmem_vmm_new_range
+0020492b sos_kmem_vmm_resolve_slab
+0020490b sos_kmem_vmm_set_slab
+00203d52 sos_kmem_vmm_subsystem_setup
+00208ca6 sos_kmutex_dispose
+00208c79 sos_kmutex_init
+00208cbc sos_kmutex_lock
+00208d22 sos_kmutex_trylock
+00208d5a sos_kmutex_unlock
+00208b88 sos_ksema_dispose
+00208b9e sos_ksema_down
+00208b5c sos_ksema_init
+00208bfb sos_ksema_trydown
+00208c36 sos_ksema_up
+00207ac2 sos_kwaitq_add_entry
+00207d87 sos_kwaitq_change_priority
+00207766 sos_kwaitq_dispose
+0020772c sos_kwaitq_init
+002077bd sos_kwaitq_init_entry
+00207795 sos_kwaitq_is_empty
+00207c64 sos_kwaitq_remove_entry
+00207c8e sos_kwaitq_wait
+00207d0a sos_kwaitq_wakeup
+002097e7 sos_main
+00202d87 sos_paging_get_paddr
+00202cd7 sos_paging_get_prot
+00202851 sos_paging_map
+002026c5 sos_paging_subsystem_setup
+00202b2f sos_paging_unmap
+002065b9 sos_physmem_get_kmem_range
+00206613 sos_physmem_get_state
+0020630b sos_physmem_ref_physpage_at
+00206151 sos_physmem_ref_physpage_new
+002065e2 sos_physmem_set_kmem_range
+00205e74 sos_physmem_subsystem_setup
+0020644e sos_physmem_unref_physpage
+00208958 sos_reschedule
+002087f5 sos_sched_change_priority
+00208769 sos_sched_set_ready
+00208544 sos_sched_subsystem_setup
+002070d2 sos_thread_exit
+002076ce sos_thread_force_unblock
+00206c80 sos_thread_get_current
+002071c9 sos_thread_get_priority
+002071e2 sos_thread_get_state
+00207434 sos_thread_set_priority
+0020755e sos_thread_sleep
+00206d2c sos_thread_subsystem_setup
+002074db sos_thread_yield
+00207ff1 sos_time_cmp
+00207e72 sos_time_dec
+002084d2 sos_time_do_tick
+00208121 sos_time_get_now
+002080bd sos_time_get_tick_resolution
+00207dcc sos_time_inc
+00208053 sos_time_is_zero
+0020836d sos_time_register_action_absolute
+0020832d sos_time_register_action_relative
+002080ef sos_time_set_tick_resolution
+00208077 sos_time_subsysem_setup
+002084ad sos_time_unregister_action
+0020ace0 sos_x86_exnames
+00202edc sos_x86_videomem_cls
+00203026 sos_x86_videomem_printf
+00202faf sos_x86_videomem_putchar
+00202f1f sos_x86_videomem_putstring
+00202ebc sos_x86_videomem_setup
+002068d5 srandom
+0020e000 stack
+00201000 start
+00201000 _start
+002067e5 strcmp
+002066f1 strlen
+00206827 strncmp
+00206716 strnlen
+0020679a strzcat
+00206749 strzcpy
+002071fb _switch_to_next_thread
+002095e4 test_thread
+0020d6d8 thread_list
+0020d6e4 tick_resolution
+0020d6e0 timeout_action_list
+0020d6c0 used_ppage
+0020ad60 video
+002068e2 vsnprintf
diff --git a/sos-code-article6.75/sos/assert.c b/sos-code-article6.75/sos/assert.c
new file mode 100644
index 0000000..2bc0d41
--- /dev/null
+++ b/sos-code-article6.75/sos/assert.c
@@ -0,0 +1,44 @@
+/* Copyright (C) 2004 The KOS Team
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+
+#include <sos/klibc.h>
+#include <drivers/bochs.h>
+#include <drivers/x86_videomem.h>
+
+#include "assert.h"
+
+void sos_display_fatal_error(const char *format, /* args */...)
+{
+ char buff[256];
+ va_list ap;
+
+ asm("cli\n"); /* disable interrupts -- x86 only */ \
+
+ va_start(ap, format);
+ vsnprintf(buff, sizeof(buff), format, ap);
+ va_end(ap);
+
+ sos_bochs_putstring(buff); sos_bochs_putstring("\n");
+ sos_x86_videomem_putstring(23, 0,
+ SOS_X86_VIDEO_BG_BLACK
+ | SOS_X86_VIDEO_FG_LTRED , buff);
+
+ /* Infinite loop: processor halted */
+ for ( ; ; )
+ asm("hlt\n");
+}
diff --git a/sos-code-article6.75/sos/assert.h b/sos-code-article6.75/sos/assert.h
new file mode 100644
index 0000000..9fcfec0
--- /dev/null
+++ b/sos-code-article6.75/sos/assert.h
@@ -0,0 +1,45 @@
+/* Copyright (C) 2004 The KOS Team
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#ifndef _SOS_ASSERT_H_
+#define _SOS_ASSERT_H_
+
+
+void sos_display_fatal_error(const char *format, /* args */...)
+ __attribute__ ((format (printf, 1, 2), noreturn));
+
+
+/**
+ * If the expr is FALSE, print a message and halt the machine
+ */
+#define SOS_ASSERT_FATAL(expr) \
+ ({ \
+ int __res=(int)(expr); \
+ if (! __res) \
+ sos_display_fatal_error("%s@%s:%d Assertion " # expr " failed", \
+ __PRETTY_FUNCTION__, __FILE__, __LINE__); \
+ })
+
+
+#define SOS_FATAL_ERROR(fmt,args...) \
+ ({ \
+ sos_display_fatal_error("%s@%s:%d FATAL: " fmt, \
+ __PRETTY_FUNCTION__, __FILE__, __LINE__, \
+ ##args); \
+ })
+
+#endif /* _SOS_ASSERT_H_ */
diff --git a/sos-code-article6.75/sos/errno.h b/sos-code-article6.75/sos/errno.h
new file mode 100644
index 0000000..fda5ed8
--- /dev/null
+++ b/sos-code-article6.75/sos/errno.h
@@ -0,0 +1,42 @@
+/* Copyright (C) 2004 The SOS Team
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#ifndef _SOS_ERRNO_H_
+#define _SOS_ERRNO_H_
+
+/**
+ * @file errno.h
+ *
+ * SOS return value codes and errors.
+ */
+
+/* Positive values of the error codes */
+#define SOS_OK 0 /* No error */
+#define SOS_EINVAL 1 /* Invalid argument */
+#define SOS_ENOSUP 2 /* Operation not supported */
+#define SOS_ENOMEM 3 /* No available memory */
+#define SOS_EBUSY 4 /* Object or device still in use */
+#define SOS_EINTR 5 /* Wait/Sleep has been interrupted */
+#define SOS_EPERM 6 /* Mutex/files ownership error */
+#define SOS_EFATAL 255 /* Internal fatal error */
+
+/* A negative value means that an error occured. For
+ * example -SOS_EINVAL means that the error was "invalid
+ * argument" */
+typedef int sos_ret_t;
+
+#endif /* _SOS_ERRNO_H_ */
diff --git a/sos-code-article6.75/sos/klibc.c b/sos-code-article6.75/sos/klibc.c
new file mode 100644
index 0000000..4442842
--- /dev/null
+++ b/sos-code-article6.75/sos/klibc.c
@@ -0,0 +1,308 @@
+/* Copyright (C) 2004 David Decotigny (with INSA Rennes for vsnprintf)
+ Copyright (C) 2003 The KOS Team
+ Copyright (C) 1999 Free Software Foundation
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#include "klibc.h"
+
+/* For an optimized version, see BSD sources ;) */
+void *memcpy(void *dst0, const void *src0, register unsigned int size)
+{
+ char *dst;
+ const char *src;
+ for (dst = (char*)dst0, src = (const char*)src0 ;
+ size > 0 ;
+ dst++, src++, size--)
+ *dst = *src;
+ return dst0;
+}
+
+/* ditto */
+void *memset(void *dst0, register int c, register unsigned int length)
+{
+ char *dst;
+ for (dst = (char*) dst0 ;
+ length > 0 ;
+ dst++, length --)
+ *dst = (char)c;
+ return dst0;
+}
+
+int memcmp(const void *s1, const void *s2, sos_size_t len)
+{
+ const unsigned char *c1, *c2;
+ unsigned int i;
+
+ for (i = 0, c1 = s1, c2 = s2; i < len; i++, c1++, c2++)
+ {
+ if(*c1 != *c2)
+ return *c1 - *c2;
+ }
+
+ return 0;
+}
+
+
+unsigned int strlen(register const char *str)
+{
+ unsigned int retval = 0;
+
+ while (*str++)
+ retval++;
+
+ return retval;
+}
+
+
+unsigned int strnlen(const char * s, sos_size_t count)
+{
+ const char *sc;
+
+ for (sc = s; count-- && *sc != '\0'; ++sc)
+ /* nothing */continue;
+
+ return sc - s;
+}
+
+
+char *strzcpy(register char *dst, register const char *src, register int len)
+{
+ int i;
+
+ if (len <= 0)
+ return dst;
+
+ for (i = 0; i < len; i++)
+ {
+ dst[i] = src[i];
+ if(src[i] == '\0')
+ return dst;
+ }
+
+ dst[len-1] = '\0';
+ return dst;
+}
+
+
+char *strzcat (char *dest, const char *src, sos_size_t n)
+{
+ char *res = dest;
+
+ for ( ; *dest ; dest++);
+
+ for ( ; *src ; src++, dest++) {
+ *dest = *src;
+ n--;
+ if (n <= 0)
+ break;
+ }
+
+ *dest = '\0';
+ return res;
+}
+
+int strcmp(register const char *s1, register const char *s2)
+{
+ while (*s1 == *s2++)
+ if (*s1++ == 0)
+ return (0);
+
+ return (*(const unsigned char *)s1 - *(const unsigned char *)(s2 - 1));
+}
+
+
+int strncmp(register const char *s1, register const char *s2, register int len)
+{
+ char c1 = '\0', c2 = '\0';
+
+ while (len > 0)
+ {
+ c1 = (unsigned char) *s1++;
+ c2 = (unsigned char) *s2++;
+ if (c1 == '\0' || c1 != c2)
+ return c1 - c2;
+ len--;
+ }
+
+ return c1 - c2;
+}
+
+
+static unsigned long int _random_seed = 93186752;
+
+/**
+ * The following code is borrowed from Glenn Rhoads.
+ * http://remus.rutgers.edu/~rhoads/Code/code.html
+ * License to be defined...
+ */
+unsigned long int random (void)
+{
+/* The following parameters are recommended settings based on research
+ uncomment the one you want. */
+
+/* For RAND_MAX == 4294967291 */
+ static unsigned int a = 1588635695, q = 2, r = 1117695901;
+/* static unsigned int a = 1223106847, m = 4294967291U, q = 3, r = 625646750;*/
+/* static unsigned int a = 279470273, m = 4294967291U, q = 15, r = 102913196;*/
+
+/* For RAND_MAX == 2147483647 */
+/* static unsigned int a = 1583458089, m = 2147483647, q = 1, r = 564025558; */
+/* static unsigned int a = 784588716, m = 2147483647, q = 2, r = 578306215; */
+/* static unsigned int a = 16807, m = 2147483647, q = 127773, r = 2836; */
+/* static unsigned int a = 950706376, m = 2147483647, q = 2, r = 246070895; */
+
+ _random_seed = a*(_random_seed % q) - r*(_random_seed / q);
+ return _random_seed;
+}
+
+
+void srandom (unsigned long int seed)
+{
+ _random_seed = seed;
+}
+
+
+/* I (d2) borrowed and rewrote this for Nachos/INSA Rennes. Thanks to
+ them for having kindly allowed me to do so. */
+int vsnprintf(char *buff, sos_size_t len, const char * format, va_list ap)
+{
+ sos_size_t i, result;
+
+ if (!buff || !format || (len < 0))
+ return -1;
+
+#define PUTCHAR(thechar) \
+ do { \
+ if (result < len-1) \
+ *buff++ = (thechar); \
+ result++; \
+ } while (0)
+
+ result = 0;
+ for(i=0 ; format[i] != '\0' ; i++){
+ switch (format[i])
+ {
+ case '%':
+ i++;
+ switch(format[i])
+ {
+ case '%':
+ {
+ PUTCHAR('%');
+ break;
+ }
+ case 'i':;
+ case 'd':
+ {
+ int integer = va_arg(ap,int);
+ int cpt2 = 0;
+ char buff_int[16];
+
+ if (integer<0)
+ PUTCHAR('-');
+ /* Ne fait pas integer = -integer ici parce que INT_MIN
+ n'a pas d'equivalent positif (int = [-2^31, 2^31-1]) */
+
+ do {
+ int m10 = integer%10;
+ m10 = (m10 < 0)? -m10:m10;
+ buff_int[cpt2++]=(char)('0'+ m10);
+ integer=integer/10;
+ } while(integer!=0);
+
+ for(cpt2 = cpt2 - 1 ; cpt2 >= 0 ; cpt2--)
+ PUTCHAR(buff_int[cpt2]);
+
+ break;
+ }
+
+ case 'c':
+ {
+ int value = va_arg(ap,int);
+ PUTCHAR((char)value);
+ break;
+ }
+
+ case 's':
+ {
+ char *string = va_arg(ap,char *);
+ if (! string)
+ string = "(null)";
+ for( ; *string != '\0' ; string++)
+ PUTCHAR(*string);
+ break;
+ }
+
+ case 'p':
+ PUTCHAR('0');
+ PUTCHAR('x');
+ case 'x':
+ {
+ unsigned int hexa = va_arg(ap,int);
+ unsigned int nb;
+ int i, had_nonzero = 0;
+ for(i=0 ; i < 8 ; i++)
+ {
+ nb = (unsigned int)(hexa << (i*4));
+ nb = (nb >> 28) & 0xf;
+ // Skip the leading zeros
+ if (nb == 0)
+ {
+ if (had_nonzero)
+ PUTCHAR('0');
+ }
+ else
+ {
+ had_nonzero = 1;
+ if (nb < 10)
+ PUTCHAR('0'+nb);
+ else
+ PUTCHAR('a'+(nb-10));
+ }
+ }
+ if (! had_nonzero)
+ PUTCHAR('0');
+ break;
+ }
+ break;
+
+ default:
+ PUTCHAR('%');
+ PUTCHAR(format[i]);
+ }
+ break;
+
+ default:
+ PUTCHAR(format[i]);
+ }
+ }
+
+ *buff = '\0';
+ return result;
+}
+
+
+int snprintf(char * buff, sos_size_t len, const char *format, ...)
+{
+ va_list ap;
+
+ va_start(ap, format);
+ len = vsnprintf(buff, len, format, ap);
+ va_end(ap);
+
+ return len;
+}
diff --git a/sos-code-article6.75/sos/klibc.h b/sos-code-article6.75/sos/klibc.h
new file mode 100644
index 0000000..7002778
--- /dev/null
+++ b/sos-code-article6.75/sos/klibc.h
@@ -0,0 +1,103 @@
+/* Copyright (C) 2003 The KOS Team
+ Copyright (C) 1999 Free Software Foundation
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#ifndef _SOS_KLIBC_H_
+#define _SOS_KLIBC_H_
+
+/**
+ * @file klibc.h
+ *
+ * Basic libc-style support for common useful functions (string.h,
+ * stdarg.h), some with slight non-standard behavior (see comments).
+ *
+ * Most of the prototypes of these functions are borrowed from
+ * FreeBSD, but their implementation (in klibc.c) come either from Kos
+ * (GPL v2) or from David Decotigny (SOS).
+ */
+
+#include <sos/types.h>
+
+/* string.h functions */
+
+void *memcpy(void *dst, const void *src, register unsigned int size ) ;
+void *memset(void *dst, register int c, register unsigned int length ) ;
+int memcmp(const void *s1, const void *s2, sos_size_t n);
+
+unsigned int strlen( register const char *str) ;
+unsigned int strnlen(const char * s, sos_size_t maxlen);
+
+/**
+ * @note Same as strncpy(), with a slightly different semantic.
+ * Actually, strncpy(3C) says " The result will not be null-terminated
+ * if the length of 'from' is n or more.". Here, 'dst' is ALWAYS
+ * null-terminated. And its total len will ALWAYS be <= len, with
+ * null-terminating-char included.
+ */
+char *strzcpy( register char *dst, register const char *src,
+ register int len ) ;
+
+/**
+ * @note Same as strncat(), with the same semantic : 'dst' is ALWAYS
+ * null-terminated. And its total len will ALWAYS be <= len, with
+ * null-terminating-char included.
+ */
+char *strzcat (char *dest, const char *src,
+ const sos_size_t len);
+
+int strcmp(register const char *s1, register const char *s2 );
+int strncmp(register const char *s1, register const char *s2,
+ register int len );
+
+/* Basic stdarg.h macros. Taken from gcc support files */
+#define __GNUC_VA_LIST
+typedef void *__gnuc_va_list;
+typedef __gnuc_va_list va_list;
+#define __va_rounded_size(TYPE) \
+ (((sizeof (TYPE) + sizeof (int) - 1) / sizeof (int)) * sizeof (int))
+#define va_start(AP, LASTARG) \
+ (AP = ((__gnuc_va_list) __builtin_next_arg (LASTARG)))
+#define va_end(AP) \
+ ((void)0)
+#define va_arg(AP, TYPE) \
+ (AP = (__gnuc_va_list) ((char *) (AP) + __va_rounded_size (TYPE)), \
+ *((TYPE *) (void *) ((char *) (AP) - __va_rounded_size (TYPE))))
+#define __va_copy(dest, src) \
+ (dest) = (src)
+
+/* stdarg.h functions. There might be a non-standard behavior: there
+ will always be a trailing '\0' in the resulting string */
+int vsnprintf(char *, sos_size_t, const char *, va_list);
+int snprintf(char *, sos_size_t, const char *, /*args*/ ...)
+ __attribute__ ((format (printf, 3, 4)));
+
+
+/*
+ * Pseudo-random generation functions. Useful to do some coverage
+ * tests.
+ */
+
+/* Amplitude of the random number generation */
+#define RAND_MAX 4294967291U
+
+/* Pseudo-random number generation (MT unsafe) */
+unsigned long int random (void);
+
+/* Set random seed (MT unsafe) */
+void srandom (unsigned long int seed);
+
+#endif /* _SOS_KLIBC_H_ */
diff --git a/sos-code-article6.75/sos/kmalloc.c b/sos-code-article6.75/sos/kmalloc.c
new file mode 100644
index 0000000..62d948d
--- /dev/null
+++ b/sos-code-article6.75/sos/kmalloc.c
@@ -0,0 +1,113 @@
+/* Copyright (C) 2004 David Decotigny
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+
+#include <sos/assert.h>
+#include <sos/macros.h>
+
+#include "physmem.h"
+#include "kmem_vmm.h"
+#include "kmem_slab.h"
+
+#include "kmalloc.h"
+
+/* The cache structures for these caches, the object size, their
+ names, and some number of pages that contain them. They might not
+ necessarily be powers of 2s. */
+static struct {
+ const char *name;
+ sos_size_t object_size;
+ sos_count_t pages_per_slab;
+ struct sos_kslab_cache *cache;
+} kmalloc_cache[] =
+ {
+ { "kmalloc 8B objects", 8, 1 },
+ { "kmalloc 16B objects", 16, 1 },
+ { "kmalloc 32B objects", 32, 1 },
+ { "kmalloc 64B objects", 64, 1 },
+ { "kmalloc 128B objects", 128, 1 },
+ { "kmalloc 256B objects", 256, 2 },
+ { "kmalloc 1024B objects", 1024, 2 },
+ { "kmalloc 2048B objects", 2048, 3 },
+ { "kmalloc 4096B objects", 4096, 4 },
+ { "kmalloc 8192B objects", 8192, 8 },
+ { "kmalloc 16384B objects", 16384, 12 },
+ { NULL, 0, 0, NULL }
+ };
+
+
+sos_ret_t sos_kmalloc_subsystem_setup()
+{
+ int i;
+ for (i = 0 ; kmalloc_cache[i].object_size != 0 ; i ++)
+ {
+ struct sos_kslab_cache *new_cache;
+ new_cache = sos_kmem_cache_create(kmalloc_cache[i].name,
+ kmalloc_cache[i].object_size,
+ kmalloc_cache[i].pages_per_slab,
+ 0,
+ SOS_KSLAB_CREATE_MAP
+ );
+ SOS_ASSERT_FATAL(new_cache != NULL);
+ kmalloc_cache[i].cache = new_cache;
+ }
+ return SOS_OK;
+}
+
+
+sos_vaddr_t sos_kmalloc(sos_size_t size, sos_ui32_t flags)
+{
+ /* Look for a suitable pre-allocated kmalloc cache */
+ int i;
+ for (i = 0 ; kmalloc_cache[i].object_size != 0 ; i ++)
+ {
+ if (kmalloc_cache[i].object_size >= size)
+ return sos_kmem_cache_alloc(kmalloc_cache[i].cache,
+ (flags
+ & SOS_KMALLOC_ATOMIC)?
+ SOS_KSLAB_ALLOC_ATOMIC:0);
+ }
+
+ /* none found yet => we directly use the kmem_vmm subsystem to
+ allocate whole pages */
+ return sos_kmem_vmm_alloc(SOS_PAGE_ALIGN_SUP(size) / SOS_PAGE_SIZE,
+ ( (flags
+ & SOS_KMALLOC_ATOMIC)?
+ SOS_KMEM_VMM_ATOMIC:0)
+ | SOS_KMEM_VMM_MAP
+ );
+}
+
+
+sos_ret_t sos_kfree(sos_vaddr_t vaddr)
+{
+ /* The trouble here is that we aren't sure whether this object is a
+ slab object in a pre-allocated kmalloc cache, or an object
+ directly allocated as a kmem_vmm region. */
+
+ /* We first pretend this object is allocated in a pre-allocated
+ kmalloc cache */
+ if (! sos_kmem_cache_free(vaddr))
+ return SOS_OK; /* Great ! We guessed right ! */
+
+ /* Here we're wrong: it appears not to be an object in a
+ pre-allocated kmalloc cache. So we try to pretend this is a
+ kmem_vmm area */
+ return sos_kmem_vmm_free(vaddr);
+}
+
+
diff --git a/sos-code-article6.75/sos/kmalloc.h b/sos-code-article6.75/sos/kmalloc.h
new file mode 100644
index 0000000..3f35b9d
--- /dev/null
+++ b/sos-code-article6.75/sos/kmalloc.h
@@ -0,0 +1,63 @@
+/* Copyright (C) 2004 David Decotigny
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#ifndef _SOS_KMALLOC_H_
+#define _SOS_KMALLOC_H_
+
+/**
+ * @file kmalloc.h
+ *
+ * Simple malloc-style wrapper to kmem_vmm.h and kmem_slab.h for
+ * "anonymous" objects (ie not associated to any precise slab cache).
+ */
+
+#include <sos/types.h>
+#include <sos/errno.h>
+
+
+/**
+ * Iniatilize the kmalloc subsystem, ie pre-allocate a series of caches.
+ */
+sos_ret_t sos_kmalloc_subsystem_setup(void);
+
+/*
+ * sos_kmalloc flags
+ */
+/** sos_kmalloc() should succeed without blocking, or return NULL */
+#define SOS_KMALLOC_ATOMIC 1
+
+/**
+ * Allocate a kernel object of the given size in the most suited slab
+ * cache if size can be handled by one of the pre-allocated caches, or
+ * using directly the range allocator otherwise. The object will
+ * allways be mapped in physical memory (ie implies
+ * SOS_KSLAB_CREATE_MAP and SOS_KMEM_VMM_MAP).
+ *
+ * @param size The size of the object
+ * @param flags The allocation flags (SOS_KMALLOC_* flags)
+ */
+sos_vaddr_t sos_kmalloc(sos_size_t size, sos_ui32_t flags);
+
+/**
+ * @note you are perfectly allowed to give the address of the
+ * kernel image, or the address of the bios area here, it will work:
+ * the kernel/bios WILL be "deallocated". But if you really want to do
+ * this, well..., do expect some "surprises" ;)
+ */
+sos_ret_t sos_kfree(sos_vaddr_t vaddr);
+
+#endif /* _SOS_KMALLOC_H_ */
diff --git a/sos-code-article6.75/sos/kmem_slab.c b/sos-code-article6.75/sos/kmem_slab.c
new file mode 100644
index 0000000..49a1527
--- /dev/null
+++ b/sos-code-article6.75/sos/kmem_slab.c
@@ -0,0 +1,812 @@
+/* Copyright (C) 2000 Thomas Petazzoni
+ Copyright (C) 2004 David Decotigny
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#include <sos/macros.h>
+#include <sos/klibc.h>
+#include <sos/list.h>
+#include <sos/assert.h>
+#include <hwcore/paging.h>
+#include <sos/physmem.h>
+#include <sos/kmem_vmm.h>
+
+#include "kmem_slab.h"
+
+/* Dimensioning constants */
+#define NB_PAGES_IN_SLAB_OF_CACHES 1
+#define NB_PAGES_IN_SLAB_OF_RANGES 1
+
+/** The structure of a slab cache */
+struct sos_kslab_cache
+{
+ char *name;
+
+ /* non mutable characteristics of this slab */
+ sos_size_t original_obj_size; /* asked object size */
+ sos_size_t alloc_obj_size; /* actual object size, taking the
+ alignment constraints into account */
+ sos_count_t nb_objects_per_slab;
+ sos_count_t nb_pages_per_slab;
+ sos_count_t min_free_objects;
+
+/* slab cache flags */
+// #define SOS_KSLAB_CREATE_MAP (1<<0) /* See kmem_slab.h */
+// #define SOS_KSLAB_CREATE_ZERO (1<<1) /* " " " " " " " " */
+#define ON_SLAB (1<<31) /* struct sos_kslab is included inside the slab */
+ sos_ui32_t flags;
+
+ /* Supervision data (updated at run-time) */
+ sos_count_t nb_free_objects;
+
+ /* The lists of slabs owned by this cache */
+ struct sos_kslab *slab_list; /* head = non full, tail = full */
+
+ /* The caches are linked together on the kslab_cache_list */
+ struct sos_kslab_cache *prev, *next;
+};
+
+
+/** The structure of a slab */
+struct sos_kslab
+{
+ /** Number of free objects on this slab */
+ sos_count_t nb_free;
+
+ /** The list of these free objects */
+ struct sos_kslab_free_object *free;
+
+ /** The address of the associated range structure */
+ struct sos_kmem_range *range;
+
+ /** Virtual start address of this range */
+ sos_vaddr_t first_object;
+
+ /** Slab cache owning this slab */
+ struct sos_kslab_cache *cache;
+
+ /** Links to the other slabs managed by the same cache */
+ struct sos_kslab *prev, *next;
+};
+
+
+/** The structure of the free objects in the slab */
+struct sos_kslab_free_object
+{
+ struct sos_kslab_free_object *prev, *next;
+};
+
+/** The cache of slab caches */
+static struct sos_kslab_cache *cache_of_struct_kslab_cache;
+
+/** The cache of slab structures for non-ON_SLAB caches */
+static struct sos_kslab_cache *cache_of_struct_kslab;
+
+/** The list of slab caches */
+static struct sos_kslab_cache *kslab_cache_list;
+
+/* Helper function to initialize a cache structure */
+static sos_ret_t
+cache_initialize(/*out*/struct sos_kslab_cache *the_cache,
+ const char* name,
+ sos_size_t obj_size,
+ sos_count_t pages_per_slab,
+ sos_count_t min_free_objs,
+ sos_ui32_t cache_flags)
+{
+ unsigned int space_left;
+ sos_size_t alloc_obj_size;
+
+ if (obj_size <= 0)
+ return -SOS_EINVAL;
+
+ /* Default allocation size is the requested one */
+ alloc_obj_size = obj_size;
+
+ /* Make sure the requested size is large enough to store a
+ free_object structure */
+ if (alloc_obj_size < sizeof(struct sos_kslab_free_object))
+ alloc_obj_size = sizeof(struct sos_kslab_free_object);
+
+ /* Align obj_size on 4 bytes */
+ alloc_obj_size = SOS_ALIGN_SUP(alloc_obj_size, sizeof(int));
+
+ /* Make sure supplied number of pages per slab is consistent with
+ actual allocated object size */
+ if (alloc_obj_size > pages_per_slab*SOS_PAGE_SIZE)
+ return -SOS_EINVAL;
+
+ /* Refuse too large slabs */
+ if (pages_per_slab > MAX_PAGES_PER_SLAB)
+ return -SOS_ENOMEM;
+
+ /* Fills in the cache structure */
+ memset(the_cache, 0x0, sizeof(struct sos_kslab_cache));
+ the_cache->name = (char*)name;
+ the_cache->flags = cache_flags;
+ the_cache->original_obj_size = obj_size;
+ the_cache->alloc_obj_size = alloc_obj_size;
+ the_cache->min_free_objects = min_free_objs;
+ the_cache->nb_pages_per_slab = pages_per_slab;
+
+ /* Small size objets => the slab structure is allocated directly in
+ the slab */
+ if(alloc_obj_size <= sizeof(struct sos_kslab))
+ the_cache->flags |= ON_SLAB;
+
+ /*
+ * Compute the space left once the maximum number of objects
+ * have been allocated in the slab
+ */
+ space_left = the_cache->nb_pages_per_slab*SOS_PAGE_SIZE;
+ if(the_cache->flags & ON_SLAB)
+ space_left -= sizeof(struct sos_kslab);
+ the_cache->nb_objects_per_slab = space_left / alloc_obj_size;
+ space_left -= the_cache->nb_objects_per_slab*alloc_obj_size;
+
+ /* Make sure a single slab is large enough to contain the minimum
+ number of objects requested */
+ if (the_cache->nb_objects_per_slab < min_free_objs)
+ return -SOS_EINVAL;
+
+ /* If there is now enough place for both the objects and the slab
+ structure, then make the slab structure ON_SLAB */
+ if (space_left >= sizeof(struct sos_kslab))
+ the_cache->flags |= ON_SLAB;
+
+ return SOS_OK;
+}
+
+
+/** Helper function to add a new slab for the given cache. */
+static sos_ret_t
+cache_add_slab(struct sos_kslab_cache *kslab_cache,
+ sos_vaddr_t vaddr_slab,
+ struct sos_kslab *slab)
+{
+ int i;
+
+ /* Setup the slab structure */
+ memset(slab, 0x0, sizeof(struct sos_kslab));
+ slab->cache = kslab_cache;
+
+ /* Establish the address of the first free object */
+ slab->first_object = vaddr_slab;
+
+ /* Account for this new slab in the cache */
+ slab->nb_free = kslab_cache->nb_objects_per_slab;
+ kslab_cache->nb_free_objects += slab->nb_free;
+
+ /* Build the list of free objects */
+ for (i = 0 ; i < kslab_cache->nb_objects_per_slab ; i++)
+ {
+ sos_vaddr_t obj_vaddr;
+
+ /* Set object's address */
+ obj_vaddr = slab->first_object + i*kslab_cache->alloc_obj_size;
+
+ /* Add it to the list of free objects */
+ list_add_tail(slab->free,
+ (struct sos_kslab_free_object *)obj_vaddr);
+ }
+
+ /* Add the slab to the cache's slab list: add the head of the list
+ since this slab is non full */
+ list_add_head(kslab_cache->slab_list, slab);
+
+ return SOS_OK;
+}
+
+
+/** Helper function to allocate a new slab for the given kslab_cache */
+static sos_ret_t
+cache_grow(struct sos_kslab_cache *kslab_cache,
+ sos_ui32_t alloc_flags)
+{
+ sos_ui32_t range_alloc_flags;
+
+ struct sos_kmem_range *new_range;
+ sos_vaddr_t new_range_start;
+
+ struct sos_kslab *new_slab;
+
+ /*
+ * Setup the flags for the range allocation
+ */
+ range_alloc_flags = 0;
+
+ /* Atomic ? */
+ if (alloc_flags & SOS_KSLAB_ALLOC_ATOMIC)
+ range_alloc_flags |= SOS_KMEM_VMM_ATOMIC;
+
+ /* Need physical mapping NOW ? */
+ if (kslab_cache->flags & (SOS_KSLAB_CREATE_MAP
+ | SOS_KSLAB_CREATE_ZERO))
+ range_alloc_flags |= SOS_KMEM_VMM_MAP;
+
+ /* Allocate the range */
+ new_range = sos_kmem_vmm_new_range(kslab_cache->nb_pages_per_slab,
+ range_alloc_flags,
+ & new_range_start);
+ if (! new_range)
+ return -SOS_ENOMEM;
+
+ /* Allocate the slab structure */
+ if (kslab_cache->flags & ON_SLAB)
+ {
+ /* Slab structure is ON the slab: simply set its address to the
+ end of the range */
+ sos_vaddr_t slab_vaddr
+ = new_range_start + kslab_cache->nb_pages_per_slab*SOS_PAGE_SIZE
+ - sizeof(struct sos_kslab);
+ new_slab = (struct sos_kslab*)slab_vaddr;
+ }
+ else
+ {
+ /* Slab structure is OFF the slab: allocate it from the cache of
+ slab structures */
+ sos_vaddr_t slab_vaddr
+ = sos_kmem_cache_alloc(cache_of_struct_kslab,
+ alloc_flags);
+ if (! slab_vaddr)
+ {
+ sos_kmem_vmm_del_range(new_range);
+ return -SOS_ENOMEM;
+ }
+ new_slab = (struct sos_kslab*)slab_vaddr;
+ }
+
+ cache_add_slab(kslab_cache, new_range_start, new_slab);
+ new_slab->range = new_range;
+
+ /* Set the backlink from range to this slab */
+ sos_kmem_vmm_set_slab(new_range, new_slab);
+
+ return SOS_OK;
+}
+
+
+/**
+ * Helper function to release a slab
+ *
+ * The corresponding range is always deleted, except when the @param
+ * must_del_range_now is not set. This happens only when the function
+ * gets called from sos_kmem_cache_release_struct_range(), to avoid
+ * large recursions.
+ */
+static sos_ret_t
+cache_release_slab(struct sos_kslab *slab,
+ sos_bool_t must_del_range_now)
+{
+ struct sos_kslab_cache *kslab_cache = slab->cache;
+ struct sos_kmem_range *range = slab->range;
+
+ SOS_ASSERT_FATAL(kslab_cache != NULL);
+ SOS_ASSERT_FATAL(range != NULL);
+ SOS_ASSERT_FATAL(slab->nb_free == slab->cache->nb_objects_per_slab);
+
+ /* First, remove the slab from the slabs' list of the cache */
+ list_delete(kslab_cache->slab_list, slab);
+ slab->cache->nb_free_objects -= slab->nb_free;
+
+ /* Release the slab structure if it is OFF slab */
+ if (! (slab->cache->flags & ON_SLAB))
+ sos_kmem_cache_free((sos_vaddr_t)slab);
+
+ /* Ok, the range is not bound to any slab anymore */
+ sos_kmem_vmm_set_slab(range, NULL);
+
+ /* Always delete the range now, unless we are told not to do so (see
+ sos_kmem_cache_release_struct_range() below) */
+ if (must_del_range_now)
+ return sos_kmem_vmm_del_range(range);
+
+ return SOS_OK;
+}
+
+
+/**
+ * Helper function to create the initial cache of caches, with a very
+ * first slab in it, so that new cache structures can be simply allocated.
+ * @return the cache structure for the cache of caches
+ */
+static struct sos_kslab_cache *
+create_cache_of_caches(sos_vaddr_t vaddr_first_slab_of_caches,
+ int nb_pages)
+{
+ /* The preliminary cache structure we need in order to allocate the
+ first slab in the cache of caches (allocated on the stack !) */
+ struct sos_kslab_cache fake_cache_of_caches;
+
+ /* The real cache structure for the cache of caches */
+ struct sos_kslab_cache *real_cache_of_caches;
+
+ /* The kslab structure for this very first slab */
+ struct sos_kslab *slab_of_caches;
+
+ /* Init the cache structure for the cache of caches */
+ if (cache_initialize(& fake_cache_of_caches,
+ "Caches", sizeof(struct sos_kslab_cache),
+ nb_pages, 0, SOS_KSLAB_CREATE_MAP | ON_SLAB))
+ /* Something wrong with the parameters */
+ return NULL;
+
+ memset((void*)vaddr_first_slab_of_caches, 0x0, nb_pages*SOS_PAGE_SIZE);
+
+ /* Add the pages for the 1st slab of caches */
+ slab_of_caches = (struct sos_kslab*)(vaddr_first_slab_of_caches
+ + nb_pages*SOS_PAGE_SIZE
+ - sizeof(struct sos_kslab));
+
+ /* Add the abovementioned 1st slab to the cache of caches */
+ cache_add_slab(& fake_cache_of_caches,
+ vaddr_first_slab_of_caches,
+ slab_of_caches);
+
+ /* Now we allocate a cache structure, which will be the real cache
+ of caches, ie a cache structure allocated INSIDE the cache of
+ caches, not inside the stack */
+ real_cache_of_caches
+ = (struct sos_kslab_cache*) sos_kmem_cache_alloc(& fake_cache_of_caches,
+ 0);
+ /* We initialize it */
+ memcpy(real_cache_of_caches, & fake_cache_of_caches,
+ sizeof(struct sos_kslab_cache));
+ /* We need to update the slab's 'cache' field */
+ slab_of_caches->cache = real_cache_of_caches;
+
+ /* Add the cache to the list of slab caches */
+ list_add_tail(kslab_cache_list, real_cache_of_caches);
+
+ return real_cache_of_caches;
+}
+
+
+/**
+ * Helper function to create the initial cache of ranges, with a very
+ * first slab in it, so that new kmem_range structures can be simply
+ * allocated.
+ * @return the cache of kmem_range
+ */
+static struct sos_kslab_cache *
+create_cache_of_ranges(sos_vaddr_t vaddr_first_slab_of_ranges,
+ sos_size_t sizeof_struct_range,
+ int nb_pages)
+{
+ /* The cache structure for the cache of kmem_range */
+ struct sos_kslab_cache *cache_of_ranges;
+
+ /* The kslab structure for the very first slab of ranges */
+ struct sos_kslab *slab_of_ranges;
+
+ cache_of_ranges = (struct sos_kslab_cache*)
+ sos_kmem_cache_alloc(cache_of_struct_kslab_cache,
+ 0);
+ if (! cache_of_ranges)
+ return NULL;
+
+ /* Init the cache structure for the cache of ranges with min objects
+ per slab = 2 !!! */
+ if (cache_initialize(cache_of_ranges,
+ "struct kmem_range",
+ sizeof_struct_range,
+ nb_pages, 2, SOS_KSLAB_CREATE_MAP | ON_SLAB))
+ /* Something wrong with the parameters */
+ return NULL;
+
+ /* Add the cache to the list of slab caches */
+ list_add_tail(kslab_cache_list, cache_of_ranges);
+
+ /*
+ * Add the first slab for this cache
+ */
+ memset((void*)vaddr_first_slab_of_ranges, 0x0, nb_pages*SOS_PAGE_SIZE);
+
+ /* Add the pages for the 1st slab of ranges */
+ slab_of_ranges = (struct sos_kslab*)(vaddr_first_slab_of_ranges
+ + nb_pages*SOS_PAGE_SIZE
+ - sizeof(struct sos_kslab));
+
+ cache_add_slab(cache_of_ranges,
+ vaddr_first_slab_of_ranges,
+ slab_of_ranges);
+
+ return cache_of_ranges;
+}
+
+
+struct sos_kslab_cache *
+sos_kmem_cache_subsystem_setup_prepare(sos_vaddr_t kernel_core_base,
+ sos_vaddr_t kernel_core_top,
+ sos_size_t sizeof_struct_range,
+ /* results */
+ struct sos_kslab **first_struct_slab_of_caches,
+ sos_vaddr_t *first_slab_of_caches_base,
+ sos_count_t *first_slab_of_caches_nb_pages,
+ struct sos_kslab **first_struct_slab_of_ranges,
+ sos_vaddr_t *first_slab_of_ranges_base,
+ sos_count_t *first_slab_of_ranges_nb_pages)
+{
+ int i;
+ sos_ret_t retval;
+ sos_vaddr_t vaddr;
+
+ /* The cache of ranges we are about to allocate */
+ struct sos_kslab_cache *cache_of_ranges;
+
+ /* In the begining, there isn't any cache */
+ kslab_cache_list = NULL;
+ cache_of_struct_kslab = NULL;
+ cache_of_struct_kslab_cache = NULL;
+
+ /*
+ * Create the cache of caches, initialised with 1 allocated slab
+ */
+
+ /* Allocate the pages needed for the 1st slab of caches, and map them
+ in kernel space, right after the kernel */
+ *first_slab_of_caches_base = SOS_PAGE_ALIGN_SUP(kernel_core_top);
+ for (i = 0, vaddr = *first_slab_of_caches_base ;
+ i < NB_PAGES_IN_SLAB_OF_CACHES ;
+ i++, vaddr += SOS_PAGE_SIZE)
+ {
+ sos_paddr_t ppage_paddr;
+
+ ppage_paddr
+ = sos_physmem_ref_physpage_new(FALSE);
+ SOS_ASSERT_FATAL(ppage_paddr != (sos_paddr_t)NULL);
+
+ retval = sos_paging_map(ppage_paddr, vaddr,
+ FALSE,
+ SOS_VM_MAP_ATOMIC
+ | SOS_VM_MAP_PROT_READ
+ | SOS_VM_MAP_PROT_WRITE);
+ SOS_ASSERT_FATAL(retval == SOS_OK);
+
+ retval = sos_physmem_unref_physpage(ppage_paddr);
+ SOS_ASSERT_FATAL(retval == FALSE);
+ }
+
+ /* Create the cache of caches */
+ *first_slab_of_caches_nb_pages = NB_PAGES_IN_SLAB_OF_CACHES;
+ cache_of_struct_kslab_cache
+ = create_cache_of_caches(*first_slab_of_caches_base,
+ NB_PAGES_IN_SLAB_OF_CACHES);
+ SOS_ASSERT_FATAL(cache_of_struct_kslab_cache != NULL);
+
+ /* Retrieve the slab that should have been allocated */
+ *first_struct_slab_of_caches
+ = list_get_head(cache_of_struct_kslab_cache->slab_list);
+
+
+ /*
+ * Create the cache of ranges, initialised with 1 allocated slab
+ */
+ *first_slab_of_ranges_base = vaddr;
+ /* Allocate the 1st slab */
+ for (i = 0, vaddr = *first_slab_of_ranges_base ;
+ i < NB_PAGES_IN_SLAB_OF_RANGES ;
+ i++, vaddr += SOS_PAGE_SIZE)
+ {
+ sos_paddr_t ppage_paddr;
+
+ ppage_paddr
+ = sos_physmem_ref_physpage_new(FALSE);
+ SOS_ASSERT_FATAL(ppage_paddr != (sos_paddr_t)NULL);
+
+ retval = sos_paging_map(ppage_paddr, vaddr,
+ FALSE,
+ SOS_VM_MAP_ATOMIC
+ | SOS_VM_MAP_PROT_READ
+ | SOS_VM_MAP_PROT_WRITE);
+ SOS_ASSERT_FATAL(retval == SOS_OK);
+
+ retval = sos_physmem_unref_physpage(ppage_paddr);
+ SOS_ASSERT_FATAL(retval == FALSE);
+ }
+
+ /* Create the cache of ranges */
+ *first_slab_of_ranges_nb_pages = NB_PAGES_IN_SLAB_OF_RANGES;
+ cache_of_ranges = create_cache_of_ranges(*first_slab_of_ranges_base,
+ sizeof_struct_range,
+ NB_PAGES_IN_SLAB_OF_RANGES);
+ SOS_ASSERT_FATAL(cache_of_ranges != NULL);
+
+ /* Retrieve the slab that should have been allocated */
+ *first_struct_slab_of_ranges
+ = list_get_head(cache_of_ranges->slab_list);
+
+ /*
+ * Create the cache of slabs, without any allocated slab yet
+ */
+ cache_of_struct_kslab
+ = sos_kmem_cache_create("off-slab slab structures",
+ sizeof(struct sos_kslab),
+ 1,
+ 0,
+ SOS_KSLAB_CREATE_MAP);
+ SOS_ASSERT_FATAL(cache_of_struct_kslab != NULL);
+
+ return cache_of_ranges;
+}
+
+
+sos_ret_t
+sos_kmem_cache_subsystem_setup_commit(struct sos_kslab *first_struct_slab_of_caches,
+ struct sos_kmem_range *first_range_of_caches,
+ struct sos_kslab *first_struct_slab_of_ranges,
+ struct sos_kmem_range *first_range_of_ranges)
+{
+ first_struct_slab_of_caches->range = first_range_of_caches;
+ first_struct_slab_of_ranges->range = first_range_of_ranges;
+ return SOS_OK;
+}
+
+
+struct sos_kslab_cache *
+sos_kmem_cache_create(const char* name,
+ sos_size_t obj_size,
+ sos_count_t pages_per_slab,
+ sos_count_t min_free_objs,
+ sos_ui32_t cache_flags)
+{
+ struct sos_kslab_cache *new_cache;
+
+ /* Allocate the new cache */
+ new_cache = (struct sos_kslab_cache*)
+ sos_kmem_cache_alloc(cache_of_struct_kslab_cache,
+ 0/* NOT ATOMIC */);
+ if (! new_cache)
+ return NULL;
+
+ if (cache_initialize(new_cache, name, obj_size,
+ pages_per_slab, min_free_objs,
+ cache_flags))
+ {
+ /* Something was wrong */
+ sos_kmem_cache_free((sos_vaddr_t)new_cache);
+ return NULL;
+ }
+
+ /* Add the cache to the list of slab caches */
+ list_add_tail(kslab_cache_list, new_cache);
+
+ /* if the min_free_objs is set, pre-allocate a slab */
+ if (min_free_objs)
+ {
+ if (cache_grow(new_cache, 0 /* Not atomic */) != SOS_OK)
+ {
+ sos_kmem_cache_destroy(new_cache);
+ return NULL; /* Not enough memory */
+ }
+ }
+
+ return new_cache;
+}
+
+
+sos_ret_t sos_kmem_cache_destroy(struct sos_kslab_cache *kslab_cache)
+{
+ int nb_slabs;
+ struct sos_kslab *slab;
+
+ if (! kslab_cache)
+ return -SOS_EINVAL;
+
+ /* Refuse to destroy the cache if there are any objects still
+ allocated */
+ list_foreach(kslab_cache->slab_list, slab, nb_slabs)
+ {
+ if (slab->nb_free != kslab_cache->nb_objects_per_slab)
+ return -SOS_EBUSY;
+ }
+
+ /* Remove all the slabs */
+ while ((slab = list_get_head(kslab_cache->slab_list)) != NULL)
+ {
+ cache_release_slab(slab, TRUE);
+ }
+
+ /* Remove the cache */
+ return sos_kmem_cache_free((sos_vaddr_t)kslab_cache);
+}
+
+
+sos_vaddr_t sos_kmem_cache_alloc(struct sos_kslab_cache *kslab_cache,
+ sos_ui32_t alloc_flags)
+{
+ sos_vaddr_t obj_vaddr;
+ struct sos_kslab * slab_head;
+#define ALLOC_RET return
+
+ /* If the slab at the head of the slabs' list has no free object,
+ then the other slabs don't either => need to allocate a new
+ slab */
+ if ((! kslab_cache->slab_list)
+ || (! list_get_head(kslab_cache->slab_list)->free))
+ {
+ if (cache_grow(kslab_cache, alloc_flags) != SOS_OK)
+ /* Not enough memory or blocking alloc */
+ ALLOC_RET( (sos_vaddr_t)NULL);
+ }
+
+ /* Here: we are sure that list_get_head(kslab_cache->slab_list)
+ exists *AND* that list_get_head(kslab_cache->slab_list)->free is
+ NOT NULL */
+ slab_head = list_get_head(kslab_cache->slab_list);
+ SOS_ASSERT_FATAL(slab_head != NULL);
+
+ /* Allocate the object at the head of the slab at the head of the
+ slabs' list */
+ obj_vaddr = (sos_vaddr_t)list_pop_head(slab_head->free);
+ slab_head->nb_free --;
+ kslab_cache->nb_free_objects --;
+
+ /* If needed, reset object's contents */
+ if (kslab_cache->flags & SOS_KSLAB_CREATE_ZERO)
+ memset((void*)obj_vaddr, 0x0, kslab_cache->alloc_obj_size);
+
+ /* Slab is now full ? */
+ if (slab_head->free == NULL)
+ {
+ /* Transfer it at the tail of the slabs' list */
+ struct sos_kslab *slab;
+ slab = list_pop_head(kslab_cache->slab_list);
+ list_add_tail(kslab_cache->slab_list, slab);
+ }
+
+ /*
+ * For caches that require a minimum amount of free objects left,
+ * allocate a slab if needed.
+ *
+ * Notice the "== min_objects - 1": we did not write " <
+ * min_objects" because for the cache of kmem structure, this would
+ * lead to an chicken-and-egg problem, since cache_grow below would
+ * call cache_alloc again for the kmem_vmm cache, so we return here
+ * with the same cache. If the test were " < min_objects", then we
+ * would call cache_grow again for the kmem_vmm cache again and
+ * again... until we reach the bottom of our stack (infinite
+ * recursion). By telling precisely "==", then the cache_grow would
+ * only be called the first time.
+ */
+ if ((kslab_cache->min_free_objects > 0)
+ && (kslab_cache->nb_free_objects == (kslab_cache->min_free_objects - 1)))
+ {
+ /* No: allocate a new slab now */
+ if (cache_grow(kslab_cache, alloc_flags) != SOS_OK)
+ {
+ /* Not enough free memory or blocking alloc => undo the
+ allocation */
+ sos_kmem_cache_free(obj_vaddr);
+ ALLOC_RET( (sos_vaddr_t)NULL);
+ }
+ }
+
+ ALLOC_RET(obj_vaddr);
+}
+
+
+/**
+ * Helper function to free the object located at the given address.
+ *
+ * @param empty_slab is the address of the slab to release, if removing
+ * the object causes the slab to become empty.
+ */
+inline static
+sos_ret_t
+free_object(sos_vaddr_t vaddr,
+ struct sos_kslab ** empty_slab)
+{
+ struct sos_kslab_cache *kslab_cache;
+
+ /* Lookup the slab containing the object in the slabs' list */
+ struct sos_kslab *slab = sos_kmem_vmm_resolve_slab(vaddr);
+
+ /* By default, consider that the slab will not become empty */
+ *empty_slab = NULL;
+
+ /* Did not find the slab */
+ if (! slab)
+ return -SOS_EINVAL;
+
+ SOS_ASSERT_FATAL(slab->cache);
+ kslab_cache = slab->cache;
+
+ /*
+ * Check whether the address really could mark the start of an actual
+ * allocated object
+ */
+ /* Address multiple of an object's size ? */
+ if (( (vaddr - slab->first_object)
+ % kslab_cache->alloc_obj_size) != 0)
+ return -SOS_EINVAL;
+ /* Address not too large ? */
+ if (( (vaddr - slab->first_object)
+ / kslab_cache->alloc_obj_size) >= kslab_cache->nb_objects_per_slab)
+ return -SOS_EINVAL;
+
+ /*
+ * Ok: we now release the object
+ */
+
+ /* Did find a full slab => will not be full any more => move it
+ to the head of the slabs' list */
+ if (! slab->free)
+ {
+ list_delete(kslab_cache->slab_list, slab);
+ list_add_head(kslab_cache->slab_list, slab);
+ }
+
+ /* Release the object */
+ list_add_head(slab->free, (struct sos_kslab_free_object*)vaddr);
+ slab->nb_free++;
+ kslab_cache->nb_free_objects++;
+ SOS_ASSERT_FATAL(slab->nb_free <= slab->cache->nb_objects_per_slab);
+
+ /* Cause the slab to be released if it becomes empty, and if we are
+ allowed to do it */
+ if ((slab->nb_free >= kslab_cache->nb_objects_per_slab)
+ && (kslab_cache->nb_free_objects - slab->nb_free
+ >= kslab_cache->min_free_objects))
+ {
+ *empty_slab = slab;
+ }
+
+ return SOS_OK;
+}
+
+
+sos_ret_t sos_kmem_cache_free(sos_vaddr_t vaddr)
+{
+ sos_ret_t retval;
+ struct sos_kslab *empty_slab;
+
+ /* Remove the object from the slab */
+ retval = free_object(vaddr, & empty_slab);
+ if (retval != SOS_OK)
+ return retval;
+
+ /* Remove the slab and the underlying range if needed */
+ if (empty_slab != NULL)
+ return cache_release_slab(empty_slab, TRUE);
+
+ return SOS_OK;
+}
+
+
+struct sos_kmem_range *
+sos_kmem_cache_release_struct_range(struct sos_kmem_range *the_range)
+{
+ sos_ret_t retval;
+ struct sos_kslab *empty_slab;
+
+ /* Remove the object from the slab */
+ retval = free_object((sos_vaddr_t)the_range, & empty_slab);
+ if (retval != SOS_OK)
+ return NULL;
+
+ /* Remove the slab BUT NOT the underlying range if needed */
+ if (empty_slab != NULL)
+ {
+ struct sos_kmem_range *empty_range = empty_slab->range;
+ SOS_ASSERT_FATAL(cache_release_slab(empty_slab, FALSE) == SOS_OK);
+ SOS_ASSERT_FATAL(empty_range != NULL);
+ return empty_range;
+ }
+
+ return NULL;
+}
+
diff --git a/sos-code-article6.75/sos/kmem_slab.h b/sos-code-article6.75/sos/kmem_slab.h
new file mode 100644
index 0000000..1f28ff9
--- /dev/null
+++ b/sos-code-article6.75/sos/kmem_slab.h
@@ -0,0 +1,206 @@
+/* Copyright (C) 2000 Thomas Petazzoni
+ Copyright (C) 2004 David Decotigny
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#ifndef _SOS_KMEM_SLAB_H_
+#define _SOS_KMEM_SLAB_H_
+
+/**
+ * @file kmem_slab.h
+ *
+ * Kernel Memory Allocator based on Bonwick's slab llocator (Solaris
+ * 2.4, Linux 2.4). This allocator achieves good memory utilization
+ * ratio (memory effectively used / memory requested) ie limited
+ * fragmentation, while elegantly handling cache-effect considerations
+ * (TLB locality through the notion of "cache" of slabs, and the
+ * dcache utilization through the notion of cache colouring to
+ * decrease the conflicts in the dcache for accesses to different data
+ * in the same cache).
+ *
+ * This allocator relies on the range allocator (kmem_vmm.h) to
+ * allocate the slabs, which itself relies on the slab allocator to
+ * allocate its "range" data structures, thus leading to a
+ * chicken-and-egg problem. We solve this problem by introducing the
+ * notion of "min_free_objs" for the slab caches, in order for the cache
+ * of ranges to always have enough ranges in reserve to complete the
+ * range allocation before being urged to allocate a new slab of
+ * ranges, which would require the allocation of a new range.
+ *
+ * Compared to Bonwick's recommendations, we don't handle ctor/dtor
+ * routines on the objects, so that we can alter the objects once they
+ * are set free. Thus, the list of free object is stored in the free
+ * objects themselves, not alongside the objects (this also implies that
+ * the SOS_KSLAB_CREATE_MAP flag below is meaningless). We also don't
+ * implement the cache colouring (trivial to add, but we omit it for
+ * readability reasons), and the only alignment constraint we respect
+ * is that allocated objects are aligned on a 4B boundary: for other
+ * alignment constraints, the user must integrate them in the
+ * "object_size" parameter to "sos_kmem_cache_create()".
+ *
+ * References :
+ * - J. Bonwick's paper, "The slab allocator: An object-caching kernel
+ * memory allocator", In USENIX Summer 1994 Technical Conference
+ * - The bible, aka "Unix internals : the new frontiers" (section
+ * 12.10), Uresh Vahalia, Prentice Hall 1996, ISBN 0131019082
+ * - "The Linux slab allocator", B. Fitzgibbons,
+ * http://www.cc.gatech.edu/people/home/bradf/cs7001/proj2/
+ * - The Kos, http://kos.enix.org/
+ */
+#include <sos/types.h>
+#include <sos/errno.h>
+
+/** Opaque data structure that defines a Cache of slabs */
+struct sos_kslab_cache;
+
+/** Opaque data structure that defines a slab. Exported only to
+ kmem_vmm.h */
+struct sos_kslab;
+
+#include "kmem_vmm.h"
+
+
+/** The maximum allowed pages for each slab */
+#define MAX_PAGES_PER_SLAB 32 /* 128 kB */
+
+
+/**
+ * Initialize the slab cache of slab caches, and prepare the cache of
+ * kmem_range for kmem_vmm.
+ *
+ * @param kernel_core_base The virtual address of the first byte used
+ * by the kernel code/data
+ *
+ * @param kernel_core_top The virtual address of the first byte after
+ * the kernel code/data.
+ *
+ * @param sizeof_struct_range the size of the objects (aka "struct
+ * sos_kmem_vmm_ranges") to be allocated in the cache of ranges
+ *
+ * @param first_struct_slab_of_caches (output value) the virtual
+ * address of the first slab structure that gets allocated for the
+ * cache of caches. The function actually manually allocate the first
+ * slab of the cache of caches because of a chicken-and-egg thing. The
+ * address of the slab is used by the kmem_vmm_setup routine to
+ * finalize the allocation of the slab, in order for it to behave like
+ * a real slab afterwards.
+ *
+ * @param first_slab_of_caches_base (output value) the virtual address
+ * of the slab associated to the slab structure.
+ *
+ * @param first_slab_of_caches_nb_pages (output value) the number of
+ * (virtual) pages used by the first slab of the cache of caches.
+ *
+ * @param first_struct_slab_of_ranges (output value) the virtual address
+ * of the first slab that gets allocated for the cache of ranges. Same
+ * explanation as above.
+ *
+ * @param first_slab_of_ranges_base (output value) the virtual address
+ * of the slab associated to the slab structure.
+ *
+ * @param first_slab_of_ranges_nb_pages (output value) the number of
+ * (virtual) pages used by the first slab of the cache of ranges.
+ *
+ * @return the cache of kmem_range immediatly usable
+ */
+struct sos_kslab_cache *
+sos_kmem_cache_subsystem_setup_prepare(sos_vaddr_t kernel_core_base,
+ sos_vaddr_t kernel_core_top,
+ sos_size_t sizeof_struct_range,
+ /* results */
+ struct sos_kslab **first_struct_slab_of_caches,
+ sos_vaddr_t *first_slab_of_caches_base,
+ sos_count_t *first_slab_of_caches_nb_pages,
+ struct sos_kslab **first_struct_slab_of_ranges,
+ sos_vaddr_t *first_slab_of_ranges_base,
+ sos_count_t *first_slab_of_ranges_nb_pages);
+
+/**
+ * Update the configuration of the cache subsystem once the vmm
+ * subsystem has been fully initialized
+ */
+sos_ret_t
+sos_kmem_cache_subsystem_setup_commit(struct sos_kslab *first_struct_slab_of_caches,
+ struct sos_kmem_range *first_range_of_caches,
+ struct sos_kslab *first_struct_slab_of_ranges,
+ struct sos_kmem_range *first_range_of_ranges);
+
+
+/*
+ * Flags for sos_kmem_cache_create()
+ */
+/** The slabs should be initially mapped in physical memory */
+#define SOS_KSLAB_CREATE_MAP (1<<0)
+/** The object should always be set to zero at allocation (implies
+ SOS_KSLAB_CREATE_MAP) */
+#define SOS_KSLAB_CREATE_ZERO (1<<1)
+
+/**
+ * @note this function MAY block (involved allocations are not atomic)
+ * @param name must remain valid during the whole cache's life
+ * (shallow copy) !
+ * @param cache_flags An or-ed combination of the SOS_KSLAB_CREATE_* flags
+ */
+struct sos_kslab_cache *
+sos_kmem_cache_create(const char* name,
+ sos_size_t object_size,
+ sos_count_t pages_per_slab,
+ sos_count_t min_free_objects,
+ sos_ui32_t cache_flags);
+
+sos_ret_t sos_kmem_cache_destroy(struct sos_kslab_cache *kslab_cache);
+
+
+/*
+ * Flags for sos_kmem_cache_alloc()
+ */
+/** Allocation should either succeed or fail, without blocking */
+#define SOS_KSLAB_ALLOC_ATOMIC (1<<0)
+
+/**
+ * Allocate an object from the given cache.
+ *
+ * @param alloc_flags An or-ed combination of the SOS_KSLAB_ALLOC_* flags
+ */
+sos_vaddr_t sos_kmem_cache_alloc(struct sos_kslab_cache *kslab_cache,
+ sos_ui32_t alloc_flags);
+
+
+/**
+ * Free an object (assumed to be already allocated and not already
+ * free) at the given virtual address.
+ */
+sos_ret_t sos_kmem_cache_free(sos_vaddr_t vaddr);
+
+
+/*
+ * Function reserved to kmem_vmm.c. Does almost everything
+ * sos_kmem_cache_free() does, except it does not call
+ * sos_kmem_vmm_del_range() if it needs to. This is aimed at avoiding
+ * large recursion when a range is freed with
+ * sos_kmem_vmm_del_range().
+ *
+ * @param the_range The range structure to free
+ *
+ * @return NULL when the range containing 'the_range' still contains
+ * other ranges, or the address of the range which owned 'the_range'
+ * if it becomes empty.
+ */
+struct sos_kmem_range *
+sos_kmem_cache_release_struct_range(struct sos_kmem_range *the_range);
+
+
+#endif /* _SOS_KMEM_SLAB_H_ */
diff --git a/sos-code-article6.75/sos/kmem_vmm.c b/sos-code-article6.75/sos/kmem_vmm.c
new file mode 100644
index 0000000..ea2fdf1
--- /dev/null
+++ b/sos-code-article6.75/sos/kmem_vmm.c
@@ -0,0 +1,606 @@
+/* Copyright (C) 2000 Thomas Petazzoni
+ Copyright (C) 2004 David Decotigny
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+
+#include <sos/list.h>
+#include <sos/physmem.h>
+#include <hwcore/paging.h>
+#include <sos/assert.h>
+
+#include "kmem_vmm.h"
+
+/** The structure of a range of kernel-space virtual addresses */
+struct sos_kmem_range
+{
+ sos_vaddr_t base_vaddr;
+ sos_count_t nb_pages;
+
+ /* The slab owning this range, or NULL */
+ struct sos_kslab *slab;
+
+ struct sos_kmem_range *prev, *next;
+};
+const int sizeof_struct_sos_kmem_range = sizeof(struct sos_kmem_range);
+
+/** The ranges are SORTED in (strictly) ascending base addresses */
+static struct sos_kmem_range *kmem_free_range_list, *kmem_used_range_list;
+
+/** The slab cache for the kmem ranges */
+static struct sos_kslab_cache *kmem_range_cache;
+
+
+
+/** Helper function to get the closest preceding or containing
+ range for the given virtual address */
+static struct sos_kmem_range *
+get_closest_preceding_kmem_range(struct sos_kmem_range *the_list,
+ sos_vaddr_t vaddr)
+{
+ int nb_elements;
+ struct sos_kmem_range *a_range, *ret_range;
+
+ /* kmem_range list is kept SORTED, so we exit as soon as vaddr >= a
+ range base address */
+ ret_range = NULL;
+ list_foreach(the_list, a_range, nb_elements)
+ {
+ if (vaddr < a_range->base_vaddr)
+ return ret_range;
+ ret_range = a_range;
+ }
+
+ /* This will always be the LAST range in the kmem area */
+ return ret_range;
+}
+
+
+/**
+ * Helper function to lookup a free range large enough to hold nb_pages
+ * pages (first fit)
+ */
+static struct sos_kmem_range *find_suitable_free_range(sos_count_t nb_pages)
+{
+ int nb_elements;
+ struct sos_kmem_range *r;
+
+ list_foreach(kmem_free_range_list, r, nb_elements)
+ {
+ if (r->nb_pages >= nb_pages)
+ return r;
+ }
+
+ return NULL;
+}
+
+
+/**
+ * Helper function to add a_range in the_list, in strictly ascending order.
+ *
+ * @return The (possibly) new head of the_list
+ */
+static struct sos_kmem_range *insert_range(struct sos_kmem_range *the_list,
+ struct sos_kmem_range *a_range)
+{
+ struct sos_kmem_range *prec_used;
+
+ /** Look for any preceding range */
+ prec_used = get_closest_preceding_kmem_range(the_list,
+ a_range->base_vaddr);
+ /** insert a_range /after/ this prec_used */
+ if (prec_used != NULL)
+ list_insert_after(the_list, prec_used, a_range);
+ else /* Insert at the beginning of the list */
+ list_add_head(the_list, a_range);
+
+ return the_list;
+}
+
+
+/**
+ * Helper function to retrieve the range owning the given vaddr, by
+ * scanning the physical memory first if vaddr is mapped in RAM
+ */
+static struct sos_kmem_range *lookup_range(sos_vaddr_t vaddr)
+{
+ struct sos_kmem_range *range;
+
+ /* First: try to retrieve the physical page mapped at this address */
+ sos_paddr_t ppage_paddr = SOS_PAGE_ALIGN_INF(sos_paging_get_paddr(vaddr));
+
+ if (ppage_paddr)
+ {
+ range = sos_physmem_get_kmem_range(ppage_paddr);
+
+ /* If a page is mapped at this address, it is EXPECTED that it
+ is really associated with a range */
+ SOS_ASSERT_FATAL(range != NULL);
+ }
+
+ /* Otherwise scan the list of used ranges, looking for the range
+ owning the address */
+ else
+ {
+ range = get_closest_preceding_kmem_range(kmem_used_range_list,
+ vaddr);
+ /* Not found */
+ if (! range)
+ return NULL;
+
+ /* vaddr not covered by this range */
+ if ( (vaddr < range->base_vaddr)
+ || (vaddr >= (range->base_vaddr + range->nb_pages*SOS_PAGE_SIZE)) )
+ return NULL;
+ }
+
+ return range;
+}
+
+
+/**
+ * Helper function for sos_kmem_vmm_setup() to initialize a new range
+ * that maps a given area as free or as already used.
+ * This function either succeeds or halts the whole system.
+ */
+static struct sos_kmem_range *
+create_range(sos_bool_t is_free,
+ sos_vaddr_t base_vaddr,
+ sos_vaddr_t top_vaddr,
+ struct sos_kslab *associated_slab)
+{
+ struct sos_kmem_range *range;
+
+ SOS_ASSERT_FATAL(SOS_IS_PAGE_ALIGNED(base_vaddr));
+ SOS_ASSERT_FATAL(SOS_IS_PAGE_ALIGNED(top_vaddr));
+
+ if ((top_vaddr - base_vaddr) < SOS_PAGE_SIZE)
+ return NULL;
+
+ range = (struct sos_kmem_range*)sos_kmem_cache_alloc(kmem_range_cache,
+ SOS_KSLAB_ALLOC_ATOMIC);
+ SOS_ASSERT_FATAL(range != NULL);
+
+ range->base_vaddr = base_vaddr;
+ range->nb_pages = (top_vaddr - base_vaddr) / SOS_PAGE_SIZE;
+
+ if (is_free)
+ {
+ list_add_tail(kmem_free_range_list,
+ range);
+ }
+ else
+ {
+ sos_vaddr_t vaddr;
+ range->slab = associated_slab;
+ list_add_tail(kmem_used_range_list,
+ range);
+
+ /* Ok, set the range owner for the pages in this page */
+ for (vaddr = base_vaddr ;
+ vaddr < top_vaddr ;
+ vaddr += SOS_PAGE_SIZE)
+ {
+ sos_paddr_t ppage_paddr = sos_paging_get_paddr(vaddr);
+ SOS_ASSERT_FATAL((void*)ppage_paddr != NULL);
+ sos_physmem_set_kmem_range(ppage_paddr, range);
+ }
+ }
+
+ return range;
+}
+
+
+sos_ret_t
+sos_kmem_vmm_subsystem_setup(sos_vaddr_t kernel_core_base,
+ sos_vaddr_t kernel_core_top,
+ sos_vaddr_t bootstrap_stack_bottom_vaddr,
+ sos_vaddr_t bootstrap_stack_top_vaddr)
+{
+ struct sos_kslab *first_struct_slab_of_caches,
+ *first_struct_slab_of_ranges;
+ sos_vaddr_t first_slab_of_caches_base,
+ first_slab_of_caches_nb_pages,
+ first_slab_of_ranges_base,
+ first_slab_of_ranges_nb_pages;
+ struct sos_kmem_range *first_range_of_caches,
+ *first_range_of_ranges;
+
+ list_init(kmem_free_range_list);
+ list_init(kmem_used_range_list);
+
+ kmem_range_cache
+ = sos_kmem_cache_subsystem_setup_prepare(kernel_core_base,
+ kernel_core_top,
+ sizeof(struct sos_kmem_range),
+ & first_struct_slab_of_caches,
+ & first_slab_of_caches_base,
+ & first_slab_of_caches_nb_pages,
+ & first_struct_slab_of_ranges,
+ & first_slab_of_ranges_base,
+ & first_slab_of_ranges_nb_pages);
+ SOS_ASSERT_FATAL(kmem_range_cache != NULL);
+
+ /* Mark virtual addresses 16kB - Video as FREE */
+ create_range(TRUE,
+ SOS_KMEM_VMM_BASE,
+ SOS_PAGE_ALIGN_INF(BIOS_N_VIDEO_START),
+ NULL);
+
+ /* Mark virtual addresses in Video hardware mapping as NOT FREE */
+ create_range(FALSE,
+ SOS_PAGE_ALIGN_INF(BIOS_N_VIDEO_START),
+ SOS_PAGE_ALIGN_SUP(BIOS_N_VIDEO_END),
+ NULL);
+
+ /* Mark virtual addresses Video - Kernel as FREE */
+ create_range(TRUE,
+ SOS_PAGE_ALIGN_SUP(BIOS_N_VIDEO_END),
+ SOS_PAGE_ALIGN_INF(kernel_core_base),
+ NULL);
+
+ /* Mark virtual addresses in Kernel code/data up to the bootstrap stack
+ as NOT FREE */
+ create_range(FALSE,
+ SOS_PAGE_ALIGN_INF(kernel_core_base),
+ bootstrap_stack_bottom_vaddr,
+ NULL);
+
+ /* Mark virtual addresses in the bootstrap stack as NOT FREE too,
+ but in another vmm region in order to be un-allocated later */
+ create_range(FALSE,
+ bootstrap_stack_bottom_vaddr,
+ bootstrap_stack_top_vaddr,
+ NULL);
+
+ /* Mark the remaining virtual addresses in Kernel code/data after
+ the bootstrap stack as NOT FREE */
+ create_range(FALSE,
+ bootstrap_stack_top_vaddr,
+ SOS_PAGE_ALIGN_SUP(kernel_core_top),
+ NULL);
+
+ /* Mark virtual addresses in the first slab of the cache of caches
+ as NOT FREE */
+ SOS_ASSERT_FATAL(SOS_PAGE_ALIGN_SUP(kernel_core_top)
+ == first_slab_of_caches_base);
+ SOS_ASSERT_FATAL(first_struct_slab_of_caches != NULL);
+ first_range_of_caches
+ = create_range(FALSE,
+ first_slab_of_caches_base,
+ first_slab_of_caches_base
+ + first_slab_of_caches_nb_pages*SOS_PAGE_SIZE,
+ first_struct_slab_of_caches);
+
+ /* Mark virtual addresses in the first slab of the cache of ranges
+ as NOT FREE */
+ SOS_ASSERT_FATAL((first_slab_of_caches_base
+ + first_slab_of_caches_nb_pages*SOS_PAGE_SIZE)
+ == first_slab_of_ranges_base);
+ SOS_ASSERT_FATAL(first_struct_slab_of_ranges != NULL);
+ first_range_of_ranges
+ = create_range(FALSE,
+ first_slab_of_ranges_base,
+ first_slab_of_ranges_base
+ + first_slab_of_ranges_nb_pages*SOS_PAGE_SIZE,
+ first_struct_slab_of_ranges);
+
+ /* Mark virtual addresses after these slabs as FREE */
+ create_range(TRUE,
+ first_slab_of_ranges_base
+ + first_slab_of_ranges_nb_pages*SOS_PAGE_SIZE,
+ SOS_KMEM_VMM_TOP,
+ NULL);
+
+ /* Update the cache subsystem so that the artificially-created
+ caches of caches and ranges really behave like *normal* caches (ie
+ those allocated by the normal slab API) */
+ sos_kmem_cache_subsystem_setup_commit(first_struct_slab_of_caches,
+ first_range_of_caches,
+ first_struct_slab_of_ranges,
+ first_range_of_ranges);
+
+ return SOS_OK;
+}
+
+
+/**
+ * Allocate a new kernel area spanning one or multiple pages.
+ *
+ * @eturn a new range structure
+ */
+struct sos_kmem_range *sos_kmem_vmm_new_range(sos_count_t nb_pages,
+ sos_ui32_t flags,
+ sos_vaddr_t * range_start)
+{
+ struct sos_kmem_range *free_range, *new_range;
+
+ if (nb_pages <= 0)
+ return NULL;
+
+ /* Find a suitable free range to hold the size-sized object */
+ free_range = find_suitable_free_range(nb_pages);
+ if (free_range == NULL)
+ return NULL;
+
+ /* If range has exactly the requested size, just move it to the
+ "used" list */
+ if(free_range->nb_pages == nb_pages)
+ {
+ list_delete(kmem_free_range_list, free_range);
+ kmem_used_range_list = insert_range(kmem_used_range_list,
+ free_range);
+ /* The new_range is exactly the free_range */
+ new_range = free_range;
+ }
+
+ /* Otherwise the range is bigger than the requested size, split it.
+ This involves reducing its size, and allocate a new range, which
+ is going to be added to the "used" list */
+ else
+ {
+ /* free_range split in { new_range | free_range } */
+ new_range = (struct sos_kmem_range*)
+ sos_kmem_cache_alloc(kmem_range_cache,
+ (flags & SOS_KMEM_VMM_ATOMIC)?
+ SOS_KSLAB_ALLOC_ATOMIC:0);
+ if (! new_range)
+ return NULL;
+
+ new_range->base_vaddr = free_range->base_vaddr;
+ new_range->nb_pages = nb_pages;
+ free_range->base_vaddr += nb_pages*SOS_PAGE_SIZE;
+ free_range->nb_pages -= nb_pages;
+
+ /* free_range is still at the same place in the list */
+ /* insert new_range in the used list */
+ kmem_used_range_list = insert_range(kmem_used_range_list,
+ new_range);
+ }
+
+ /* By default, the range is not associated with any slab */
+ new_range->slab = NULL;
+
+ /* If mapping of physical pages is needed, map them now */
+ if (flags & SOS_KMEM_VMM_MAP)
+ {
+ int i;
+ for (i = 0 ; i < nb_pages ; i ++)
+ {
+ /* Get a new physical page */
+ sos_paddr_t ppage_paddr
+ = sos_physmem_ref_physpage_new(! (flags & SOS_KMEM_VMM_ATOMIC));
+
+ /* Map the page in kernel space */
+ if (ppage_paddr)
+ {
+ if (sos_paging_map(ppage_paddr,
+ new_range->base_vaddr
+ + i * SOS_PAGE_SIZE,
+ FALSE /* Not a user page */,
+ ((flags & SOS_KMEM_VMM_ATOMIC)?
+ SOS_VM_MAP_ATOMIC:0)
+ | SOS_VM_MAP_PROT_READ
+ | SOS_VM_MAP_PROT_WRITE))
+ {
+ /* Failed => force unallocation, see below */
+ sos_physmem_unref_physpage(ppage_paddr);
+ ppage_paddr = (sos_paddr_t)NULL;
+ }
+ else
+ {
+ /* Success : page can be unreferenced since it is
+ now mapped */
+ sos_physmem_unref_physpage(ppage_paddr);
+ }
+ }
+
+ /* Undo the allocation if failed to allocate or map a new page */
+ if (! ppage_paddr)
+ {
+ sos_kmem_vmm_del_range(new_range);
+ return NULL;
+ }
+
+ /* Ok, set the range owner for this page */
+ sos_physmem_set_kmem_range(ppage_paddr, new_range);
+ }
+ }
+ /* ... Otherwise: Demand Paging will do the job */
+
+ if (range_start)
+ *range_start = new_range->base_vaddr;
+
+ return new_range;
+}
+
+
+sos_ret_t sos_kmem_vmm_del_range(struct sos_kmem_range *range)
+{
+ int i;
+ struct sos_kmem_range *ranges_to_free;
+ list_init(ranges_to_free);
+
+ SOS_ASSERT_FATAL(range != NULL);
+ SOS_ASSERT_FATAL(range->slab == NULL);
+
+ /* Remove the range from the 'USED' list now */
+ list_delete(kmem_used_range_list, range);
+
+ /*
+ * The following do..while() loop is here to avoid an indirect
+ * recursion: if we call directly kmem_cache_free() from inside the
+ * current function, we take the risk to re-enter the current function
+ * (sos_kmem_vmm_del_range()) again, which may cause problem if it
+ * in turn calls kmem_slab again and sos_kmem_vmm_del_range again,
+ * and again and again. This may happen while freeing ranges of
+ * struct sos_kslab...
+ *
+ * To avoid this,we choose to call a special function of kmem_slab
+ * doing almost the same as sos_kmem_cache_free(), but which does
+ * NOT call us (ie sos_kmem_vmm_del_range()): instead WE add the
+ * range that is to be freed to a list, and the do..while() loop is
+ * here to process this list ! The recursion is replaced by
+ * classical iterations.
+ */
+ do
+ {
+ /* Ok, we got the range. Now, insert this range in the free list */
+ kmem_free_range_list = insert_range(kmem_free_range_list, range);
+
+ /* Unmap the physical pages */
+ for (i = 0 ; i < range->nb_pages ; i ++)
+ {
+ /* This will work even if no page is mapped at this address */
+ sos_paging_unmap(range->base_vaddr + i*SOS_PAGE_SIZE);
+ }
+
+ /* Eventually coalesce it with prev/next free ranges (there is
+ always a valid prev/next link since the list is circular). Note:
+ the tests below will lead to correct behaviour even if the list
+ is limited to the 'range' singleton, at least as long as the
+ range is not zero-sized */
+ /* Merge with preceding one ? */
+ if (range->prev->base_vaddr + range->prev->nb_pages*SOS_PAGE_SIZE
+ == range->base_vaddr)
+ {
+ struct sos_kmem_range *empty_range_of_ranges = NULL;
+ struct sos_kmem_range *prec_free = range->prev;
+
+ /* Merge them */
+ prec_free->nb_pages += range->nb_pages;
+ list_delete(kmem_free_range_list, range);
+
+ /* Mark the range as free. This may cause the slab owning
+ the range to become empty */
+ empty_range_of_ranges =
+ sos_kmem_cache_release_struct_range(range);
+
+ /* If this causes the slab owning the range to become empty,
+ add the range corresponding to the slab at the end of the
+ list of the ranges to be freed: it will be actually freed
+ in one of the next iterations of the do{} loop. */
+ if (empty_range_of_ranges != NULL)
+ {
+ list_delete(kmem_used_range_list, empty_range_of_ranges);
+ list_add_tail(ranges_to_free, empty_range_of_ranges);
+ }
+
+ /* Set range to the beginning of this coelescion */
+ range = prec_free;
+ }
+
+ /* Merge with next one ? [NO 'else' since range may be the result of
+ the merge above] */
+ if (range->base_vaddr + range->nb_pages*SOS_PAGE_SIZE
+ == range->next->base_vaddr)
+ {
+ struct sos_kmem_range *empty_range_of_ranges = NULL;
+ struct sos_kmem_range *next_range = range->next;
+
+ /* Merge them */
+ range->nb_pages += next_range->nb_pages;
+ list_delete(kmem_free_range_list, next_range);
+
+ /* Mark the next_range as free. This may cause the slab
+ owning the next_range to become empty */
+ empty_range_of_ranges =
+ sos_kmem_cache_release_struct_range(next_range);
+
+ /* If this causes the slab owning the next_range to become
+ empty, add the range corresponding to the slab at the end
+ of the list of the ranges to be freed: it will be
+ actually freed in one of the next iterations of the
+ do{} loop. */
+ if (empty_range_of_ranges != NULL)
+ {
+ list_delete(kmem_used_range_list, empty_range_of_ranges);
+ list_add_tail(ranges_to_free, empty_range_of_ranges);
+ }
+ }
+
+
+ /* If deleting the range(s) caused one or more range(s) to be
+ freed, get the next one to free */
+ if (list_is_empty(ranges_to_free))
+ range = NULL; /* No range left to free */
+ else
+ range = list_pop_head(ranges_to_free);
+
+ }
+ /* Stop when there is no range left to be freed for now */
+ while (range != NULL);
+
+ return SOS_OK;
+}
+
+
+sos_vaddr_t sos_kmem_vmm_alloc(sos_count_t nb_pages,
+ sos_ui32_t flags)
+{
+ struct sos_kmem_range *range
+ = sos_kmem_vmm_new_range(nb_pages,
+ flags,
+ NULL);
+ if (! range)
+ return (sos_vaddr_t)NULL;
+
+ return range->base_vaddr;
+}
+
+
+sos_ret_t sos_kmem_vmm_free(sos_vaddr_t vaddr)
+{
+ struct sos_kmem_range *range = lookup_range(vaddr);
+
+ /* We expect that the given address is the base address of the
+ range */
+ if (!range || (range->base_vaddr != vaddr))
+ return -SOS_EINVAL;
+
+ /* We expect that this range is not held by any cache */
+ if (range->slab != NULL)
+ return -SOS_EBUSY;
+
+ return sos_kmem_vmm_del_range(range);
+}
+
+
+sos_ret_t sos_kmem_vmm_set_slab(struct sos_kmem_range *range,
+ struct sos_kslab *slab)
+{
+ if (! range)
+ return -SOS_EINVAL;
+
+ range->slab = slab;
+ return SOS_OK;
+}
+
+struct sos_kslab * sos_kmem_vmm_resolve_slab(sos_vaddr_t vaddr)
+{
+ struct sos_kmem_range *range = lookup_range(vaddr);
+ if (! range)
+ return NULL;
+
+ return range->slab;
+}
+
+
+sos_bool_t sos_kmem_vmm_is_valid_vaddr(sos_vaddr_t vaddr)
+{
+ struct sos_kmem_range *range = lookup_range(vaddr);
+ return (range != NULL);
+}
diff --git a/sos-code-article6.75/sos/kmem_vmm.h b/sos-code-article6.75/sos/kmem_vmm.h
new file mode 100644
index 0000000..49b262d
--- /dev/null
+++ b/sos-code-article6.75/sos/kmem_vmm.h
@@ -0,0 +1,113 @@
+/* Copyright (C) 2000 Thomas Petazzoni
+ Copyright (C) 2004 David Decotigny
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#ifndef _SOS_KMEM_VMM_H_
+#define _SOS_KMEM_VMM_H_
+
+/**
+ * @file kmem_vmm.h
+ *
+ * Kernel Memory Allocator for multiple-page-sized objects residing in
+ * the kernel (virtual memory) space. Relies on the slab cache
+ * allocator to allocate its (internal) "range" data structure.
+ */
+
+#include <hwcore/paging.h>
+
+/* The base and top virtual addresses covered by the kernel allocator */
+#define SOS_KMEM_VMM_BASE 0x4000 /* 16kB */
+#define SOS_KMEM_VMM_TOP SOS_PAGING_MIRROR_VADDR /* 1GB - 4MB */
+
+/** Opaque structure used internally and declared here for physmem.h */
+struct sos_kmem_range;
+
+#include <sos/kmem_slab.h>
+
+/**
+ * Mark the areas belonging to SOS_KMEM_VMM_BASE and SOS_KMEM_VMM_TOP
+ * are either used or free. Those that are already mapped are marked
+ * as "used", and the 0..SOS_KMEM_VMM_BASE virtual addresses as marked
+ * as "used" too (to detect incorrect pointer dereferences).
+ */
+sos_ret_t
+sos_kmem_vmm_subsystem_setup(sos_vaddr_t kernel_core_base_vaddr,
+ sos_vaddr_t kernel_core_top_vaddr,
+ sos_vaddr_t bootstrap_stack_bottom_vaddr,
+ sos_vaddr_t bootstrap_stack_top_vaddr);
+
+
+/*
+ * Flags for kmem_vmm_new_range and kmem_vmm_alloc
+ */
+/** Physical pages should be immediately mapped */
+#define SOS_KMEM_VMM_MAP (1<<0)
+/** Allocation should either success or fail, without blocking */
+#define SOS_KMEM_VMM_ATOMIC (1<<1)
+
+/**
+ * Allocate a new kernel area spanning one or multiple pages.
+ *
+ * @param range_base_vaddr If not NULL, the start address of the range
+ * is stored in this location
+ * @eturn a new range structure
+ */
+struct sos_kmem_range *sos_kmem_vmm_new_range(sos_size_t nb_pages,
+ sos_ui32_t flags,
+ sos_vaddr_t *range_base_vaddr);
+sos_ret_t sos_kmem_vmm_del_range(struct sos_kmem_range *range);
+
+
+/**
+ * Straighforward variant of sos_kmem_vmm_new_range() returning the
+ * range's start address instead of the range structure
+ */
+sos_vaddr_t sos_kmem_vmm_alloc(sos_size_t nb_pages,
+ sos_ui32_t flags);
+
+/**
+ * @note you are perfectly allowed to give the address of the
+ * kernel image, or the address of the bios area here, it will work:
+ * the kernel/bios WILL be "deallocated". But if you really want to do
+ * this, well..., do expect some "surprises" ;)
+ */
+sos_ret_t sos_kmem_vmm_free(sos_vaddr_t vaddr);
+
+
+/**
+ * @return TRUE when vaddr is covered by any (used) kernel range
+ */
+sos_bool_t sos_kmem_vmm_is_valid_vaddr(sos_vaddr_t vaddr);
+
+
+/* *****************************
+ * Reserved to kmem_slab.c ONLY.
+ */
+/**
+ * Associate the range with the given slab.
+ */
+sos_ret_t sos_kmem_vmm_set_slab(struct sos_kmem_range *range,
+ struct sos_kslab *slab);
+
+/**
+ * Retrieve the (used) slab associated with the range covering vaddr.
+ *
+ * @return NULL if the range is not associated with a KMEM range
+ */
+struct sos_kslab *sos_kmem_vmm_resolve_slab(sos_vaddr_t vaddr);
+
+#endif /* _SOS_KMEM_VMM_H_ */
diff --git a/sos-code-article6.75/sos/ksynch.c b/sos-code-article6.75/sos/ksynch.c
new file mode 100644
index 0000000..edbd800
--- /dev/null
+++ b/sos-code-article6.75/sos/ksynch.c
@@ -0,0 +1,235 @@
+/* Copyright (C) 2004 David Decotigny
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+
+
+#include <hwcore/irq.h>
+
+
+#include "ksynch.h"
+
+
+sos_ret_t sos_ksema_init(struct sos_ksema *sema, const char *name,
+ int initial_value,
+ sos_kwaitq_ordering_t ordering)
+{
+ sema->value = initial_value;
+ return sos_kwaitq_init(& sema->kwaitq, name, ordering);
+}
+
+
+sos_ret_t sos_ksema_dispose(struct sos_ksema *sema)
+{
+ return sos_kwaitq_dispose(& sema->kwaitq);
+}
+
+
+sos_ret_t sos_ksema_down(struct sos_ksema *sema,
+ struct sos_time *timeout)
+{
+ sos_ui32_t flags;
+ sos_ret_t retval;
+
+ sos_disable_IRQs(flags);
+ retval = SOS_OK;
+
+ sema->value --;
+ if (sema->value < 0)
+ {
+ /* Wait for somebody to wake us */
+ retval = sos_kwaitq_wait(& sema->kwaitq, timeout);
+
+ /* Something wrong happened (timeout, external wakeup, ...) ? */
+ if (SOS_OK != retval)
+ {
+ /* Yes: pretend we did not ask for the semaphore */
+ sema->value ++;
+ }
+ }
+
+ sos_restore_IRQs(flags);
+ return retval;
+}
+
+
+sos_ret_t sos_ksema_trydown(struct sos_ksema *sema)
+{
+ sos_ui32_t flags;
+ sos_ret_t retval;
+
+ sos_disable_IRQs(flags);
+
+ /* Can we take the semaphore without blocking ? */
+ if (sema->value >= 1)
+ {
+ /* Yes: we take it now */
+ sema->value --;
+ retval = SOS_OK;
+ }
+ else
+ {
+ /* No: we signal it */
+ retval = -SOS_EBUSY;
+ }
+
+ sos_restore_IRQs(flags);
+ return retval;
+}
+
+
+sos_ret_t sos_ksema_up(struct sos_ksema *sema)
+{
+ sos_ui32_t flags;
+ sos_ret_t retval;
+
+ sos_disable_IRQs(flags);
+
+ sema->value ++;
+ retval = sos_kwaitq_wakeup(& sema->kwaitq, 1, SOS_OK);
+
+ sos_restore_IRQs(flags);
+ return retval;
+}
+
+
+sos_ret_t sos_kmutex_init(struct sos_kmutex *mutex, const char *name,
+ sos_kwaitq_ordering_t ordering)
+{
+ mutex->owner = NULL;
+ return sos_kwaitq_init(& mutex->kwaitq, name, ordering);
+}
+
+
+sos_ret_t sos_kmutex_dispose(struct sos_kmutex *mutex)
+{
+ return sos_kwaitq_dispose(& mutex->kwaitq);
+}
+
+
+/*
+ * Implementation based on ownership transfer (ie no while()
+ * loop). The only assumption is that the thread awoken by
+ * kmutex_unlock is not suppressed before effectively waking up: in
+ * that case the mutex will be forever locked AND unlockable (by
+ * nobody other than the owner, but this is not natural since this
+ * owner already issued an unlock()...). The same problem happens with
+ * the semaphores, but in a less obvious manner.
+ */
+sos_ret_t sos_kmutex_lock(struct sos_kmutex *mutex,
+ struct sos_time *timeout)
+{
+ __label__ exit_kmutex_lock;
+ sos_ui32_t flags;
+ sos_ret_t retval;
+
+ sos_disable_IRQs(flags);
+ retval = SOS_OK;
+
+ /* Mutex already owned ? */
+ if (NULL != mutex->owner)
+ {
+ /* Owned by us or by someone else ? */
+ if (sos_thread_get_current() == mutex->owner)
+ {
+ /* Owned by us: do nothing */
+ retval = -SOS_EBUSY;
+ goto exit_kmutex_lock;
+ }
+
+ /* Wait for somebody to wake us */
+ retval = sos_kwaitq_wait(& mutex->kwaitq, timeout);
+
+ /* Something wrong happened ? */
+ if (SOS_OK != retval)
+ {
+ goto exit_kmutex_lock;
+ }
+ }
+
+ /* Ok, the mutex is available to us: take it */
+ mutex->owner = sos_thread_get_current();
+
+ exit_kmutex_lock:
+ sos_restore_IRQs(flags);
+ return retval;
+}
+
+
+sos_ret_t sos_kmutex_trylock(struct sos_kmutex *mutex)
+{
+ sos_ui32_t flags;
+ sos_ret_t retval;
+
+ sos_disable_IRQs(flags);
+
+ /* Mutex available to us ? */
+ if (NULL == mutex->owner)
+ {
+ /* Great ! Take it now */
+ mutex->owner = sos_thread_get_current();
+
+ retval = SOS_OK;
+ }
+ else
+ {
+ /* No: signal it */
+ retval = -SOS_EBUSY;
+ }
+
+ sos_restore_IRQs(flags);
+ return retval;
+}
+
+
+sos_ret_t sos_kmutex_unlock(struct sos_kmutex *mutex)
+{
+ sos_ui32_t flags;
+ sos_ret_t retval;
+
+ sos_disable_IRQs(flags);
+
+ if (sos_thread_get_current() != mutex->owner)
+ retval = -SOS_EPERM;
+
+ else if (sos_kwaitq_is_empty(& mutex->kwaitq))
+ {
+ /*
+ * There is NOT ANY thread waiting => we really mark the mutex
+ * as FREE
+ */
+ mutex->owner = NULL;
+ retval = SOS_OK;
+ }
+ else
+ {
+ /*
+ * There is at least 1 thread waiting => we DO NOT mark the
+ * mutex as free !
+ * Actually, we should have written:
+ * mutex->owner = thread_that_is_woken_up;
+ * But the real Id of the next thread owning the mutex is not
+ * that important. What is important here is that mutex->owner
+ * IS NOT NULL. Otherwise there will be a possibility for the
+ * thread woken up here to have the mutex stolen by a thread
+ * locking the mutex in the meantime.
+ */
+ retval = sos_kwaitq_wakeup(& mutex->kwaitq, 1, SOS_OK);
+ }
+
+ sos_restore_IRQs(flags);
+ return retval;
+}
diff --git a/sos-code-article6.75/sos/ksynch.h b/sos-code-article6.75/sos/ksynch.h
new file mode 100644
index 0000000..47d8675
--- /dev/null
+++ b/sos-code-article6.75/sos/ksynch.h
@@ -0,0 +1,172 @@
+/* Copyright (C) 2004 David Decotigny
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#ifndef _SOS_KSYNCH_H_
+#define _SOS_KSYNCH_H_
+
+
+/**
+ * @file synch.h
+ *
+ * Common kernel synchronisation primitives.
+ */
+
+
+#include <sos/errno.h>
+#include <sos/kwaitq.h>
+
+
+/* ====================================================================
+ * Kernel semaphores, NON-recursive
+ */
+
+
+/**
+ * The structure of a (NON-RECURSIVE) kernel Semaphore
+ */
+struct sos_ksema
+{
+ int value;
+ struct sos_kwaitq kwaitq;
+};
+
+
+/*
+ * Initialize a kernel semaphore structure with the given name
+ *
+ * @param name Name of the semaphore (for debugging purpose only; safe
+ * [deep copied])
+ *
+ * @param initial_value The value of the semaphore before any up/down
+ */
+sos_ret_t sos_ksema_init(struct sos_ksema *sema, const char *name,
+ int initial_value,
+ sos_kwaitq_ordering_t ordering);
+
+
+/*
+ * De-initialize a kernel semaphore
+ *
+ * @return -SOS_EBUSY when semaphore could not be de-initialized
+ * because at least a thread is in the waitq.
+ */
+sos_ret_t sos_ksema_dispose(struct sos_ksema *sema);
+
+
+/*
+ * Enters the semaphore
+ *
+ * @param timeout Maximum time to wait for the semaphore. Or NULL for
+ * "no limit". Updated on return to reflect the time remaining (0 when
+ * timeout has been triggered)
+ *
+ * @return -SOS_EINTR when timeout was triggered or when another waitq
+ * woke us up.
+ *
+ * @note This is a BLOCKING FUNCTION
+ */
+sos_ret_t sos_ksema_down(struct sos_ksema *sema,
+ struct sos_time *timeout);
+
+
+/*
+ * Try to enter the semaphore without blocking.
+ *
+ * @return -SOS_EBUSY when locking the semaphore would block
+ */
+sos_ret_t sos_ksema_trydown(struct sos_ksema *sema);
+
+
+/**
+ * Increments the semaphore's value, eventually waking up a thread
+ */
+sos_ret_t sos_ksema_up(struct sos_ksema *sema);
+
+
+
+/* ====================================================================
+ * Kernel mutex (ie binary semaphore with strong ownership),
+ * NON-recursive !
+ */
+
+
+/**
+ * The structure of a (NON-RECURSIVE) kernel Mutex
+ */
+struct sos_kmutex
+{
+ struct sos_thread *owner;
+ struct sos_kwaitq kwaitq;
+};
+
+
+/*
+ * Initialize a kernel mutex structure with the given name
+ *
+ * @param name Name of the mutex (for debugging purpose only; safe
+ * [deep copied])
+ *
+ * @param initial_value The value of the mutex before any up/down
+ */
+sos_ret_t sos_kmutex_init(struct sos_kmutex *mutex, const char *name,
+ sos_kwaitq_ordering_t ordering);
+
+
+/*
+ * De-initialize a kernel mutex
+ *
+ * @return -SOS_EBUSY when mutex could not be de-initialized
+ * because at least a thread is in the waitq.
+ */
+sos_ret_t sos_kmutex_dispose(struct sos_kmutex *mutex);
+
+
+/*
+ * Lock the mutex. If the same thread multiply locks the same mutex,
+ * it won't hurt (no deadlock, return value = -SOS_EBUSY).
+ *
+ * @param timeout Maximum time to wait for the mutex. Or NULL for "no
+ * limit". Updated on return to reflect the time remaining (0 when
+ * timeout has been triggered)
+ *
+ * @return -SOS_EINTR when timeout was triggered or when another waitq
+ * woke us up, -SOS_EBUSY when the thread already owns the mutex.
+ *
+ * @note This is a BLOCKING FUNCTION
+ */
+sos_ret_t sos_kmutex_lock(struct sos_kmutex *mutex,
+ struct sos_time *timeout);
+
+
+/*
+ * Try to lock the mutex without blocking.
+ *
+ * @return -SOS_EBUSY when locking the mutex would block
+ */
+sos_ret_t sos_kmutex_trylock(struct sos_kmutex *mutex);
+
+
+/**
+ * Unlock the mutex, eventually waking up a thread
+ *
+ * @return -SOS_EPERM when the calling thread is NOT the owner of the
+ * mutex
+ */
+sos_ret_t sos_kmutex_unlock(struct sos_kmutex *mutex);
+
+
+#endif /* _SOS_KSYNCH_H_ */
diff --git a/sos-code-article6.75/sos/kwaitq.c b/sos-code-article6.75/sos/kwaitq.c
new file mode 100644
index 0000000..2b49a04
--- /dev/null
+++ b/sos-code-article6.75/sos/kwaitq.c
@@ -0,0 +1,321 @@
+/* Copyright (C) 2004 David Decotigny
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+
+#include <sos/klibc.h>
+#include <sos/list.h>
+#include <sos/assert.h>
+#include <hwcore/irq.h>
+
+#include "kwaitq.h"
+
+
+sos_ret_t sos_kwaitq_init(struct sos_kwaitq *kwq,
+ const char *name,
+ sos_kwaitq_ordering_t ordering)
+{
+ memset(kwq, 0x0, sizeof(struct sos_kwaitq));
+
+#ifdef SOS_KWQ_DEBUG
+ if (! name)
+ name = "<unknown>";
+ strzcpy(kwq->name, name, SOS_KWQ_DEBUG_MAX_NAMELEN);
+#endif
+ kwq->ordering = ordering;
+ list_init_named(kwq->waiting_list,
+ prev_entry_in_kwaitq, next_entry_in_kwaitq);
+
+ return SOS_OK;
+}
+
+
+sos_ret_t sos_kwaitq_dispose(struct sos_kwaitq *kwq)
+{
+ sos_ui32_t flags;
+ sos_ret_t retval;
+
+ sos_disable_IRQs(flags);
+ if (list_is_empty_named(kwq->waiting_list,
+ prev_entry_in_kwaitq, next_entry_in_kwaitq))
+ retval = SOS_OK;
+ else
+ retval = -SOS_EBUSY;
+
+ sos_restore_IRQs(flags);
+ return retval;
+}
+
+
+sos_bool_t sos_kwaitq_is_empty(const struct sos_kwaitq *kwq)
+{
+ sos_ui32_t flags;
+ sos_ret_t retval;
+
+ sos_disable_IRQs(flags);
+ retval = list_is_empty_named(kwq->waiting_list,
+ prev_entry_in_kwaitq, next_entry_in_kwaitq);
+
+ sos_restore_IRQs(flags);
+ return retval;
+}
+
+
+sos_ret_t sos_kwaitq_init_entry(struct sos_kwaitq_entry *kwq_entry)
+{
+ memset(kwq_entry, 0x0, sizeof(struct sos_kwaitq_entry));
+ kwq_entry->thread = sos_thread_get_current();
+ return SOS_OK;
+}
+
+
+/** Internal helper function equivalent to sos_kwaitq_add_entry(), but
+ without interrupt protection scheme */
+inline static sos_ret_t
+_kwaitq_add_entry(struct sos_kwaitq *kwq,
+ struct sos_kwaitq_entry *kwq_entry,
+ sos_sched_priority_t prio)
+{
+ struct sos_kwaitq_entry *next_entry = NULL, *entry;
+ int nb_entries;
+
+ /* This entry is already added in the kwaitq ! */
+ SOS_ASSERT_FATAL(NULL == kwq_entry->kwaitq);
+
+ /* sos_kwaitq_init_entry() has not been called ?! */
+ SOS_ASSERT_FATAL(NULL != kwq_entry->thread);
+
+ /* (Re-)Initialize wakeup status of the entry */
+ kwq_entry->wakeup_triggered = FALSE;
+ kwq_entry->wakeup_status = SOS_OK;
+
+ /* Insert this entry in the kwaitq waiting list */
+ switch (kwq->ordering)
+ {
+ case SOS_KWQ_ORDER_FIFO:
+ /* Insertion in the list in FIFO order */
+ {
+ /* Add the thread in the list */
+ list_add_tail_named(kwq->waiting_list, kwq_entry,
+ prev_entry_in_kwaitq, next_entry_in_kwaitq);
+ }
+ break;
+
+ case SOS_KWQ_ORDER_PRIO:
+ /* Priority-driven insertion in the list */
+ {
+ /* Look for the place where to insert the thread in the queue (we
+ want to order them in order of increasing priorities) */
+ list_foreach_forward_named(kwq->waiting_list, entry, nb_entries,
+ prev_entry_in_kwaitq, next_entry_in_kwaitq)
+ {
+ /* Does the thread we want to insert have higher priority than
+ the given thread in the queue ? */
+ if (SOS_SCHED_PRIO_CMP(prio,
+ sos_thread_get_priority(entry->thread))
+ > 0)
+ {
+ /* Yes: we insert before this given thread */
+ next_entry = entry;
+ break;
+ }
+ }
+
+ /* Actually insert the entry in the list */
+ if (next_entry != NULL)
+ {
+ list_insert_before_named(kwq->waiting_list, kwq_entry, next_entry,
+ prev_entry_in_kwaitq,
+ next_entry_in_kwaitq);
+ }
+ else
+ {
+ /* The thread we want to insert has less priority than any
+ other in the list */
+ list_add_tail_named(kwq->waiting_list, kwq_entry,
+ prev_entry_in_kwaitq, next_entry_in_kwaitq);
+ }
+ }
+ break;
+
+ default:
+ SOS_FATAL_ERROR("Invalid kwq ordering %d !\n", kwq->ordering);
+ break;
+ }
+
+ /* Update the list of waitqueues for the thread */
+ list_add_tail_named(kwq_entry->thread->kwaitq_list, kwq_entry,
+ prev_entry_for_thread, next_entry_for_thread);
+
+ kwq_entry->kwaitq = kwq;
+
+ return SOS_OK;
+}
+
+
+sos_ret_t sos_kwaitq_add_entry(struct sos_kwaitq *kwq,
+ struct sos_kwaitq_entry *kwq_entry)
+{
+ sos_ui32_t flags;
+ sos_ret_t retval;
+
+ sos_disable_IRQs(flags);
+ retval = _kwaitq_add_entry(kwq, kwq_entry,
+ sos_thread_get_priority(kwq_entry->thread));
+ sos_restore_IRQs(flags);
+
+ return retval;
+}
+
+
+/** Internal helper function equivalent to sos_kwaitq_remove_entry(),
+ but without interrupt protection scheme */
+inline static sos_ret_t
+_kwaitq_remove_entry(struct sos_kwaitq *kwq,
+ struct sos_kwaitq_entry *kwq_entry)
+{
+ SOS_ASSERT_FATAL(kwq_entry->kwaitq == kwq);
+
+ list_delete_named(kwq->waiting_list, kwq_entry,
+ prev_entry_in_kwaitq, next_entry_in_kwaitq);
+
+ list_delete_named(kwq_entry->thread->kwaitq_list, kwq_entry,
+ prev_entry_for_thread, next_entry_for_thread);
+
+ kwq_entry->kwaitq = NULL;
+ return SOS_OK;
+}
+
+
+sos_ret_t sos_kwaitq_remove_entry(struct sos_kwaitq *kwq,
+ struct sos_kwaitq_entry *kwq_entry)
+{
+ sos_ui32_t flags;
+ sos_ret_t retval;
+
+ sos_disable_IRQs(flags);
+ retval = _kwaitq_remove_entry(kwq, kwq_entry);
+ sos_restore_IRQs(flags);
+
+ return retval;
+}
+
+
+sos_ret_t sos_kwaitq_wait(struct sos_kwaitq *kwq,
+ struct sos_time *timeout)
+{
+ sos_ui32_t flags;
+ sos_ret_t retval;
+ struct sos_kwaitq_entry kwq_entry;
+
+ sos_kwaitq_init_entry(& kwq_entry);
+
+ sos_disable_IRQs(flags);
+
+ retval = _kwaitq_add_entry(kwq, & kwq_entry,
+ sos_thread_get_priority(kwq_entry.thread));
+
+ /* Wait for wakeup or timeout */
+ sos_thread_sleep(timeout);
+ /* Woken up ! */
+
+ /* Sleep delay elapsed ? */
+ if (! kwq_entry.wakeup_triggered)
+ {
+ /* Yes (timeout occured, or wakeup on another waitqueue): remove
+ the waitq entry by ourselves */
+ _kwaitq_remove_entry(kwq, & kwq_entry);
+ retval = -SOS_EINTR;
+ }
+ else
+ {
+ retval = kwq_entry.wakeup_status;
+ }
+
+ sos_restore_IRQs(flags);
+
+ /* We were correctly awoken: position return status */
+ return retval;
+}
+
+
+sos_ret_t sos_kwaitq_wakeup(struct sos_kwaitq *kwq,
+ unsigned int nb_threads,
+ sos_ret_t wakeup_status)
+{
+ sos_ui32_t flags;
+
+ sos_disable_IRQs(flags);
+
+ /* Wake up as much threads waiting in waitqueue as possible (up to
+ nb_threads), scanning the list in FIFO/decreasing priority order
+ (depends on the kwaitq ordering) */
+ while (! list_is_empty_named(kwq->waiting_list,
+ prev_entry_in_kwaitq, next_entry_in_kwaitq))
+ {
+ struct sos_kwaitq_entry *kwq_entry
+ = list_get_head_named(kwq->waiting_list,
+ prev_entry_in_kwaitq, next_entry_in_kwaitq);
+
+ /* Enough threads woken up ? */
+ if (nb_threads <= 0)
+ break;
+
+ /*
+ * Ok: wake up the thread for this entry
+ */
+
+ /* Thread already woken up ? */
+ if (SOS_THR_RUNNING == sos_thread_get_state(kwq_entry->thread))
+ {
+ /* Yes => Do nothing because WE are that woken-up thread. In
+ particular: don't call set_ready() here because this
+ would result in an inconsistent configuration (currently
+ running thread marked as "waiting for CPU"...). */
+ continue;
+ }
+ else
+ {
+ /* No => wake it up now. */
+ sos_sched_set_ready(kwq_entry->thread);
+ }
+
+ /* Remove this waitq entry */
+ _kwaitq_remove_entry(kwq, kwq_entry);
+ kwq_entry->wakeup_triggered = TRUE;
+ kwq_entry->wakeup_status = wakeup_status;
+
+ /* Next iteration... */
+ nb_threads --;
+ }
+
+ sos_restore_IRQs(flags);
+
+ return SOS_OK;
+}
+
+
+/* Internal function (callback for thread subsystem) */
+sos_ret_t sos_kwaitq_change_priority(struct sos_kwaitq *kwq,
+ struct sos_kwaitq_entry *kwq_entry,
+ sos_sched_priority_t priority)
+{
+ /* Reorder the waiting list */
+ _kwaitq_remove_entry(kwq, kwq_entry);
+ _kwaitq_add_entry(kwq, kwq_entry, priority);
+
+ return SOS_OK;
+}
diff --git a/sos-code-article6.75/sos/kwaitq.h b/sos-code-article6.75/sos/kwaitq.h
new file mode 100644
index 0000000..9bc6c39
--- /dev/null
+++ b/sos-code-article6.75/sos/kwaitq.h
@@ -0,0 +1,216 @@
+/* Copyright (C) 2004 David Decotigny
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#ifndef _SOS_KWAITQ_H_
+#define _SOS_KWAITQ_H_
+
+#include <sos/errno.h>
+#include <sos/thread.h>
+#include <sos/time.h>
+
+
+/**
+ * @kwaitq.h
+ *
+ * Low-level functions to manage queues of threads waiting for a
+ * resource. These functions are public, except
+ * sos_kwaitq_change_priority() that is a callback for the thread
+ * subsystem. However, for higher-level synchronization primitives
+ * such as mutex, semaphores, conditions, ... prefer to look at the
+ * corresponding libraries.
+ */
+
+
+/**
+ * Define this if you want to know the names of the kwaitq
+ */
+// #define SOS_KWQ_DEBUG
+
+
+/* Forward declaration */
+struct sos_kwaitq_entry;
+
+
+/**
+ * The threads in the kwaitqs can be ordered in FIFO or in decreasing
+ * priority order.
+ */
+typedef enum { SOS_KWQ_ORDER_FIFO, SOS_KWQ_ORDER_PRIO } sos_kwaitq_ordering_t;
+
+
+#include <sos/sched.h>
+
+
+/**
+ * Definition of a waitqueue. In a kwaitq, the threads can be ordererd
+ * either in FIFO order (SOS_KWQ_ORDER_FIFO) or in decreasing priority
+ * order (SOS_KWQ_ORDER_PRIO ; with FIFO ordering for same-prio
+ * threads).
+ *
+ * A more efficient method to store the threads ordered by their
+ * priority would have been to use 1 list for each priority level. But
+ * we have to be careful to the size of a kwaitq structure here:
+ * potentially there are thousands of kwaitq in a running system
+ * (basically: 1 per opened file !). The algorithm we use to order the
+ * threads in the kwaitq in this case is highly under-optimal (naive
+ * linear insertion): as an exercise, one can implement a more
+ * efficient algorithm (think of a heap).
+ */
+struct sos_kwaitq
+{
+#ifdef SOS_KWQ_DEBUG
+# define SOS_KWQ_DEBUG_MAX_NAMELEN 32
+ char name[SOS_KWQ_DEBUG_MAX_NAMELEN];
+#endif
+ sos_kwaitq_ordering_t ordering;
+ struct sos_kwaitq_entry *waiting_list;
+};
+
+
+/**
+ * Definition of an entry for a thread waiting in the waitqueue
+ */
+struct sos_kwaitq_entry
+{
+ /** The thread associted with this entry */
+ struct sos_thread *thread;
+
+ /** The kwaitqueue this entry belongs to */
+ struct sos_kwaitq *kwaitq;
+
+ /** TRUE when somebody woke up this entry */
+ sos_bool_t wakeup_triggered;
+
+ /** The status of wakeup for this entry. @see wakeup_status argument
+ of sos_kwaitq_wakeup() */
+ sos_ret_t wakeup_status;
+
+ /** Other entries in this kwaitqueue */
+ struct sos_kwaitq_entry *prev_entry_in_kwaitq, *next_entry_in_kwaitq;
+
+ /** Other entries for the thread */
+ struct sos_kwaitq_entry *prev_entry_for_thread, *next_entry_for_thread;
+};
+
+
+/**
+ * Initialize an empty waitqueue.
+ *
+ * @param name Used only if SOS_KWQ_DEBUG is defined (safe [deep
+ * copied])
+ */
+sos_ret_t sos_kwaitq_init(struct sos_kwaitq *kwq,
+ const char *name,
+ sos_kwaitq_ordering_t ordering);
+
+
+/**
+ * Release a waitqueue, making sure that no thread is in it.
+ *
+ * @return -SOS_EBUSY in case a thread is still in the waitqueue.
+ */
+sos_ret_t sos_kwaitq_dispose(struct sos_kwaitq *kwq);
+
+
+/**
+ * Return whether there are no threads in the waitq
+ */
+sos_bool_t sos_kwaitq_is_empty(const struct sos_kwaitq *kwq);
+
+
+/**
+ * Initialize a waitqueue entry. Mainly consists in updating the
+ * "thread" field of the entry (set to current running thread), and
+ * initializing the remaining of the entry as to indicate it does not
+ * belong to any waitq.
+ */
+sos_ret_t sos_kwaitq_init_entry(struct sos_kwaitq_entry *kwq_entry);
+
+
+/**
+ * Add an entry (previously initialized with sos_kwaitq_init_entry())
+ * in the given waitqueue.
+ *
+ * @note: No state change/context switch can occur here ! Among other
+ * things: the current executing thread is not preempted.
+ */
+sos_ret_t sos_kwaitq_add_entry(struct sos_kwaitq *kwq,
+ struct sos_kwaitq_entry *kwq_entry);
+
+
+/**
+ * Remove the given kwaitq_entry from the kwaitq.
+ *
+ * @note: No state change/context switch can occur here ! Among other
+ * things: the thread associated with the entry is not necessarilly
+ * the same as the one currently running, and does not preempt the
+ * current running thread if they are different.
+ */
+sos_ret_t sos_kwaitq_remove_entry(struct sos_kwaitq *kwq,
+ struct sos_kwaitq_entry *kwq_entry);
+
+
+/**
+ * Helper function to make the current running thread block in the
+ * given kwaitq, waiting to be woken up by somedy else or by the given
+ * timeout. It calls the sos_kwaitq_add_entry() and
+ * sos_kwaitq_remove_entry().
+ *
+ * @param timeout The desired timeout (can be NULL => wait for
+ * ever). It is updated by the function to reflect the remaining
+ * timeout in case the thread has been woken-up prior to its
+ * expiration.
+ *
+ * @return -SOS_EINTR when the thread is resumed while it has not be
+ * explicitely woken up by someone calling sos_kwaitq_wakeup() upon
+ * the same waitqueue... This can only happen 1/ if the timeout
+ * expired, or 2/ if the current thread is also in another kwaitq
+ * different to "kwq". Otherwise return the value set by
+ * sos_kwaitq_wakeup(). The timeout remaining is updated in timeout.
+ *
+ * @note This is a BLOCKING FUNCTION
+ */
+sos_ret_t sos_kwaitq_wait(struct sos_kwaitq *kwq,
+ struct sos_time *timeout);
+
+
+/**
+ * Wake up as much as nb_thread threads (SOS_KWQ_WAKEUP_ALL to wake
+ * up all threads) in the kwaitq kwq, in FIFO or decreasing priority
+ * order (depends on the ordering scheme selected at kwaitq
+ * initialization time).
+ *
+ * @param wakeup_status The value returned by sos_kwaitq_wait() when
+ * the thread will effectively woken up due to this wakeup.
+ */
+sos_ret_t sos_kwaitq_wakeup(struct sos_kwaitq *kwq,
+ unsigned int nb_threads,
+ sos_ret_t wakeup_status);
+#define SOS_KWQ_WAKEUP_ALL (~((unsigned int)0))
+
+
+/**
+ * @note INTERNAL function (in particular: interrupts not disabled) !
+ *
+ * @note: The use of this function is RESERVED (to thread.c). Do not
+ * call it directly: use sos_thread_set_priority() for that !
+ */
+sos_ret_t sos_kwaitq_change_priority(struct sos_kwaitq *kwq,
+ struct sos_kwaitq_entry *kwq_entry,
+ sos_sched_priority_t priority);
+
+#endif /* _SOS_KWAITQ_H_ */
diff --git a/sos-code-article6.75/sos/list.h b/sos-code-article6.75/sos/list.h
new file mode 100644
index 0000000..67e72f3
--- /dev/null
+++ b/sos-code-article6.75/sos/list.h
@@ -0,0 +1,186 @@
+/* Copyright (C) 2001 David Decotigny
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#ifndef _SOS_LIST_H_
+#define _SOS_LIST_H_
+
+/**
+ * @file list.h
+ *
+ * Circular doubly-linked lists implementation entirely based on C
+ * macros
+ */
+
+
+/* *_named are used when next and prev links are not exactly next
+ and prev. For instance when we have next_in_team, prev_in_team,
+ prev_global and next_global */
+
+#define list_init_named(list,prev,next) \
+ ((list) = NULL)
+
+#define list_singleton_named(list,item,prev,next) ({ \
+ (item)->next = (item)->prev = (item); \
+ (list) = (item); \
+})
+
+#define list_is_empty_named(list,prev,next) \
+ ((list) == NULL)
+
+#define list_get_head_named(list,prev,next) \
+ (list)
+
+#define list_get_tail_named(list,prev,next) \
+ ((list)?((list)->prev):NULL)
+
+/* Internal macro : insert before the head == insert at tail */
+#define __list_insert_atleft_named(before_this,item,prev,next) ({ \
+ (before_this)->prev->next = (item); \
+ (item)->prev = (before_this)->prev; \
+ (before_this)->prev = (item); \
+ (item)->next = (before_this); \
+})
+
+/* @note Before_this and item are expected to be valid ! */
+#define list_insert_before_named(list,before_this,item,prev,next) ({ \
+ __list_insert_atleft_named(before_this,item,prev,next); \
+ if ((list) == (before_this)) (list) = (item); \
+})
+
+/** @note After_this and item are expected to be valid ! */
+#define list_insert_after_named(list,after_this,item,prev,next) ({ \
+ (after_this)->next->prev = (item); \
+ (item)->next = (after_this)->next; \
+ (after_this)->next = (item); \
+ (item)->prev = (after_this); \
+})
+
+#define list_add_head_named(list,item,prev,next) ({ \
+ if (list) \
+ list_insert_before_named(list,list,item,prev,next); \
+ else \
+ list_singleton_named(list,item,prev,next); \
+ (list) = (item); \
+})
+
+#define list_add_tail_named(list,item,prev,next) ({ \
+ if (list) \
+ __list_insert_atleft_named(list,item,prev,next); \
+ else \
+ list_singleton_named(list,item,prev,next); \
+})
+
+/** @note NO check whether item really is in list ! */
+#define list_delete_named(list,item,prev,next) ({ \
+ if ( ((item)->next == (item)) && ((item)->prev == (item)) ) \
+ (item)->next = (item)->prev = (list) = NULL; \
+ else { \
+ (item)->prev->next = (item)->next; \
+ (item)->next->prev = (item)->prev; \
+ if ((item) == (list)) (list) = (item)->next; \
+ (item)->prev = (item)->next = NULL; \
+ } \
+})
+
+#define list_pop_head_named(list,prev,next) ({ \
+ typeof(list) __ret_elt = (list); \
+ list_delete_named(list,__ret_elt,prev,next); \
+ __ret_elt; })
+
+/** Loop statement that iterates through all of its elements, from
+ head to tail */
+#define list_foreach_forward_named(list,iterator,nb_elements,prev,next) \
+ for (nb_elements=0, (iterator) = (list) ; \
+ (iterator) && (!nb_elements || ((iterator) != (list))) ; \
+ nb_elements++, (iterator) = (iterator)->next )
+
+/** Loop statement that iterates through all of its elements, from
+ tail back to head */
+#define list_foreach_backward_named(list,iterator,nb_elements,prev,next) \
+ for (nb_elements=0, (iterator) = list_get_tail_named(list,prev,next) ; \
+ (iterator) && (!nb_elements || \
+ ((iterator) != list_get_tail_named(list,prev,next))) ; \
+ nb_elements++, (iterator) = (iterator)->prev )
+
+#define list_foreach_named list_foreach_forward_named
+
+/** True when we exitted early from the foreach loop (ie break) */
+#define list_foreach_early_break(list,iterator,nb_elements) \
+ ((list) && ( \
+ ((list) != (iterator)) || \
+ ( ((list) == (iterator)) && (nb_elements == 0)) ))
+
+/** Loop statement that also removes the item at each iteration */
+#define list_collapse_named(list,iterator,prev,next) \
+ for ( ; ({ ((iterator) = (list)) ; \
+ if (list) list_delete_named(list,iterator,prev,next) ; \
+ (iterator); }) ; )
+
+
+/*
+ * the same macros : assume that the prev and next fields are really
+ * named "prev" and "next"
+ */
+
+#define list_init(list) \
+ list_init_named(list,prev,next)
+
+#define list_singleton(list,item) \
+ list_singleton_named(list,item,prev,next)
+
+#define list_is_empty(list) \
+ list_is_empty_named(list,prev,next)
+
+#define list_get_head(list) \
+ list_get_head_named(list,prev,next) \
+
+#define list_get_tail(list) \
+ list_get_tail_named(list,prev,next) \
+
+/* @note Before_this and item are expected to be valid ! */
+#define list_insert_after(list,after_this,item) \
+ list_insert_after_named(list,after_this,item,prev,next)
+
+/* @note After_this and item are expected to be valid ! */
+#define list_insert_before(list,before_this,item) \
+ list_insert_before_named(list,before_this,item,prev,next)
+
+#define list_add_head(list,item) \
+ list_add_head_named(list,item,prev,next)
+
+#define list_add_tail(list,item) \
+ list_add_tail_named(list,item,prev,next)
+
+/* @note NO check whether item really is in list ! */
+#define list_delete(list,item) \
+ list_delete_named(list,item,prev,next)
+
+#define list_pop_head(list) \
+ list_pop_head_named(list,prev,next)
+
+#define list_foreach_forward(list,iterator,nb_elements) \
+ list_foreach_forward_named(list,iterator,nb_elements,prev,next)
+
+#define list_foreach_backward(list,iterator,nb_elements) \
+ list_foreach_backward_named(list,iterator,nb_elements,prev,next)
+
+#define list_foreach list_foreach_forward
+
+#define list_collapse(list,iterator) \
+ list_collapse_named(list,iterator,prev,next)
+
+#endif /* _SOS_LIST_H_ */
diff --git a/sos-code-article6.75/sos/macros.h b/sos-code-article6.75/sos/macros.h
new file mode 100644
index 0000000..80a05d3
--- /dev/null
+++ b/sos-code-article6.75/sos/macros.h
@@ -0,0 +1,41 @@
+/* Copyright (C) 2004 The KOS Team
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#ifndef _SOS_MACROS_H_
+#define _SOS_MACROS_H_
+
+/** Align on a boundary (MUST be a power of 2), so that return value <= val */
+#define SOS_ALIGN_INF(val,boundary) \
+ (((unsigned)(val)) & (~((boundary)-1)))
+
+/** Align on a boundary (MUST be a power of 2), so that return value >= val */
+#define SOS_ALIGN_SUP(val,boundary) \
+ ({ unsigned int __bnd=(boundary); \
+ (((((unsigned)(val))-1) & (~(__bnd - 1))) + __bnd); })
+
+/** Check whether val is aligned on a boundary (MUST be a power of 2) */
+#define SOS_IS_ALIGNED(val,boundary) \
+ ( 0 == (((unsigned)(val)) & ((boundary)-1)) )
+
+/**
+ * @return TRUE if val is a power of 2.
+ * @note val is evaluated multiple times
+ */
+#define SOS_IS_POWER_OF_2(val) \
+ ((((val) - 1) & (val)) == 0)
+
+#endif /* _SOS_MACROS_H_ */
diff --git a/sos-code-article6.75/sos/main.c b/sos-code-article6.75/sos/main.c
new file mode 100644
index 0000000..e4e178c
--- /dev/null
+++ b/sos-code-article6.75/sos/main.c
@@ -0,0 +1,462 @@
+/* Copyright (C) 2004 The SOS Team
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+
+/* Include definitions of the multiboot standard */
+#include <bootstrap/multiboot.h>
+#include <hwcore/idt.h>
+#include <hwcore/gdt.h>
+#include <hwcore/irq.h>
+#include <hwcore/exception.h>
+#include <hwcore/i8254.h>
+#include <sos/list.h>
+#include <sos/physmem.h>
+#include <hwcore/paging.h>
+#include <sos/kmem_vmm.h>
+#include <sos/kmalloc.h>
+#include <sos/time.h>
+#include <sos/thread.h>
+#include <sos/klibc.h>
+#include <sos/assert.h>
+#include <drivers/x86_videomem.h>
+#include <drivers/bochs.h>
+
+
+/* Helper function to display each bits of a 32bits integer on the
+ screen as dark or light carrets */
+void display_bits(unsigned char row, unsigned char col,
+ unsigned char attribute,
+ sos_ui32_t integer)
+{
+ int i;
+ /* Scan each bit of the integer, MSb first */
+ for (i = 31 ; i >= 0 ; i--)
+ {
+ /* Test if bit i of 'integer' is set */
+ int bit_i = (integer & (1 << i));
+ /* Ascii 219 => dark carret, Ascii 177 => light carret */
+ unsigned char ascii_code = bit_i?219:177;
+ sos_x86_videomem_putchar(row, col++,
+ attribute,
+ ascii_code);
+ }
+}
+
+
+/* Clock IRQ handler */
+static void clk_it(int intid)
+{
+ static sos_ui32_t clock_count = 0;
+
+ display_bits(0, 48,
+ SOS_X86_VIDEO_FG_LTGREEN | SOS_X86_VIDEO_BG_BLUE,
+ clock_count);
+ clock_count++;
+
+ /* Execute the expired timeout actions (if any) */
+ sos_time_do_tick();
+}
+
+
+/* ======================================================================
+ * Page fault exception handling
+ */
+
+/* Helper function to dump a backtrace on bochs and/or the console */
+static void dump_backtrace(const struct sos_cpu_state *cpu_state,
+ sos_vaddr_t stack_bottom,
+ sos_size_t stack_size,
+ sos_bool_t on_console,
+ sos_bool_t on_bochs)
+{
+ void backtracer(sos_vaddr_t PC,
+ sos_vaddr_t params,
+ sos_ui32_t depth,
+ void *custom_arg)
+ {
+ sos_ui32_t invalid = 0xffffffff, *arg1, *arg2, *arg3, *arg4;
+
+ /* Get the address of the first 3 arguments from the
+ frame. Among these arguments, 0, 1, 2, 3 arguments might be
+ meaningful (depending on how many arguments the function may
+ take). */
+ arg1 = (sos_ui32_t*)params;
+ arg2 = (sos_ui32_t*)(params+4);
+ arg3 = (sos_ui32_t*)(params+8);
+ arg4 = (sos_ui32_t*)(params+12);
+
+ /* Make sure the addresses of these arguments fit inside the
+ stack boundaries */
+#define INTERVAL_OK(b,v,u) ( ((b) <= (sos_vaddr_t)(v)) \
+ && ((sos_vaddr_t)(v) < (u)) )
+ if (!INTERVAL_OK(stack_bottom, arg1, stack_bottom + stack_size))
+ arg1 = &invalid;
+ if (!INTERVAL_OK(stack_bottom, arg2, stack_bottom + stack_size))
+ arg2 = &invalid;
+ if (!INTERVAL_OK(stack_bottom, arg3, stack_bottom + stack_size))
+ arg3 = &invalid;
+ if (!INTERVAL_OK(stack_bottom, arg4, stack_bottom + stack_size))
+ arg4 = &invalid;
+
+ /* Print the function context for this frame */
+ if (on_bochs)
+ sos_bochs_printf("[%d] PC=0x%x arg1=0x%x arg2=0x%x arg3=0x%x\n",
+ (unsigned)depth, (unsigned)PC,
+ (unsigned)*arg1, (unsigned)*arg2,
+ (unsigned)*arg3);
+
+ if (on_console)
+ sos_x86_videomem_printf(23-depth, 3,
+ SOS_X86_VIDEO_BG_BLUE
+ | SOS_X86_VIDEO_FG_LTGREEN,
+ "[%d] PC=0x%x arg1=0x%x arg2=0x%x arg3=0x%x arg4=0x%x",
+ (unsigned)depth, PC,
+ (unsigned)*arg1, (unsigned)*arg2,
+ (unsigned)*arg3, (unsigned)*arg4);
+
+ }
+
+ sos_backtrace(cpu_state, 15, stack_bottom, stack_size, backtracer, NULL);
+}
+
+
+/* Page fault exception handler with demand paging for the kernel */
+static void pgflt_ex(int intid, const struct sos_cpu_state *ctxt)
+{
+ static sos_ui32_t demand_paging_count = 0;
+ sos_vaddr_t faulting_vaddr = sos_cpu_context_get_EX_faulting_vaddr(ctxt);
+ sos_paddr_t ppage_paddr;
+
+ /* Check if address is covered by any VMM range */
+ if (! sos_kmem_vmm_is_valid_vaddr(faulting_vaddr))
+ {
+ /* No: The page fault is out of any kernel virtual region. For
+ the moment, we don't handle this. */
+ dump_backtrace(ctxt,
+ bootstrap_stack_bottom,
+ bootstrap_stack_size,
+ TRUE, TRUE);
+ sos_display_fatal_error("Unresolved page Fault at instruction 0x%x on access to address 0x%x (info=%x)!",
+ sos_cpu_context_get_PC(ctxt),
+ (unsigned)faulting_vaddr,
+ (unsigned)sos_cpu_context_get_EX_info(ctxt));
+ SOS_ASSERT_FATAL(! "Got page fault (note: demand paging is disabled)");
+ }
+
+
+ /*
+ * Demand paging
+ */
+
+ /* Update the number of demand paging requests handled */
+ demand_paging_count ++;
+ display_bits(0, 0,
+ SOS_X86_VIDEO_FG_LTRED | SOS_X86_VIDEO_BG_BLUE,
+ demand_paging_count);
+
+ /* Allocate a new page for the virtual address */
+ ppage_paddr = sos_physmem_ref_physpage_new(FALSE);
+ if (! ppage_paddr)
+ SOS_ASSERT_FATAL(! "TODO: implement swap. (Out of mem in demand paging because no swap for kernel yet !)");
+ SOS_ASSERT_FATAL(SOS_OK == sos_paging_map(ppage_paddr,
+ SOS_PAGE_ALIGN_INF(faulting_vaddr),
+ FALSE,
+ SOS_VM_MAP_PROT_READ
+ | SOS_VM_MAP_PROT_WRITE
+ | SOS_VM_MAP_ATOMIC));
+ sos_physmem_unref_physpage(ppage_paddr);
+
+ /* Ok, we can now return to interrupted context */
+}
+
+
+/* ======================================================================
+ * Demonstrate the use of SOS kernel threads
+ * - Kernel Threads are created with various priorities and their
+ * state is printed on both the console and the bochs' 0xe9 port
+ * - For tests regarding threads' synchronization, see mouse_sim.c
+ */
+
+struct thr_arg
+{
+ char character;
+ int color;
+
+ int col;
+ int row;
+};
+
+
+static void demo_thread(void *arg)
+{
+ struct thr_arg *thr_arg = (struct thr_arg*)arg;
+ int progress = 0;
+
+ sos_bochs_printf("start %c", thr_arg->character);
+ while (1)
+ {
+ progress ++;
+ display_bits(thr_arg->row, thr_arg->col+1, thr_arg->color, progress);
+
+ sos_bochs_putchar(thr_arg->character);
+
+ /* Yield the CPU to another thread sometimes... */
+ if ((random() % 100) == 0)
+ {
+ sos_bochs_printf("yield(%c)\n", thr_arg->character);
+ sos_x86_videomem_putchar(thr_arg->row, thr_arg->col, 0x1e, 'Y');
+ SOS_ASSERT_FATAL(SOS_OK == sos_thread_yield());
+ sos_x86_videomem_putchar(thr_arg->row, thr_arg->col, 0x1e, 'R');
+ }
+
+ /* Go to sleep some other times... */
+ else if ((random() % 200) == 0)
+ {
+ struct sos_time t = (struct sos_time){ .sec=0, .nanosec=50000000 };
+ sos_bochs_printf("sleep1(%c)\n", thr_arg->character);
+ sos_x86_videomem_putchar(thr_arg->row, thr_arg->col, 0x1e, 's');
+ SOS_ASSERT_FATAL(SOS_OK == sos_thread_sleep(& t));
+ SOS_ASSERT_FATAL(sos_time_is_zero(& t));
+ sos_x86_videomem_putchar(thr_arg->row, thr_arg->col, 0x1e, 'R');
+ }
+
+ /* Go to sleep for a longer time some other times... */
+ else if ((random() % 300) == 0)
+ {
+ struct sos_time t = (struct sos_time){ .sec=0, .nanosec=300000000 };
+ sos_bochs_printf("sleep2(%c)\n", thr_arg->character);
+ sos_x86_videomem_putchar(thr_arg->row, thr_arg->col, 0x1e, 'S');
+ SOS_ASSERT_FATAL(SOS_OK == sos_thread_sleep(& t));
+ SOS_ASSERT_FATAL(sos_time_is_zero(& t));
+ sos_x86_videomem_putchar(thr_arg->row, thr_arg->col, 0x1e, 'R');
+ }
+
+ /* Infinite loop otherwise */
+ }
+}
+
+
+static void test_thread()
+{
+ /* "static" variables because we want them to remain even when the
+ function returns */
+ static struct thr_arg arg_b, arg_c, arg_d, arg_e, arg_R, arg_S;
+ sos_ui32_t flags;
+
+ sos_disable_IRQs(flags);
+
+ arg_b = (struct thr_arg) { .character='b', .col=0, .row=21, .color=0x14 };
+ sos_create_kernel_thread("YO[b]", demo_thread, (void*)&arg_b, SOS_SCHED_PRIO_TS_LOWEST);
+
+ arg_c = (struct thr_arg) { .character='c', .col=46, .row=21, .color=0x14 };
+ sos_create_kernel_thread("YO[c]", demo_thread, (void*)&arg_c, SOS_SCHED_PRIO_TS_LOWEST);
+
+ arg_d = (struct thr_arg) { .character='d', .col=0, .row=20, .color=0x14 };
+ sos_create_kernel_thread("YO[d]", demo_thread, (void*)&arg_d, SOS_SCHED_PRIO_TS_LOWEST-1);
+
+ arg_e = (struct thr_arg) { .character='e', .col=0, .row=19, .color=0x14 };
+ sos_create_kernel_thread("YO[e]", demo_thread, (void*)&arg_e, SOS_SCHED_PRIO_TS_LOWEST-2);
+
+ arg_R = (struct thr_arg) { .character='R', .col=0, .row=17, .color=0x1c };
+ sos_create_kernel_thread("YO[R]", demo_thread, (void*)&arg_R, SOS_SCHED_PRIO_RT_LOWEST);
+
+ arg_S = (struct thr_arg) { .character='S', .col=0, .row=16, .color=0x1c };
+ sos_create_kernel_thread("YO[S]", demo_thread, (void*)&arg_S, SOS_SCHED_PRIO_RT_LOWEST-1);
+
+ sos_restore_IRQs(flags);
+}
+
+
+/* ======================================================================
+ * An operating system MUST always have a ready thread ! Otherwise:
+ * what would the CPU have to execute ?!
+ */
+static void idle_thread()
+{
+ sos_ui32_t idle_twiddle = 0;
+
+ while (1)
+ {
+ /* Remove this instruction if you get an "Invalid opcode" CPU
+ exception (old 80386 CPU) */
+ asm("hlt\n");
+
+ idle_twiddle ++;
+ display_bits(0, 0, SOS_X86_VIDEO_FG_GREEN | SOS_X86_VIDEO_BG_BLUE,
+ idle_twiddle);
+
+ /* Lend the CPU to some other thread */
+ sos_thread_yield();
+ }
+}
+
+
+/* ======================================================================
+ * The C entry point of our operating system
+ */
+void sos_main(unsigned long magic, unsigned long addr)
+{
+ unsigned i;
+ sos_paddr_t sos_kernel_core_base_paddr, sos_kernel_core_top_paddr;
+ struct sos_time tick_resolution;
+
+ /* Grub sends us a structure, called multiboot_info_t with a lot of
+ precious informations about the system, see the multiboot
+ documentation for more information. */
+ multiboot_info_t *mbi;
+ mbi = (multiboot_info_t *) addr;
+
+ /* Setup bochs and console, and clear the console */
+ sos_bochs_setup();
+
+ sos_x86_videomem_setup();
+ sos_x86_videomem_cls(SOS_X86_VIDEO_BG_BLUE);
+
+ /* Greetings from SOS */
+ if (magic == MULTIBOOT_BOOTLOADER_MAGIC)
+ /* Loaded with Grub */
+ sos_x86_videomem_printf(1, 0,
+ SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
+ "Welcome From GRUB to %s%c RAM is %dMB (upper mem = 0x%x kB)",
+ "SOS article 6.75", ',',
+ (unsigned)(mbi->mem_upper >> 10) + 1,
+ (unsigned)mbi->mem_upper);
+ else
+ /* Not loaded with grub */
+ sos_x86_videomem_printf(1, 0,
+ SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
+ "Welcome to SOS article 6.75");
+
+ sos_bochs_putstring("Message in a bochs: This is SOS article 6.75.\n");
+
+ /* Setup CPU segmentation and IRQ subsystem */
+ sos_gdt_subsystem_setup();
+ sos_idt_subsystem_setup();
+
+ /* Setup SOS IRQs and exceptions subsystem */
+ sos_exception_subsystem_setup();
+ sos_irq_subsystem_setup();
+
+ /* Configure the timer so as to raise the IRQ0 at a 100Hz rate */
+ sos_i8254_set_frequency(100);
+
+ /* Setup the kernel time subsystem to get prepared to take the timer
+ ticks into account */
+ tick_resolution = (struct sos_time) { .sec=0, .nanosec=10000000UL };
+ sos_time_subsysem_setup(& tick_resolution);
+
+ /* We need a multiboot-compliant boot loader to get the size of the RAM */
+ if (magic != MULTIBOOT_BOOTLOADER_MAGIC)
+ {
+ sos_x86_videomem_putstring(20, 0,
+ SOS_X86_VIDEO_FG_LTRED
+ | SOS_X86_VIDEO_BG_BLUE
+ | SOS_X86_VIDEO_FG_BLINKING,
+ "I'm not loaded with Grub !");
+ /* STOP ! */
+ for (;;)
+ continue;
+ }
+
+ /*
+ * Some interrupt handlers
+ */
+
+ /* Binding some HW interrupts and exceptions to software routines */
+ sos_irq_set_routine(SOS_IRQ_TIMER,
+ clk_it);
+
+ /*
+ * Setup physical memory management
+ */
+
+ /* Multiboot says: "The value returned for upper memory is maximally
+ the address of the first upper memory hole minus 1 megabyte.". It
+ also adds: "It is not guaranteed to be this value." aka "YMMV" ;) */
+ sos_physmem_subsystem_setup((mbi->mem_upper<<10) + (1<<20),
+ & sos_kernel_core_base_paddr,
+ & sos_kernel_core_top_paddr);
+
+ /*
+ * Switch to paged-memory mode
+ */
+
+ /* Disabling interrupts should seem more correct, but it's not really
+ necessary at this stage */
+ SOS_ASSERT_FATAL(SOS_OK ==
+ sos_paging_subsystem_setup(sos_kernel_core_base_paddr,
+ sos_kernel_core_top_paddr));
+
+ /* Bind the page fault exception */
+ sos_exception_set_routine(SOS_EXCEPT_PAGE_FAULT,
+ pgflt_ex);
+
+ /*
+ * Setup kernel virtual memory allocator
+ */
+
+ if (sos_kmem_vmm_subsystem_setup(sos_kernel_core_base_paddr,
+ sos_kernel_core_top_paddr,
+ bootstrap_stack_bottom,
+ bootstrap_stack_bottom
+ + bootstrap_stack_size))
+ sos_bochs_printf("Could not setup the Kernel virtual space allocator\n");
+
+ if (sos_kmalloc_subsystem_setup())
+ sos_bochs_printf("Could not setup the Kmalloc subsystem\n");
+
+ /*
+ * Initialize the Kernel thread and scheduler subsystems
+ */
+
+ /* Initialize kernel thread subsystem */
+ sos_thread_subsystem_setup(bootstrap_stack_bottom,
+ bootstrap_stack_size);
+
+ /* Initialize the scheduler */
+ sos_sched_subsystem_setup();
+
+ /* Declare the IDLE thread */
+ SOS_ASSERT_FATAL(sos_create_kernel_thread("idle", idle_thread, NULL,
+ SOS_SCHED_PRIO_TS_LOWEST) != NULL);
+
+ /* Enabling the HW interrupts here, this will make the timer HW
+ interrupt call the scheduler */
+ asm volatile ("sti\n");
+
+
+ /* Now run some Kernel threads just for fun ! */
+ extern void MouseSim();
+ MouseSim();
+ test_thread();
+
+ /*
+ * We can safely exit from this function now, for there is already
+ * an idle Kernel thread ready to make the CPU busy working...
+ *
+ * However, we must EXPLICITELY call sos_thread_exit() because a
+ * simple "return" will return nowhere ! Actually this first thread
+ * was initialized by the Grub bootstrap stage, at a time when the
+ * word "thread" did not exist. This means that the stack was not
+ * setup in order for a return here to call sos_thread_exit()
+ * automagically. Hence we must call it manually. This is the ONLY
+ * kernel thread where we must do this manually.
+ */
+ sos_bochs_printf("Bye from primary thread !\n");
+ sos_thread_exit();
+ SOS_FATAL_ERROR("No trespassing !");
+}
diff --git a/sos-code-article6.75/sos/mouse_sim.c b/sos-code-article6.75/sos/mouse_sim.c
new file mode 100644
index 0000000..d2c3dc4
--- /dev/null
+++ b/sos-code-article6.75/sos/mouse_sim.c
@@ -0,0 +1,805 @@
+/***************************************************************************
+ * Copyright (C) 2004 by cyril dupuit *
+ * cyrildupuit@hotmail.com *
+ * http://perso.wanadoo.fr/koalys/ *
+ * (Adaptation for SOS by d2 -- 2004/12/20) *
+ * *
+ * This program is free software; you can redistribute it and/or modify *
+ * it under the terms of the GNU General Public License as published by *
+ * the Free Software Foundation; either version 2 of the License, or *
+ * (at your option) any later version. *
+ * *
+ * This program is distributed in the hope that it will be useful, *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
+ * GNU General Public License for more details. *
+ * *
+ * You should have received a copy of the GNU General Public License *
+ * along with this program; if not, write to the *
+ * Free Software Foundation, Inc., *
+ * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
+ ***************************************************************************/
+
+//*****************************************************************************
+// Nom du module : MouseSim.c
+// Description : Creation et destruction de souris mangeuse de fromages
+//*****************************************************************************
+
+#include <sos/assert.h>
+#include <sos/klibc.h>
+#include <sos/thread.h>
+#include <sos/ksynch.h>
+#include <sos/kmalloc.h>
+#include <drivers/x86_videomem.h>
+
+// Historique :
+// 20/12/04 : Suppr DestroyMap et suppr handler kbd dans version LM (d2)
+// 26/11/04 : Bug trouve et resolu dans la fonction DestroyMap
+// 21/11/04 : Creation du module V1.0
+
+//*****************************************************************************
+// Definition des equivalences :
+//*****************************************************************************
+#define MAP_X 76
+#define MAP_Y 12
+#define MAP_SIZE MAP_X * MAP_Y
+
+#define MOUSE 0x01
+#define CHEESE 0x02
+#define OBSTACLE 0x04
+#define INPUT 0x08
+#define OUTPUT 0x10
+
+#define OBSTACLE_COUNT 100
+#define CHEESE_COUNT 650
+
+#define MOUSE_FULL 0x01
+#define MOUSE_EMPTY 0x02
+#define CHEESE_FOUND 0x04
+#define MOUSE_EXITED 0x08
+
+#define MOUSE_SPEED_MAX 1000
+#define MOUSE_SPEED_MIN 4
+
+typedef unsigned int Color_t;
+
+struct Point{
+ int X;
+ int Y;
+ };
+
+typedef struct Point Point_t;
+
+#define Set(Reg, Flag) Reg = (Reg | Flag)
+#define Reset(Reg, Flag) Reg = (Reg &(~Flag))
+#define IsSet(Reg, Flag) (Reg & Flag)
+
+
+//*****************************************************************************
+// Structure de gestion d'un element
+//*****************************************************************************
+struct Element{
+ sos_ui32_t Type;//Type d'element
+ sos_ui32_t Status;
+ Color_t Color;//Couleur de l'element
+ Point_t P;//Coordonnees de l'element
+ struct sos_thread * ThreadID;//Thread associe a la souris
+ int Way;//Direction de la souris
+ };
+
+typedef struct Element Element_t;
+
+//*****************************************************************************
+// Prototypes des fonctions/procedures :
+//*****************************************************************************
+static void MouseCommander(void);
+static void DrawMap(void);
+static sos_ret_t CreateMap(void);
+static sos_ret_t InitMapInput(Element_t * * pMap);
+static sos_ret_t InitMapOutput(Element_t * * pMap);
+static sos_ret_t ElementInit(Element_t * * pMap, unsigned int Type);
+static void Mouse(unsigned long Param);
+static void MouseMove(Point_t * P);
+static Point_t ChoosePosition(Element_t * pMouse, int Positions[], int Count);
+static int EvaluatePositions(Point_t Org, int Positions[], Point_t * Cheese);
+static sos_bool_t IsCollision(Point_t Org, Point_t p, Point_t *Cheese);
+static sos_bool_t AffectMovement(Point_t Org, Point_t p);
+static void MouseCreator(void);
+static sos_ret_t CreateMouse(void);
+
+//*****************************************************************************
+// Variables globales de ce module :
+//*****************************************************************************
+
+static Element_t * * pMap;
+static struct sos_ksema SemMap;
+static struct sos_ksema SemMouse;
+static int MouseCount = 0;
+static int CheeseCount = 0;
+static int ObstacleCount = 0;
+static int MouseSpeed = 100;
+
+//*****************************************************************************
+// Koalys Glue
+//*****************************************************************************
+void DrawPixel(int x, int y, Color_t color)
+{
+ sos_x86_videomem_putchar(y+3, x+2, color, 219);
+}
+
+
+
+//*****************************************************************************
+// Point d'entre de la 'simulation'
+//*****************************************************************************
+void MouseSim(void)
+{
+ //Creation du semaphore de protection de la carte
+ SOS_ASSERT_FATAL(SOS_OK == sos_ksema_init(& SemMap, "SemMap", 1,
+ SOS_KWQ_ORDER_FIFO));
+
+ //Creation du semaphore de creation de souris
+ SOS_ASSERT_FATAL(SOS_OK == sos_ksema_init(& SemMouse, "SemMouse", 2,
+ SOS_KWQ_ORDER_FIFO));
+
+ //Creation de la carte
+ SOS_ASSERT_FATAL(SOS_OK == CreateMap());
+
+ //Creation du thread createur de souris
+ SOS_ASSERT_FATAL(sos_create_kernel_thread("MouseCreator",
+ (sos_kernel_thread_start_routine_t)MouseCreator,
+ 0, SOS_SCHED_PRIO_TS_LOWEST-1) != NULL);
+
+}
+
+
+//*****************************************************************************
+// But de la fonction : Creer et initialiser la carte
+// Entree : Aucune
+// Parametre retourne : ERROR si la memoire est insuffisante, TRUE sinon
+//*****************************************************************************
+static sos_ret_t CreateMap(void)
+{
+ pMap = (Element_t * *)sos_kmalloc(MAP_SIZE * sizeof(Element_t *), 0);
+ if(pMap == NULL) return -SOS_ENOMEM;
+
+ //Mettre la carte a 0
+ memset(pMap, 0, MAP_SIZE * sizeof(Element_t *));
+
+ //Initialisation de l'entree de la carte
+ if(SOS_OK != InitMapInput(pMap))
+ {//Memoire insuffisante
+ return -SOS_EFATAL;
+ }
+
+ //Initialisation de la sortie de la carte
+ if(InitMapOutput(pMap) != SOS_OK)
+ {//Memoire insuffisante
+ return -SOS_EFATAL;
+ }
+
+ //Initialisation du fromage
+ if(ElementInit(pMap, CHEESE) != SOS_OK)
+ {//Memoire insuffisante
+ return -SOS_EFATAL;
+ }
+
+ //Initialisation des obstacles
+ if(ElementInit(pMap, OBSTACLE) != SOS_OK)
+ {//Memoire insuffisante
+ return -SOS_EFATAL;
+ }
+
+ DrawMap();//Afficher la carte creee
+
+ return SOS_OK;
+}
+
+//*****************************************************************************
+// But de la procedure : Dessiner la carte a l'ecran
+// Entree : Aucune
+// Sortie : Aucune
+//*****************************************************************************
+static void DrawMap(void)
+{
+ unsigned int I;
+
+ for(I = 0; I < MAP_SIZE; I++)
+ {
+ if(pMap[I] != NULL)
+ {
+ DrawPixel(I % MAP_X, I/MAP_X, pMap[I]->Color);
+ }
+ else DrawPixel(I % MAP_X, I/MAP_X, SOS_X86_VIDEO_FG_BLACK);
+ }
+ sos_x86_videomem_printf(23, 0, SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
+ "Souris = %d; Fromages = %d; Obstacles = %d ",
+ MouseCount, CheeseCount, ObstacleCount);
+}
+
+//*****************************************************************************
+// But de la fonction : Initialiser l'entree de la carte
+// Entree :
+// pMap : Pointeur sur la carte
+// Parametre retourne : ERROR si memoire insuffisante, TRUE sinon
+//*****************************************************************************
+static sos_ret_t InitMapInput(Element_t * * pMap)
+{
+ Element_t * pElement;
+
+ //Definir le point d'entree
+ pElement = (Element_t *)sos_kmalloc(sizeof(Element_t), 0);
+ if(pElement == NULL) return -SOS_ENOMEM;
+
+ //Initialiser l'entree
+ pElement->Type = INPUT;
+ pElement->Status = 0;
+ pElement->Color = SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE;
+ pElement->P.X = 0;
+ pElement->P.Y = MAP_Y / 2;
+ pElement->ThreadID = 0;
+
+ pMap[(pElement->P.Y * MAP_X) + pElement->P.X] = pElement;
+
+ return SOS_OK;
+}
+
+//*****************************************************************************
+// But de la fonction : Initialiser la sortie de la carte
+// Entree :
+// pMap : Pointeur sur la carte
+// Parametre retourne : ERROR si memoire insuffisante, TRUE sinon
+//*****************************************************************************
+static sos_ret_t InitMapOutput(Element_t * * pMap)
+{
+ Element_t * pElement;
+
+ //Definir le point de sortie
+ pElement = (Element_t *)sos_kmalloc(sizeof(Element_t), 0);
+ if(pElement == NULL) return -SOS_ENOMEM;
+
+ //Initialiser l'entree
+ pElement->Type = OUTPUT;
+ pElement->Status = 0;
+ pElement->Color = SOS_X86_VIDEO_FG_LTBLUE;
+ pElement->P.X = MAP_X - 1;
+ pElement->P.Y = MAP_Y / 2;
+ pElement->ThreadID = 0;
+
+ pMap[(pElement->P.Y * MAP_X) + pElement->P.X] = pElement;
+
+ return SOS_OK;
+}
+
+//*****************************************************************************
+// But de la fonction : Initialiser un type d'objet sur la carte
+// Entree :
+// pMap : Pointeur sur la carte
+// Type : Type d'objet a initialiser
+// Parametre retourne : ERROR si memoire insuffisante, TRUE sinon
+//*****************************************************************************
+static sos_ret_t ElementInit(Element_t * * pMap, unsigned int Type)
+{
+ unsigned int I, J;
+ unsigned int Max;
+ Color_t Color;
+
+ if(Type == CHEESE)
+ {//Type d'element = fromage
+ Max = CHEESE_COUNT;
+ Color = SOS_X86_VIDEO_FG_YELLOW;
+ }
+ else if(Type == OBSTACLE)
+ {//Type d'element = Obstacle
+ Max = OBSTACLE_COUNT;
+ Color = SOS_X86_VIDEO_FG_GREEN;
+ }
+ else
+ {//Aucune autre type reconnu
+ return -SOS_EINVAL;
+ }
+
+ for(I = 0; I < Max; I++)
+ {//Tirer les fromages
+ J = random();
+ J += random();
+ J %= MAP_SIZE;
+ if(pMap[J] == NULL)
+ {//Si l'emplacement est libre
+ pMap[J] = (Element_t *)sos_kmalloc(sizeof(Element_t),
+ 0);
+ if(pMap[J] == NULL) return -SOS_ENOMEM;
+
+ pMap[J]->Type = Type;
+ //Initialiser l'element
+ if(Type == CHEESE)
+ {//Type d'element = fromage
+ CheeseCount++;
+ }
+ else if(Type == OBSTACLE)
+ {//Type d'element = Obstacle
+ ObstacleCount++;
+ }
+
+ pMap[J]->Color = Color;
+ pMap[J]->Status = 0;
+ pMap[J]->Color = Color;
+ pMap[J]->P.X = J % MAP_X;
+ pMap[J]->P.Y = J / MAP_X;
+ pMap[J]->ThreadID = 0;
+ }
+ }
+
+ return SOS_OK;
+}
+
+
+//*****************************************************************************
+// But du thread : Deplacer la souris sur la carte selon les regles etablies.
+// Regles :
+// - La souris doit se placer devant l'entree puis commence a recolter du
+// fromage.
+// - Des que la souris a ramasse un morceau de fromage, elle doit aller en
+// entree de la carte afin de deposer sa recolte.
+// - Si une souris a prouve sa recolte, une autre souris est creee.
+// - Si une souris prend la sortie, elle est eliminee.
+//*****************************************************************************
+static void Mouse(unsigned long Param)
+{
+ Element_t * pMouse = (Element_t *)Param;
+ Point_t P;
+
+ SOS_ASSERT_FATAL(pMouse != NULL);
+
+ //Position de depart de la souris
+ P = pMouse->P;
+ P = pMouse->P;
+
+ while(1)
+ {
+ int delay_ms;
+ struct sos_time delay;
+
+ //La souris doit se deplacer
+ sos_ksema_down(& SemMap, NULL);
+
+ MouseMove(&P);
+
+ sos_ksema_up(& SemMap);
+
+ // Est-ce que la souris est sortie ?
+ if (IsSet(pMouse->Status, MOUSE_EXITED))
+ // Oui => on sort
+ break;
+
+ // Delai entre MOUSE_SPEED_MIN et MouseSpeed - 1
+ delay_ms = MOUSE_SPEED_MIN + (random() % MouseSpeed);
+ delay.sec = delay_ms / 1000;
+ delay.nanosec = (delay_ms % 1000) * 1000000;
+ sos_thread_sleep(& delay);
+ }
+
+ // Libere la structure associee
+ sos_kfree((sos_vaddr_t)pMouse);
+}
+
+//*****************************************************************************
+// But de la procedure : Deplacer la souris de maniere aleatoire sur la carte
+// Entrees :
+// P : Position courante de la souris
+// Sorties :
+// P : Position suivante de la souris
+//*****************************************************************************
+static void MouseMove(Point_t * P)
+{
+ Point_t Org;
+ Point_t p;
+ Point_t Cheese;
+ int Positions[8];
+ int Count = 0;
+ Element_t * pMouse;
+
+ Org = *P;
+
+ pMouse = pMap[Org.X + (Org.Y * MAP_X)];
+
+ Count = EvaluatePositions(Org, Positions, &Cheese);
+
+ if(Count == 0) return;
+
+ p = Org;
+
+ if(IsSet(pMouse->Status, CHEESE_FOUND))
+ {//Prendre le fromage
+ Reset(pMouse->Status, CHEESE_FOUND);
+ p = Cheese;
+ }
+ else
+ {//Choisir une position au hasard
+ p = ChoosePosition(pMouse, Positions, Count);
+ }
+ if(AffectMovement(Org, p) == FALSE) return;
+ //Deplacer la souris
+ pMap[Org.X + (Org.Y * MAP_X)] = NULL;
+ pMap[p.X + (p.Y * MAP_X)] = pMouse;
+ pMouse->P = p;
+ //Mettre a jour l'affichage
+ DrawPixel(Org.X, Org.Y, SOS_X86_VIDEO_FG_BLACK);
+ DrawPixel(p.X, p.Y, pMouse->Color);
+ sos_x86_videomem_printf( 23,0, SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE, "Souris = %d; Fromages = %d; Obstacles = %d ", MouseCount, CheeseCount, ObstacleCount);
+ //Mettre a jour les coordonnees
+ *P = p;
+}
+
+//*****************************************************************************
+// But de la fonction : Choisir un mouvement
+// Entree :
+// pMouse : Pointeur sur la souris
+// Positions : Tableau de position possible
+// Count :Nombre de positions valides
+// Sortie : Aucune
+// Parametre retourne : Position choisie
+//*****************************************************************************
+static Point_t ChoosePosition(Element_t * pMouse, int Positions[], int Count)
+{
+ int I, J;
+ Point_t p;
+
+ for(J = 0; J < Count; J++)
+ {//Chercher dans le tableau si cette position est disponible
+ I = Positions[J];
+ if(I == pMouse->Way)
+ {//Poursuivre ce sens d'avance
+ p = pMouse->P;
+ switch(I)
+ {
+ case 0:
+ p.Y++;
+ break;
+ case 1:
+ p.X++;
+ p.Y++;
+ break;
+ case 2:
+ p.X++;
+ break;
+ case 3:
+ p.Y--;
+ p.X++;
+ break;
+ case 4:
+ p.Y--;
+ break;
+ case 5:
+ p.Y--;
+ p.X--;
+ break;
+ case 6:
+ p.X--;
+ break;
+ case 7:
+ p.X--;
+ p.Y++;
+ break;
+ }
+ return p;
+ }
+ }
+
+ J = random() % Count;
+ I = Positions[J];
+ if(((I + 4) % 8) == pMouse->Way)
+ {//Eviter le sens inverse
+ J = (J + 1) % Count;
+ I = Positions[J];
+ }
+
+ p = pMouse->P;
+ switch(I)
+ {//Repere le deplacement
+ case 0:
+ p.Y++;
+ break;
+ case 1:
+ p.X++;
+ p.Y++;
+ break;
+ case 2:
+ p.X++;
+ break;
+ case 3:
+ p.Y--;
+ p.X++;
+ break;
+ case 4:
+ p.Y--;
+ break;
+ case 5:
+ p.Y--;
+ p.X--;
+ break;
+ case 6:
+ p.X--;
+ break;
+ case 7:
+ p.X--;
+ p.Y++;
+ break;
+ }
+
+ pMouse->Way = I;//Memoriser la direction selectionnee
+
+ return p;
+}
+
+//*****************************************************************************
+// But de la fonction : Evaluer les positions possibles et les memoriser dans
+// un tableau de positions si aucun fromage n'a ete detecte. Si du fromage a
+// ete detecte, il sera selectionne en premier. La presence d'un fromage est
+// indiquee par le drapeau CHEESE_FOUND
+// Entree :
+// Org : Position de la souris
+// Sorties :
+// Positions : Tableau de positions valides
+// Cheese : Position du fromage
+// Parametre retourne : Nombre de positions valides
+//*****************************************************************************
+static int EvaluatePositions(Point_t Org, int Positions[], Point_t * Cheese)
+{
+ int I;
+ int Count = 0;
+ Point_t p;
+ Point_t CheesePos;
+
+ for(I = 0; I < 8; I++)
+ {//Explorer toute les directions
+ p = Org;
+ switch(I)
+ {//Repere le deplacement
+ case 0:
+ p.Y++;
+ break;
+ case 1:
+ p.X++;
+ p.Y++;
+ break;
+ case 2:
+ p.X++;
+ break;
+ case 3:
+ p.Y--;
+ p.X++;
+ break;
+ case 4:
+ p.Y--;
+ break;
+ case 5:
+ p.Y--;
+ p.X--;
+ break;
+ case 6:
+ p.X--;
+ break;
+ case 7:
+ p.X--;
+ p.Y++;
+ break;
+ }
+ //Tester la collision
+ if(IsCollision(Org, p, &CheesePos) == FALSE)
+ {//La souris n'a rencontre aucun obstacle
+ Positions[Count] = I;
+ Count++;
+ }
+ }
+
+ *Cheese = CheesePos;
+
+ return Count;
+}
+
+//*****************************************************************************
+// But de la fonction : Affecter un mouvement a la souris
+// Entrees :
+// Org : Coordonnees de la souris
+// p : Coordonnees voulu par la souris
+// Parametre retourne : TRUE si le mouvement a eu lieu, FALSE sinon
+//*****************************************************************************
+static sos_bool_t AffectMovement(Point_t Org, Point_t p)
+{
+ Element_t * pMouse = pMap[Org.X + (Org.Y * MAP_X)];
+ Element_t * pElement;
+
+ pElement = pMap[p.X + (p.Y * MAP_X)];
+
+ //La place est libre
+ if(pElement == NULL) return TRUE;//Autoriser le mouvement
+
+ switch(pElement->Type)
+ {
+ case CHEESE:
+ // Liberer l'emplacement memoire du fromage
+ sos_kfree((sos_vaddr_t)pElement);
+ pMap[p.X + (p.Y * MAP_X)] = NULL;
+
+ //Donner le fromage a la souris
+ Set(pMouse->Status, MOUSE_FULL);
+ Reset(pMouse->Status, MOUSE_EMPTY);
+ pMouse->Color = SOS_X86_VIDEO_FG_MAGENTA;
+ CheeseCount--;
+ return TRUE;
+ case OUTPUT:
+ //Supprimer la souris
+ pMap[Org.X + (Org.Y * MAP_X)] = NULL;
+ MouseCount--;
+ DrawPixel(Org.X, Org.Y, SOS_X86_VIDEO_FG_BLACK);
+ sos_x86_videomem_printf( 23,0, SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE,
+ "Souris = %d; Fromages = %d; Obstacles = %d ",
+ MouseCount, CheeseCount,
+ ObstacleCount);
+ Set(pMouse->Status, MOUSE_EXITED);
+ return FALSE;
+ default :
+ return FALSE;
+ }
+
+ return FALSE;
+}
+
+//*****************************************************************************
+// But de la fonction : Tester si une collision a eu lieu avec un obstacle
+// Entrees :
+// Org : Coordonnees de la souris
+// p : coordonnees desirees par la souris
+// Sortie :
+// Cheese : Coordonnees du fromage
+// Parametre retourne : TRUE si une collision a eu lieu, FALSE sinon
+//*****************************************************************************
+static sos_bool_t IsCollision(Point_t Org, Point_t p, Point_t *Cheese)
+{
+ Element_t * pMouse = pMap[Org.X + (Org.Y * MAP_X)];
+ Element_t * pElement;
+
+ //Tester les bordures de la map
+ if((p.X < 0)||(p.Y < 0)) return TRUE;
+
+ if((p.Y >= MAP_Y)||(p.X >= MAP_X)) return TRUE;
+
+ pElement = pMap[p.X + (p.Y * MAP_X)];
+
+ //L'element est vide
+ if(pElement == NULL) return FALSE;
+
+ //Si du fromage a ete trouve, stopper la recherche
+ if(IsSet(pMouse->Status, CHEESE_FOUND)) return FALSE;
+
+ switch(pElement->Type)
+ {
+ case CHEESE:
+ if(IsSet(pMouse->Status, MOUSE_FULL)) return TRUE;
+ //Indiquer que du fromage a ete trouve
+ Set(pMouse->Status, CHEESE_FOUND);
+ //Retenir la position du fromage
+ (*Cheese).X = p.X;
+ (*Cheese).Y = p.Y;
+ break;
+ case INPUT:
+ if(IsSet(pMouse->Status, MOUSE_EMPTY)) return TRUE;
+ //Remplir les reserves de fromage
+ Set(pMouse->Status, MOUSE_EMPTY);
+ Reset(pMouse->Status, MOUSE_FULL);
+ pMouse->Color = SOS_X86_VIDEO_FG_LTRED;
+ //Autoriser la creation d'une autre souris
+ sos_ksema_up(& SemMouse);
+ return TRUE;
+ case OUTPUT:
+ break;
+ default :
+ return TRUE;
+ }
+
+ return FALSE;//Aucune collision
+}
+
+//*****************************************************************************
+// But du thread : Creer une souris et la placer autour de l'entree
+//*****************************************************************************
+static void MouseCreator(void)
+{
+ while(1)
+ {
+ sos_ksema_down(& SemMouse, NULL);
+ sos_ksema_down(& SemMap, NULL);
+ CreateMouse();
+ sos_ksema_up(& SemMap);
+ }
+}
+
+//*****************************************************************************
+// But de la fonction : Creer une souris et l'inserer dans la carte
+// Entree : Aucune
+// Parametre retourne : ERROR si memoire insuffisante, FALSE si souris non
+// cree, TRUE sinon
+//*****************************************************************************
+static sos_ret_t CreateMouse(void)
+{
+ Element_t * pElement;
+ unsigned int I;
+
+ Point_t p;
+
+ for(I = 0; I < 8; I++)
+ {//Explorer tous les emplacements
+ p.X = 0;
+ p.Y = MAP_Y / 2;
+ switch(I)
+ {//Repere le deplacement
+ case 0:
+ p.Y++;
+ break;
+ case 1:
+ p.X++;
+ p.Y++;
+ break;
+ case 2:
+ p.X++;
+ break;
+ case 3:
+ p.Y--;
+ p.X++;
+ break;
+ case 4:
+ p.Y--;
+ break;
+ case 5:
+ p.Y--;
+ p.X--;
+ break;
+ case 6:
+ p.X--;
+ break;
+ case 7:
+ p.X--;
+ p.Y++;
+ break;
+ }
+ if((p.X >= 0)&&(p.Y >= 0)&&(p.X < MAP_X)&&(p.Y < MAP_Y))
+ {//L'emplacement est valide
+ pElement = pMap[p.X + (p.Y * MAP_X)];
+ if(pElement == NULL)
+ {//Creer la souris
+ pElement = (Element_t *)sos_kmalloc(sizeof(Element_t), 0);
+ if(pElement != NULL)
+ {//Initialiser l'entree
+ pElement->Type = MOUSE;
+ Set(pElement->Status, MOUSE_EMPTY);
+ pElement->Color = SOS_X86_VIDEO_FG_LTRED;
+ pElement->P = p;
+ pElement->Way = 0;
+ pElement->ThreadID
+ = sos_create_kernel_thread("Mouse",
+ (sos_kernel_thread_start_routine_t)Mouse,
+ pElement, SOS_SCHED_PRIO_TS_LOWEST-1);
+ if(pElement->ThreadID == 0)
+ {
+ sos_kfree((sos_vaddr_t)pElement);
+ pElement = NULL;
+ return -SOS_ENOMEM;
+ }
+ pMap[p.X + (p.Y * MAP_X)] = pElement;
+ MouseCount++;
+
+ DrawPixel(p.X, p.Y, pElement->Color);
+ sos_x86_videomem_printf(23, 0, SOS_X86_VIDEO_FG_YELLOW | SOS_X86_VIDEO_BG_BLUE, "Souris = %d; Fromages = %d; Obstacles = %d ", MouseCount, CheeseCount, ObstacleCount);
+
+ return SOS_OK;
+ }
+ }
+ }
+ }
+ return -SOS_EBUSY;
+}
+
+//*****************************************************************************
+// C'est fini !!!!
+//*****************************************************************************
diff --git a/sos-code-article6.75/sos/physmem.c b/sos-code-article6.75/sos/physmem.c
new file mode 100644
index 0000000..daf730f
--- /dev/null
+++ b/sos-code-article6.75/sos/physmem.c
@@ -0,0 +1,319 @@
+/* Copyright (C) 2004 David Decotigny
+ Copyright (C) 2000 The KOS Team
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#include <sos/list.h>
+#include <sos/macros.h>
+#include <sos/assert.h>
+#include <sos/klibc.h>
+
+#include "physmem.h"
+
+/** A descriptor for a physical page in SOS */
+struct physical_page_descr
+{
+ /** The physical base address for the page */
+ sos_paddr_t paddr;
+
+ /** The reference count for this physical page. > 0 means that the
+ page is in the used list. */
+ sos_count_t ref_cnt;
+
+ /** Some data associated with the page when it is mapped in kernel space */
+ struct sos_kmem_range *kernel_range;
+
+ /** The other pages on the list (used, free) */
+ struct physical_page_descr *prev, *next;
+};
+
+/** These are some markers present in the executable file (see sos.lds) */
+extern char __b_kernel, __e_kernel;
+
+/** The array of ppage descriptors will be located at this address */
+#define PAGE_DESCR_ARRAY_ADDR \
+ SOS_PAGE_ALIGN_SUP((sos_paddr_t) (& __e_kernel))
+static struct physical_page_descr * physical_page_descr_array;
+
+/** The list of physical pages currently available */
+static struct physical_page_descr *free_ppage;
+
+/** The list of physical pages currently in use */
+static struct physical_page_descr *used_ppage;
+
+/** We will store here the interval of valid physical addresses */
+static sos_paddr_t physmem_base, physmem_top;
+
+/** We store the number of pages used/free */
+static sos_count_t physmem_total_pages, physmem_used_pages;
+
+sos_ret_t sos_physmem_subsystem_setup(sos_size_t ram_size,
+ /* out */sos_paddr_t *kernel_core_base,
+ /* out */sos_paddr_t *kernel_core_top)
+{
+ /* The iterator over the page descriptors */
+ struct physical_page_descr *ppage_descr;
+
+ /* The iterator over the physical addresses */
+ sos_paddr_t ppage_addr;
+
+ /* Make sure ram size is aligned on a page boundary */
+ ram_size = SOS_PAGE_ALIGN_INF(ram_size);/* Yes, we may lose at most a page */
+
+ /* Reset the used/free page lists before building them */
+ free_ppage = used_ppage = NULL;
+ physmem_total_pages = physmem_used_pages = 0;
+
+ /* Make sure that there is enough memory to store the array of page
+ descriptors */
+ *kernel_core_base = SOS_PAGE_ALIGN_INF((sos_paddr_t)(& __b_kernel));
+ *kernel_core_top
+ = PAGE_DESCR_ARRAY_ADDR
+ + SOS_PAGE_ALIGN_SUP( (ram_size >> SOS_PAGE_SHIFT)
+ * sizeof(struct physical_page_descr));
+ if (*kernel_core_top > ram_size)
+ return -SOS_ENOMEM;
+
+ /* Page 0-4kB is not available in order to return address 0 as a
+ means to signal "no page available" */
+ physmem_base = SOS_PAGE_SIZE;
+ physmem_top = ram_size;
+
+ /* Setup the page descriptor arrray */
+ physical_page_descr_array
+ = (struct physical_page_descr*)PAGE_DESCR_ARRAY_ADDR;
+
+ /* Scan the list of physical pages */
+ for (ppage_addr = 0,
+ ppage_descr = physical_page_descr_array ;
+ ppage_addr < physmem_top ;
+ ppage_addr += SOS_PAGE_SIZE,
+ ppage_descr ++)
+ {
+ enum { PPAGE_MARK_RESERVED, PPAGE_MARK_FREE,
+ PPAGE_MARK_KERNEL, PPAGE_MARK_HWMAP } todo;
+
+ memset(ppage_descr, 0x0, sizeof(struct physical_page_descr));
+
+ /* Init the page descriptor for this page */
+ ppage_descr->paddr = ppage_addr;
+
+ /* Reserved : 0 ... base */
+ if (ppage_addr < physmem_base)
+ todo = PPAGE_MARK_RESERVED;
+
+ /* Free : base ... BIOS */
+ else if ((ppage_addr >= physmem_base)
+ && (ppage_addr < BIOS_N_VIDEO_START))
+ todo = PPAGE_MARK_FREE;
+
+ /* Used : BIOS */
+ else if ((ppage_addr >= BIOS_N_VIDEO_START)
+ && (ppage_addr < BIOS_N_VIDEO_END))
+ todo = PPAGE_MARK_HWMAP;
+
+ /* Free : BIOS ... kernel */
+ else if ((ppage_addr >= BIOS_N_VIDEO_END)
+ && (ppage_addr < (sos_paddr_t) (& __b_kernel)))
+ todo = PPAGE_MARK_FREE;
+
+ /* Used : Kernel code/data/bss + physcal page descr array */
+ else if ((ppage_addr >= *kernel_core_base)
+ && (ppage_addr < *kernel_core_top))
+ todo = PPAGE_MARK_KERNEL;
+
+ /* Free : first page of descr ... end of RAM */
+ else
+ todo = PPAGE_MARK_FREE;
+
+ /* Actually does the insertion in the used/free page lists */
+ physmem_total_pages ++;
+ switch (todo)
+ {
+ case PPAGE_MARK_FREE:
+ ppage_descr->ref_cnt = 0;
+ list_add_head(free_ppage, ppage_descr);
+ break;
+
+ case PPAGE_MARK_KERNEL:
+ case PPAGE_MARK_HWMAP:
+ ppage_descr->ref_cnt = 1;
+ list_add_head(used_ppage, ppage_descr);
+ physmem_used_pages ++;
+ break;
+
+ default:
+ /* Reserved page: nop */
+ break;
+ }
+ }
+
+ return SOS_OK;
+}
+
+
+sos_paddr_t sos_physmem_ref_physpage_new(sos_bool_t can_block)
+{
+ struct physical_page_descr *ppage_descr;
+
+ if (! free_ppage)
+ return (sos_paddr_t)NULL;
+
+ /* Retrieve a page in the free list */
+ ppage_descr = list_pop_head(free_ppage);
+
+ /* The page is assumed not to be already used */
+ SOS_ASSERT_FATAL(ppage_descr->ref_cnt == 0);
+
+ /* Mark the page as used (this of course sets the ref count to 1) */
+ ppage_descr->ref_cnt ++;
+
+ /* No associated kernel range by default */
+ ppage_descr->kernel_range = NULL;
+
+ /* Put the page in the used list */
+ list_add_tail(used_ppage, ppage_descr);
+ physmem_used_pages ++;
+
+ return ppage_descr->paddr;
+}
+
+
+/**
+ * Helper function to get the physical page descriptor for the given
+ * physical page address.
+ *
+ * @return NULL when out-of-bounds or non-page-aligned
+ */
+inline static struct physical_page_descr *
+get_page_descr_at_paddr(sos_paddr_t ppage_paddr)
+{
+ /* Don't handle non-page-aligned addresses */
+ if (ppage_paddr & SOS_PAGE_MASK)
+ return NULL;
+
+ /* Don't support out-of-bounds requests */
+ if ((ppage_paddr < physmem_base) || (ppage_paddr >= physmem_top))
+ return NULL;
+
+ return physical_page_descr_array + (ppage_paddr >> SOS_PAGE_SHIFT);
+}
+
+
+sos_ret_t sos_physmem_ref_physpage_at(sos_paddr_t ppage_paddr)
+{
+ struct physical_page_descr *ppage_descr
+ = get_page_descr_at_paddr(ppage_paddr);
+
+ if (! ppage_descr)
+ return -SOS_EINVAL;
+
+ /* Increment the reference count for the page */
+ ppage_descr->ref_cnt ++;
+
+ /* If the page is newly referenced (ie we are the only owners of the
+ page => ref cnt == 1), transfer it in the used pages list */
+ if (ppage_descr->ref_cnt == 1)
+ {
+ list_delete(free_ppage, ppage_descr);
+
+ /* No associated kernel range by default */
+ ppage_descr->kernel_range = NULL;
+
+ list_add_tail(used_ppage, ppage_descr);
+ physmem_used_pages ++;
+
+ /* The page is newly referenced */
+ return FALSE;
+ }
+
+ /* The page was already referenced by someone */
+ return TRUE;
+}
+
+
+sos_ret_t
+sos_physmem_unref_physpage(sos_paddr_t ppage_paddr)
+{
+ /* By default the return value indicates that the page is still
+ used */
+ sos_ret_t retval = FALSE;
+
+ struct physical_page_descr *ppage_descr
+ = get_page_descr_at_paddr(ppage_paddr);
+
+ if (! ppage_descr)
+ return -SOS_EINVAL;
+
+ /* Don't do anything if the page is not in the used list */
+ if (ppage_descr->ref_cnt <= 0)
+ return -SOS_EINVAL;
+
+ /* Unreference the page, and, when no mapping is active anymore, put
+ the page in the free list */
+ ppage_descr->ref_cnt--;
+ if (ppage_descr->ref_cnt <= 0)
+ {
+ /* Reset associated kernel range */
+ ppage_descr->kernel_range = NULL;
+
+ /* Transfer the page, considered USED, to the free list */
+ list_delete(used_ppage, ppage_descr);
+ physmem_used_pages --;
+ list_add_head(free_ppage, ppage_descr);
+
+ /* Indicate that the page is now unreferenced */
+ retval = TRUE;
+ }
+
+ return retval;
+}
+
+
+struct sos_kmem_range* sos_physmem_get_kmem_range(sos_paddr_t ppage_paddr)
+{
+ struct physical_page_descr *ppage_descr
+ = get_page_descr_at_paddr(ppage_paddr);
+
+ if (! ppage_descr)
+ return NULL;
+
+ return ppage_descr->kernel_range;
+}
+
+
+sos_ret_t sos_physmem_set_kmem_range(sos_paddr_t ppage_paddr,
+ struct sos_kmem_range *range)
+{
+ struct physical_page_descr *ppage_descr
+ = get_page_descr_at_paddr(ppage_paddr);
+
+ if (! ppage_descr)
+ return -SOS_EINVAL;
+
+ ppage_descr->kernel_range = range;
+ return SOS_OK;
+}
+
+sos_ret_t sos_physmem_get_state(/* out */sos_count_t *total_ppages,
+ /* out */sos_count_t *used_ppages)
+{
+ if (total_ppages)
+ *total_ppages = physmem_total_pages;
+ if (used_ppages)
+ *used_ppages = physmem_used_pages;
+ return SOS_OK;
+}
diff --git a/sos-code-article6.75/sos/physmem.h b/sos-code-article6.75/sos/physmem.h
new file mode 100644
index 0000000..7b4cd2b
--- /dev/null
+++ b/sos-code-article6.75/sos/physmem.h
@@ -0,0 +1,147 @@
+/* Copyright (C) 2004 David Decotigny
+ Copyright (C) 2000 The KOS Team
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#ifndef _SOS_PHYSMEM_H_
+#define _SOS_PHYSMEM_H_
+
+/**
+ * @file physmem.h
+ *
+ * Physical pages of memory
+ */
+
+#include <sos/errno.h>
+#include <sos/types.h>
+#include <sos/macros.h>
+
+/** The size of a physical page (arch-dependent) */
+#define SOS_PAGE_SIZE (4*1024)
+
+/** The corresponding shift */
+#define SOS_PAGE_SHIFT 12 /* 4 kB = 2^12 B */
+
+/** The corresponding mask */
+#define SOS_PAGE_MASK ((1<<12) - 1)
+
+#define SOS_PAGE_ALIGN_INF(val) \
+ SOS_ALIGN_INF((val), SOS_PAGE_SIZE)
+#define SOS_PAGE_ALIGN_SUP(val) \
+ SOS_ALIGN_SUP((val), SOS_PAGE_SIZE)
+#define SOS_IS_PAGE_ALIGNED(val) \
+ SOS_IS_ALIGNED((val), SOS_PAGE_SIZE)
+
+/**
+ * This is the reserved physical interval for the x86 video memory and
+ * BIOS area. In physmem.c, we have to mark this area as "used" in
+ * order to prevent from allocating it. And in paging.c, we'd better
+ * map it in virtual space if we really want to be able to print to
+ * the screen (for debugging purpose, at least): for this, the
+ * simplest is to identity-map this area in virtual space (note
+ * however that this mapping could also be non-identical).
+ */
+#define BIOS_N_VIDEO_START 0xa0000
+#define BIOS_N_VIDEO_END 0x100000
+
+
+/**
+ * Initialize the physical memory subsystem, for the physical area [0,
+ * ram_size). This routine takes into account the BIOS and video
+ * areas, to prevent them from future allocations.
+ *
+ * @param ram_size The size of the RAM that will be managed by this subsystem
+ *
+ * @param kernel_core_base The lowest address for which the kernel
+ * assumes identity mapping (ie virtual address == physical address)
+ * will be stored here
+ *
+ * @param kernel_core_top The top address for which the kernel
+ * assumes identity mapping (ie virtual address == physical address)
+ * will be stored here
+ */
+sos_ret_t sos_physmem_subsystem_setup(sos_size_t ram_size,
+ /* out */sos_paddr_t *kernel_core_base,
+ /* out */sos_paddr_t *kernel_core_top);
+
+/**
+ * Retrieve the total number of pages, and the number of free pages
+ */
+sos_ret_t sos_physmem_get_state(/* out */sos_count_t *total_ppages,
+ /* out */sos_count_t *used_ppages);
+
+
+/**
+ * Get a free page.
+ *
+ * @return The (physical) address of the (physical) page allocated, or
+ * NULL when none currently available.
+ *
+ * @param can_block TRUE if the function is allowed to block
+ * @note The page returned has a reference count equal to 1.
+ */
+sos_paddr_t sos_physmem_ref_physpage_new(sos_bool_t can_block);
+
+
+/**
+ * Increment the reference count of a given physical page. Useful for
+ * VM code which tries to map a precise physical address.
+ *
+ * @param ppage_paddr Physical address of the page (MUST be page-aligned)
+ *
+ * @return TRUE when the page was previously in use, FALSE when the
+ * page was previously in the free list, <0 when the page address is
+ * invalid.
+ */
+sos_ret_t sos_physmem_ref_physpage_at(sos_paddr_t ppage_paddr);
+
+
+/**
+ * Decrement the reference count of the given physical page. When this
+ * reference count reaches 0, the page is marked free, ie is available
+ * for future sos_physmem_get_physpage()
+ *
+ * @param ppage_paddr Physical address of the page (MUST be page-aligned)
+ *
+ * @return FALSE when the page is still in use, TRUE when the page is now
+ * unreferenced, <0 when the page address is invalid
+ */
+sos_ret_t sos_physmem_unref_physpage(sos_paddr_t ppage_paddr);
+
+
+#include <sos/kmem_vmm.h>
+
+/**
+ * Return the kernel memory allocation range associated with the given
+ * physical page, or NULL when page has no associated range
+ *
+ * @param ppage_paddr Physical address of the page (MUST be page-aligned)
+ */
+struct sos_kmem_range* sos_physmem_get_kmem_range(sos_paddr_t ppage_paddr);
+
+
+/**
+ * Set the kernel memory allocation range associated to the given
+ * physical page.
+ *
+ * @param ppage_paddr Physical address of the page (MUST be page-aligned)
+ *
+ * @return error if page is invalid
+ */
+sos_ret_t sos_physmem_set_kmem_range(sos_paddr_t ppage_paddr,
+ struct sos_kmem_range *range);
+
+#endif /* _SOS_PHYSMEM_H_ */
diff --git a/sos-code-article6.75/sos/sched.c b/sos-code-article6.75/sos/sched.c
new file mode 100644
index 0000000..2788be0
--- /dev/null
+++ b/sos-code-article6.75/sos/sched.c
@@ -0,0 +1,208 @@
+/* Copyright (C) 2004 David Decotigny
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+
+#include <sos/errno.h>
+#include <sos/klibc.h>
+#include <sos/assert.h>
+#include <sos/list.h>
+
+#include "sched.h"
+
+
+/**
+ * The definition of the scheduler queue. We could have used a normal
+ * kwaitq here, it would have had the same properties (regarding
+ * priority ordering mainly). But we don't bother with size
+ * considerations here (in kwaitq, we had better make the kwaitq
+ * structure as small as possible because there are a lot of kwaitq in
+ * the system: at least 1 per opened file), so that we can implement a
+ * much faster way of handling the prioritized jobs.
+ */
+struct sos_sched_queue
+{
+ unsigned int nr_threads;
+ struct sos_thread *thread_list[SOS_SCHED_NUM_PRIO];
+};
+
+
+/**
+ * We manage 2 queues: a queue being scanned for ready threads
+ * (active_queue) and a queue to store the threads the threads having
+ * expired their time quantuum.
+ */
+static struct sos_sched_queue *active_queue, *expired_queue;
+
+
+/**
+ * The instances for the active/expired queues
+ */
+static struct sos_sched_queue sched_queue[2];
+
+
+sos_ret_t sos_sched_subsystem_setup()
+{
+ memset(sched_queue, 0x0, sizeof(sched_queue));
+ active_queue = & sched_queue[0];
+ expired_queue = & sched_queue[1];
+
+ return SOS_OK;
+}
+
+
+/**
+ * Helper function to add a thread in a ready queue AND to change the
+ * state of the given thread to "READY".
+ *
+ * @param insert_at_tail TRUE to tell to add the thread at the end of
+ * the ready list. Otherwise it is added at the head of it.
+ */
+static sos_ret_t add_in_ready_queue(struct sos_sched_queue *q,
+ struct sos_thread *thr,
+ sos_bool_t insert_at_tail)
+{
+ sos_sched_priority_t prio;
+
+ SOS_ASSERT_FATAL( (SOS_THR_CREATED == thr->state)
+ || (SOS_THR_RUNNING == thr->state) /* Yield */
+ || (SOS_THR_BLOCKED == thr->state) );
+
+ /* Add the thread to the CPU queue */
+ prio = sos_thread_get_priority(thr);
+ if (insert_at_tail)
+ list_add_tail_named(q->thread_list[prio], thr,
+ ready.rdy_prev, ready.rdy_next);
+ else
+ list_add_head_named(q->thread_list[prio], thr,
+ ready.rdy_prev, ready.rdy_next);
+ thr->ready.rdy_queue = q;
+ q->nr_threads ++;
+
+ /* Ok, thread is now really ready to be (re)started */
+ thr->state = SOS_THR_READY;
+
+ return SOS_OK;
+}
+
+
+sos_ret_t sos_sched_set_ready(struct sos_thread *thr)
+{
+ sos_ret_t retval;
+
+ /* Don't do anything for already ready threads */
+ if (SOS_THR_READY == thr->state)
+ return SOS_OK;
+
+ if (SOS_SCHED_PRIO_IS_RT(sos_thread_get_priority(thr)))
+ {
+ /* Real-time thread: schedule it for the present turn */
+ retval = add_in_ready_queue(active_queue, thr, TRUE);
+ }
+ else
+ {
+ /* Non real-time thread: schedule it for next turn */
+ retval = add_in_ready_queue(expired_queue, thr, TRUE);
+ }
+
+ return retval;
+}
+
+
+sos_ret_t sos_sched_change_priority(struct sos_thread *thr,
+ sos_sched_priority_t priority)
+{
+ struct sos_thread *thread_list;
+ SOS_ASSERT_FATAL(SOS_THR_READY == thr->state);
+
+ /* Temp variable */
+ thread_list
+ = thr->ready.rdy_queue->thread_list[sos_thread_get_priority(thr)];
+
+ list_delete_named(thread_list, thr, ready.rdy_prev, ready.rdy_next);
+
+ /* Update lists */
+ thread_list = thr->ready.rdy_queue->thread_list[priority];
+ list_add_tail_named(thread_list, thr, ready.rdy_prev, ready.rdy_next);
+ thr->ready.rdy_queue->thread_list[priority] = thread_list;
+
+ return SOS_OK;
+}
+
+
+struct sos_thread * sos_reschedule(struct sos_thread *current_thread,
+ sos_bool_t do_yield)
+{
+ sos_sched_priority_t prio;
+
+ if (SOS_THR_ZOMBIE == current_thread->state)
+ {
+ /* Don't think of returning to this thread since it is
+ terminated */
+ /* Nop */
+ }
+ else if (SOS_THR_BLOCKED != current_thread->state)
+ {
+ /* Take into account the current executing thread unless it is
+ marked blocked */
+ if (do_yield)
+ {
+ /* Ok, reserve it for next turn */
+ if (SOS_SCHED_PRIO_IS_RT(sos_thread_get_priority(current_thread)))
+ add_in_ready_queue(active_queue, current_thread, TRUE);
+ else
+ add_in_ready_queue(expired_queue, current_thread, TRUE);
+ }
+ else
+ {
+ /* Put it at the head of the active list */
+ add_in_ready_queue(active_queue, current_thread, FALSE);
+ }
+ }
+
+
+ /* Active queue is empty ? */
+ if (active_queue->nr_threads <= 0)
+ {
+ /* Yes: Exchange it with the expired queue */
+ struct sos_sched_queue *q;
+ q = active_queue;
+ active_queue = expired_queue;
+ expired_queue = q;
+ }
+
+ /* Now loop over the priorities in the active queue, looking for a
+ non-empty queue */
+ for (prio = SOS_SCHED_PRIO_HIGHEST ; prio <= SOS_SCHED_PRIO_LOWEST ; prio ++)
+ {
+ struct sos_thread *next_thr;
+
+ if (list_is_empty_named(active_queue->thread_list[prio],
+ ready.rdy_prev, ready.rdy_next))
+ continue;
+
+ /* Queue is not empty: take the thread at its head */
+ next_thr = list_pop_head_named(active_queue->thread_list[prio],
+ ready.rdy_prev, ready.rdy_next);
+ active_queue->nr_threads --;
+
+ return next_thr;
+ }
+
+
+ SOS_FATAL_ERROR("No kernel thread ready ?!");
+ return NULL;
+}
diff --git a/sos-code-article6.75/sos/sched.h b/sos-code-article6.75/sos/sched.h
new file mode 100644
index 0000000..2dcdd56
--- /dev/null
+++ b/sos-code-article6.75/sos/sched.h
@@ -0,0 +1,141 @@
+/* Copyright (C) 2004 David Decotigny
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#ifndef _SOS_SCHED_H_
+#define _SOS_SCHED_H_
+
+
+/**
+ * @file sched.h
+ *
+ * A basic scheduler inspired from the O(1) Linux scheduler. Supports
+ * 2 classes of thread priorities:
+ * - so-called 'real-time' threads scheduled according to a simple
+ * traditional static priority real-time scheduler. "Real-time" round
+ * robin scheduling is not supported.
+ * - "fair" time-sharing scheduling for non real-time threads. "fair"
+ * because no starvation among the non real-time threads is
+ * possible. Contrary to the original O(1) Linux scheduler, the
+ * on-line adjustment of the scheduling priorities to cope with
+ * interactive/non interactive threads discrimination is not
+ * supported: threads keep having the same priority as long as the
+ * user does not change it.
+ *
+ * The functions below manage CPU queues, and are NEVER responsible
+ * for context switches (see thread.h for that) or synchronizations
+ * (see kwaitq.h or the higher levels primitives [mutex, semaphore,
+ * ...] for that).
+ *
+ * @note IMPORTANT: all the functions below are meant to be called
+ * ONLY by the thread/timer/kwaitq subsystems. DO NOT use them
+ * directly from anywhere else: use ONLY the thread/kwaitq functions!
+ * If you still want to call them directly despite this disclaimer,
+ * simply disable interrupts before clling them.
+ */
+
+#include <sos/errno.h>
+
+
+/**
+ * The definition of a priority
+ */
+typedef unsigned char sos_sched_priority_t;
+
+
+#include <sos/thread.h>
+
+
+/**
+ * Valid priority interval ("real-time" and non real-time threads altogether)
+ */
+#define SOS_SCHED_PRIO_HIGHEST 0
+#define SOS_SCHED_PRIO_LOWEST 63
+#define SOS_SCHED_NUM_PRIO 64
+
+
+/**
+ * Class-specific priorities
+ */
+#define SOS_SCHED_PRIO_RT_HIGHEST 0 /**< Highest 'real-time' static prio. */
+#define SOS_SCHED_PRIO_RT_LOWEST 15 /**< Lowest 'real-time' static priority */
+#define SOS_SCHED_PRIO_TS_HIGHEST 16 /**< Highest time-sharing priority */
+#define SOS_SCHED_PRIO_TS_LOWEST 63 /**< Lowest time-sharing priority */
+
+#define SOS_SCHED_PRIO_DEFAULT 40 /**< Default priority */
+
+
+/**
+ * Helper macros (Yes, priorities ordered in decreasing numerical value)
+ *
+ * @note: The use of this function is RESERVED
+ */
+#define SOS_SCHED_PRIO_CMP(prio1,prio2) ((prio1) - (prio2))
+
+#define SOS_SCHED_PRIO_IS_VALID(prio) \
+ ({ int __prio = (int)(prio); \
+ ((__prio) <= SOS_SCHED_PRIO_LOWEST) \
+ && \
+ ((__prio) >= SOS_SCHED_PRIO_HIGHEST); })
+
+#define SOS_SCHED_PRIO_IS_RT(prio) \
+ ({ int __prio = (int)(prio); \
+ ((__prio) <= SOS_SCHED_PRIO_RT_LOWEST) \
+ && \
+ ((__prio) >= SOS_SCHED_PRIO_RT_HIGHEST); })
+
+
+/**
+ * Initialize the scheduler
+ *
+ * @note: The use of this function is RESERVED
+ */
+sos_ret_t sos_sched_subsystem_setup();
+
+
+/**
+ * Mark the given thread as ready
+ *
+ * @note: The use of this function is RESERVED
+ */
+sos_ret_t sos_sched_set_ready(struct sos_thread * thr);
+
+
+/**
+ * Return the identifier of the next thread to run. Also removes it
+ * from the ready list, but does NOT set is as current_thread !
+ *
+ * @param current_thread TCB of the thread calling the function
+ *
+ * @param do_yield When TRUE, put the current executing thread at the
+ * end of the ready list. Otherwise it is kept at the head of it.
+ *
+ * @note: The use of this function is RESERVED
+ */
+struct sos_thread * sos_reschedule(struct sos_thread * current_thread,
+ sos_bool_t do_yield);
+
+/**
+ * Called by thread subsystem each time a READY thread's priority is
+ * changed
+ *
+ * @note: The use of this function is RESERVED (to thread.c)
+ */
+sos_ret_t sos_sched_change_priority(struct sos_thread * thr,
+ sos_sched_priority_t priority);
+
+
+#endif /* _SOS_WAITQUEUE_H_ */
diff --git a/sos-code-article6.75/sos/thread.c b/sos-code-article6.75/sos/thread.c
new file mode 100644
index 0000000..d8027ba
--- /dev/null
+++ b/sos-code-article6.75/sos/thread.c
@@ -0,0 +1,513 @@
+/* Copyright (C) 2004,2005 David Decotigny
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+
+#include <sos/physmem.h>
+#include <sos/kmem_slab.h>
+#include <sos/kmalloc.h>
+#include <sos/klibc.h>
+#include <sos/list.h>
+#include <sos/assert.h>
+
+#include <hwcore/irq.h>
+
+#include "thread.h"
+
+
+/**
+ * The size of the stack of a kernel thread
+ */
+#define SOS_THREAD_KERNEL_STACK_SIZE (1*SOS_PAGE_SIZE)
+
+
+/**
+ * The identifier of the thread currently running on CPU.
+ *
+ * We only support a SINGLE processor, ie a SINGLE thread
+ * running at any time in the system. This greatly simplifies the
+ * implementation of the system, since we don't have to complicate
+ * things in order to retrieve the identifier of the threads running
+ * on the CPU. On multiprocessor systems the current_thread below is
+ * an array indexed by the id of the CPU, so that the challenge is to
+ * retrieve the identifier of the CPU. This is usually done based on
+ * the stack address (Linux implementation) or on some form of TLS
+ * ("Thread Local Storage": can be implemented by way of LDTs for the
+ * processes, accessed through the fs or gs registers).
+ */
+static volatile struct sos_thread *current_thread = NULL;
+
+
+/*
+ * The list of threads currently in the system.
+ *
+ * @note We could have used current_thread for that...
+ */
+static struct sos_thread *thread_list = NULL;
+
+
+/**
+ * The Cache of thread structures
+ */
+static struct sos_kslab_cache *cache_thread;
+
+
+struct sos_thread *sos_thread_get_current()
+{
+ SOS_ASSERT_FATAL(current_thread->state == SOS_THR_RUNNING);
+ return (struct sos_thread*)current_thread;
+}
+
+
+inline static sos_ret_t _set_current(struct sos_thread *thr)
+{
+ SOS_ASSERT_FATAL(thr->state == SOS_THR_READY);
+ current_thread = thr;
+ current_thread->state = SOS_THR_RUNNING;
+ return SOS_OK;
+}
+
+
+sos_ret_t sos_thread_subsystem_setup(sos_vaddr_t init_thread_stack_base_addr,
+ sos_size_t init_thread_stack_size)
+{
+ struct sos_thread *myself;
+
+ /* Allocate the cache of threads */
+ cache_thread = sos_kmem_cache_create("thread",
+ sizeof(struct sos_thread),
+ 2,
+ 0,
+ SOS_KSLAB_CREATE_MAP
+ | SOS_KSLAB_CREATE_ZERO);
+ if (! cache_thread)
+ return -SOS_ENOMEM;
+
+ /* Allocate a new thread structure for the current running thread */
+ myself = (struct sos_thread*) sos_kmem_cache_alloc(cache_thread,
+ SOS_KSLAB_ALLOC_ATOMIC);
+ if (! myself)
+ return -SOS_ENOMEM;
+
+ /* Initialize the thread attributes */
+ strzcpy(myself->name, "[kinit]", SOS_THR_MAX_NAMELEN);
+ myself->state = SOS_THR_CREATED;
+ myself->priority = SOS_SCHED_PRIO_LOWEST;
+ myself->kernel_stack_base_addr = init_thread_stack_base_addr;
+ myself->kernel_stack_size = init_thread_stack_size;
+
+ /* Do some stack poisoning on the bottom of the stack, if needed */
+ sos_cpu_state_prepare_detect_kernel_stack_overflow(myself->cpu_state,
+ myself->kernel_stack_base_addr,
+ myself->kernel_stack_size);
+
+ /* Add the thread in the global list */
+ list_singleton_named(thread_list, myself, gbl_prev, gbl_next);
+
+ /* Ok, now pretend that the running thread is ourselves */
+ myself->state = SOS_THR_READY;
+ _set_current(myself);
+
+ return SOS_OK;
+}
+
+
+struct sos_thread *
+sos_create_kernel_thread(const char *name,
+ sos_kernel_thread_start_routine_t start_func,
+ void *start_arg,
+ sos_sched_priority_t priority)
+{
+ __label__ undo_creation;
+ sos_ui32_t flags;
+ struct sos_thread *new_thread;
+
+ if (! start_func)
+ return NULL;
+ if (! SOS_SCHED_PRIO_IS_VALID(priority))
+ return NULL;
+
+ /* Allocate a new thread structure for the current running thread */
+ new_thread
+ = (struct sos_thread*) sos_kmem_cache_alloc(cache_thread,
+ SOS_KSLAB_ALLOC_ATOMIC);
+ if (! new_thread)
+ return NULL;
+
+ /* Initialize the thread attributes */
+ strzcpy(new_thread->name, ((name)?name:"[NONAME]"), SOS_THR_MAX_NAMELEN);
+ new_thread->state = SOS_THR_CREATED;
+ new_thread->priority = priority;
+
+ /* Allocate the stack for the new thread */
+ new_thread->kernel_stack_base_addr = sos_kmalloc(SOS_THREAD_KERNEL_STACK_SIZE, 0);
+ new_thread->kernel_stack_size = SOS_THREAD_KERNEL_STACK_SIZE;
+ if (! new_thread->kernel_stack_base_addr)
+ goto undo_creation;
+
+ /* Initialize the CPU context of the new thread */
+ if (SOS_OK
+ != sos_cpu_kstate_init(& new_thread->cpu_state,
+ (sos_cpu_kstate_function_arg1_t*) start_func,
+ (sos_ui32_t) start_arg,
+ new_thread->kernel_stack_base_addr,
+ new_thread->kernel_stack_size,
+ (sos_cpu_kstate_function_arg1_t*) sos_thread_exit,
+ (sos_ui32_t) NULL))
+ goto undo_creation;
+
+ /* Add the thread in the global list */
+ sos_disable_IRQs(flags);
+ list_add_tail_named(thread_list, new_thread, gbl_prev, gbl_next);
+ sos_restore_IRQs(flags);
+
+ /* Mark the thread ready */
+ if (SOS_OK != sos_sched_set_ready(new_thread))
+ goto undo_creation;
+
+ /* Normal non-erroneous end of function */
+ return new_thread;
+
+ undo_creation:
+ if (new_thread->kernel_stack_base_addr)
+ sos_kfree((sos_vaddr_t) new_thread->kernel_stack_base_addr);
+ sos_kmem_cache_free((sos_vaddr_t) new_thread);
+ return NULL;
+}
+
+
+/** Function called after thr has terminated. Called from inside the context
+ of another thread, interrupts disabled */
+static void delete_thread(struct sos_thread *thr)
+{
+ sos_ui32_t flags;
+
+ sos_disable_IRQs(flags);
+ list_delete_named(thread_list, thr, gbl_prev, gbl_next);
+ sos_restore_IRQs(flags);
+
+ sos_kfree((sos_vaddr_t) thr->kernel_stack_base_addr);
+ memset(thr, 0x0, sizeof(struct sos_thread));
+ sos_kmem_cache_free((sos_vaddr_t) thr);
+}
+
+
+void sos_thread_exit()
+{
+ sos_ui32_t flags;
+ struct sos_thread *myself, *next_thread;
+
+ /* Interrupt handlers are NOT allowed to exit the current thread ! */
+ SOS_ASSERT_FATAL(! sos_servicing_irq());
+
+ myself = sos_thread_get_current();
+
+ /* Refuse to end the current executing thread if it still holds a
+ resource ! */
+ SOS_ASSERT_FATAL(list_is_empty_named(myself->kwaitq_list,
+ prev_entry_for_thread,
+ next_entry_for_thread));
+
+ /* Prepare to run the next thread */
+ sos_disable_IRQs(flags);
+ myself->state = SOS_THR_ZOMBIE;
+ next_thread = sos_reschedule(myself, FALSE);
+
+ /* Make sure that the next_thread is valid */
+ sos_cpu_state_detect_kernel_stack_overflow(next_thread->cpu_state,
+ next_thread->kernel_stack_base_addr,
+ next_thread->kernel_stack_size);
+
+ /* No need for sos_restore_IRQs() here because the IRQ flag will be
+ restored to that of the next thread upon context switch */
+
+ /* Immediate switch to next thread */
+ _set_current(next_thread);
+ sos_cpu_context_exit_to(next_thread->cpu_state,
+ (sos_cpu_kstate_function_arg1_t*) delete_thread,
+ (sos_ui32_t) myself);
+}
+
+
+sos_sched_priority_t sos_thread_get_priority(struct sos_thread *thr)
+{
+ if (! thr)
+ thr = (struct sos_thread*)current_thread;
+
+ return thr->priority;
+}
+
+
+sos_thread_state_t sos_thread_get_state(struct sos_thread *thr)
+{
+ if (! thr)
+ thr = (struct sos_thread*)current_thread;
+
+ return thr->state;
+}
+
+
+typedef enum { YIELD_MYSELF, BLOCK_MYSELF } switch_type_t;
+/**
+ * Helper function to initiate a context switch in case the current
+ * thread becomes blocked, waiting for a timeout, or calls yield.
+ */
+static sos_ret_t _switch_to_next_thread(switch_type_t operation)
+{
+ struct sos_thread *myself, *next_thread;
+
+ SOS_ASSERT_FATAL(current_thread->state == SOS_THR_RUNNING);
+
+ /* Interrupt handlers are NOT allowed to block ! */
+ SOS_ASSERT_FATAL(! sos_servicing_irq());
+
+ myself = (struct sos_thread*)current_thread;
+
+ /* Make sure that if we are to be marked "BLOCKED", we have any
+ reason of effectively being blocked */
+ if (BLOCK_MYSELF == operation)
+ {
+ myself->state = SOS_THR_BLOCKED;
+ }
+
+ /* Identify the next thread */
+ next_thread = sos_reschedule(myself, YIELD_MYSELF == operation);
+
+ /* Avoid context switch if the context does not change */
+ if (myself != next_thread)
+ {
+ /* Sanity checks for the next thread */
+ sos_cpu_state_detect_kernel_stack_overflow(next_thread->cpu_state,
+ next_thread->kernel_stack_base_addr,
+ next_thread->kernel_stack_size);
+
+
+ /*
+ * Actual CPU context switch
+ */
+ _set_current(next_thread);
+ sos_cpu_context_switch(& myself->cpu_state, next_thread->cpu_state);
+
+ /* Back here ! */
+ SOS_ASSERT_FATAL(current_thread == myself);
+ SOS_ASSERT_FATAL(current_thread->state == SOS_THR_RUNNING);
+ }
+ else
+ {
+ /* No context switch but still update ID of current thread */
+ _set_current(next_thread);
+ }
+
+ return SOS_OK;
+}
+
+
+/**
+ * Helper function to change the thread's priority in all the
+ * waitqueues associated with the thread.
+ */
+static sos_ret_t _change_waitq_priorities(struct sos_thread *thr,
+ sos_sched_priority_t priority)
+{
+ struct sos_kwaitq_entry *kwq_entry;
+ int nb_waitqs;
+
+ list_foreach_forward_named(thr->kwaitq_list, kwq_entry, nb_waitqs,
+ prev_entry_for_thread, next_entry_for_thread)
+ {
+ SOS_ASSERT_FATAL(SOS_OK == sos_kwaitq_change_priority(kwq_entry->kwaitq,
+ kwq_entry,
+ priority));
+ }
+
+ return SOS_OK;
+}
+
+
+sos_ret_t sos_thread_set_priority(struct sos_thread *thr,
+ sos_sched_priority_t priority)
+{
+ __label__ exit_set_prio;
+ sos_ui32_t flags;
+ sos_ret_t retval;
+
+
+ if (! SOS_SCHED_PRIO_IS_VALID(priority))
+ return -SOS_EINVAL;
+
+ if (! thr)
+ thr = (struct sos_thread*)current_thread;
+
+ sos_disable_IRQs(flags);
+
+ /* Signal kwaitq subsystem that the priority of the thread in all
+ the waitq it is waiting in should be updated */
+ retval = _change_waitq_priorities(thr, priority);
+ if (SOS_OK != retval)
+ goto exit_set_prio;
+
+ /* Signal scheduler that the thread, currently in a waiting list,
+ should take into account the change of priority */
+ if (SOS_THR_READY == thr->state)
+ retval = sos_sched_change_priority(thr, priority);
+
+ /* Update priority */
+ thr->priority = priority;
+
+ exit_set_prio:
+ sos_restore_IRQs(flags);
+ return retval;
+}
+
+
+sos_ret_t sos_thread_yield()
+{
+ sos_ui32_t flags;
+ sos_ret_t retval;
+
+ sos_disable_IRQs(flags);
+
+ retval = _switch_to_next_thread(YIELD_MYSELF);
+
+ sos_restore_IRQs(flags);
+ return retval;
+}
+
+
+/**
+ * Internal sleep timeout management
+ */
+struct sleep_timeout_params
+{
+ struct sos_thread *thread_to_wakeup;
+ sos_bool_t timeout_triggered;
+};
+
+
+/**
+ * Callback called when a timeout happened
+ */
+static void sleep_timeout(struct sos_timeout_action *act)
+{
+ struct sleep_timeout_params *sleep_timeout_params
+ = (struct sleep_timeout_params*) act->routine_data;
+
+ /* Signal that we have been woken up by the timeout */
+ sleep_timeout_params->timeout_triggered = TRUE;
+
+ /* Mark the thread ready */
+ SOS_ASSERT_FATAL(SOS_OK ==
+ sos_thread_force_unblock(sleep_timeout_params
+ ->thread_to_wakeup));
+}
+
+
+sos_ret_t sos_thread_sleep(struct sos_time *timeout)
+{
+ sos_ui32_t flags;
+ struct sleep_timeout_params sleep_timeout_params;
+ struct sos_timeout_action timeout_action;
+ sos_ret_t retval;
+
+ /* Block forever if no timeout is given */
+ if (NULL == timeout)
+ {
+ sos_disable_IRQs(flags);
+ retval = _switch_to_next_thread(BLOCK_MYSELF);
+ sos_restore_IRQs(flags);
+
+ return retval;
+ }
+
+ /* Initialize the timeout action */
+ sos_time_init_action(& timeout_action);
+
+ /* Prepare parameters used by the sleep timeout callback */
+ sleep_timeout_params.thread_to_wakeup
+ = (struct sos_thread*)current_thread;
+ sleep_timeout_params.timeout_triggered = FALSE;
+
+ sos_disable_IRQs(flags);
+
+ /* Now program the timeout ! */
+ SOS_ASSERT_FATAL(SOS_OK ==
+ sos_time_register_action_relative(& timeout_action,
+ timeout,
+ sleep_timeout,
+ & sleep_timeout_params));
+
+ /* Prepare to block: wait for sleep_timeout() to wakeup us in the
+ timeout kwaitq, or for someone to wake us up in any other
+ waitq */
+ retval = _switch_to_next_thread(BLOCK_MYSELF);
+ /* Unblocked by something ! */
+
+ /* Unblocked by timeout ? */
+ if (sleep_timeout_params.timeout_triggered)
+ {
+ /* Yes */
+ SOS_ASSERT_FATAL(sos_time_is_zero(& timeout_action.timeout));
+ retval = SOS_OK;
+ }
+ else
+ {
+ /* No: We have probably been woken up while in some other
+ kwaitq */
+ SOS_ASSERT_FATAL(SOS_OK == sos_time_unregister_action(& timeout_action));
+ retval = -SOS_EINTR;
+ }
+
+ sos_restore_IRQs(flags);
+
+ /* Update the remaining timeout */
+ memcpy(timeout, & timeout_action.timeout, sizeof(struct sos_time));
+
+ return retval;
+}
+
+
+sos_ret_t sos_thread_force_unblock(struct sos_thread *thread)
+{
+ sos_ret_t retval;
+ sos_ui32_t flags;
+
+ if (! thread)
+ return -SOS_EINVAL;
+
+ sos_disable_IRQs(flags);
+
+ /* Thread already woken up ? */
+ retval = SOS_OK;
+ switch(sos_thread_get_state(thread))
+ {
+ case SOS_THR_RUNNING:
+ case SOS_THR_READY:
+ /* Do nothing */
+ break;
+
+ case SOS_THR_ZOMBIE:
+ retval = -SOS_EFATAL;
+ break;
+
+ default:
+ retval = sos_sched_set_ready(thread);
+ break;
+ }
+
+ sos_restore_IRQs(flags);
+
+ return retval;
+}
diff --git a/sos-code-article6.75/sos/thread.h b/sos-code-article6.75/sos/thread.h
new file mode 100644
index 0000000..5fcb2f4
--- /dev/null
+++ b/sos-code-article6.75/sos/thread.h
@@ -0,0 +1,228 @@
+/* Copyright (C) 2004,2005 David Decotigny
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#ifndef _SOS_THREAD_H_
+#define _SOS_THREAD_H_
+
+/**
+ * @file thread.h
+ *
+ * SOS Thread management API
+ */
+
+#include <sos/errno.h>
+
+/* Forward declaration */
+struct sos_thread;
+
+#include <hwcore/cpu_context.h>
+#include <sos/sched.h>
+#include <sos/kwaitq.h>
+#include <sos/time.h>
+
+/**
+ * The possible states of a valid thread
+ */
+typedef enum { SOS_THR_CREATED, /**< Thread created, not fully initialized */
+ SOS_THR_READY, /**< Thread fully initialized or
+ waiting for CPU after having been
+ blocked or preempted */
+ SOS_THR_RUNNING, /**< Thread currently running on CPU */
+ SOS_THR_BLOCKED, /**< Thread waiting for I/O (+ in at LEAST
+ one kwaitq) and/or sleeping (+ in NO
+ kwaitq) */
+ SOS_THR_ZOMBIE, /**< Thread terminated execution, waiting to
+ be deleted by kernel */
+ } sos_thread_state_t;
+
+
+/**
+ * TCB (Thread Control Block): structure describing a thread. Don't
+ * access these fields directly: prefer using the accessor functions
+ * below.
+ */
+struct sos_thread
+{
+#define SOS_THR_MAX_NAMELEN 32
+ char name[SOS_THR_MAX_NAMELEN];
+
+ sos_thread_state_t state;
+ sos_sched_priority_t priority;
+
+ /**
+ * The hardware context of the thread.
+ *
+ * It will reflect the CPU state of the thread:
+ * - From an interrupt handler: the state of the thread at the time
+ * of the OUTERMOST irq. An IRQ is not allowed to make context
+ * switches, so this context will remain valid from the begining of
+ * the outermost IRQ handler to the end of it, no matter if there
+ * are other IRQ handlers nesting in one another. You may safely
+ * use it from IRQ handlers to query the state of the interrupted
+ * thread, no matter if there has been other IRQ handlers
+ * executing meanwhile.
+ * - From normal kernel code, exceptions and syscall: the state of
+ * the thread the last time there was a context switch from this
+ * thread to another one. Thus this field WON'T reflect the
+ * current's thread cpu_state in these cases. So, in these cases,
+ * simply DO NOT USE IT outside thread.c ! Note: for syscall and
+ * exception handlers, the VALID state of the interrupted thread is
+ * passed as an argument to the handlers.
+ */
+ struct sos_cpu_state *cpu_state;
+
+ /* Kernel stack parameters */
+ sos_vaddr_t kernel_stack_base_addr;
+ sos_size_t kernel_stack_size;
+
+ /* Data specific to each state */
+ union
+ {
+ struct
+ {
+ struct sos_sched_queue *rdy_queue;
+ struct sos_thread *rdy_prev, *rdy_next;
+ } ready;
+ }; /* Anonymous union (gcc extenion) */
+
+
+ /*
+ * Data used by the kwaitq subsystem: list of kwaitqueues the thread
+ * is waiting for.
+ *
+ * @note: a RUNNING or READY thread might be in one or more
+ * waitqueues ! The only property we have is that, among these
+ * waitqueues (if any), _at least_ one has woken the thread.
+ */
+ struct sos_kwaitq_entry *kwaitq_list;
+
+
+ /**
+ * Chaining pointers for global ("gbl") list of threads (debug)
+ */
+ struct sos_thread *gbl_prev, *gbl_next;
+};
+
+
+/**
+ * Definition of the function executed by a kernel thread
+ */
+typedef void (*sos_kernel_thread_start_routine_t)(void *arg);
+
+
+/**
+ * Initialize the subsystem responsible for thread management
+ *
+ * Initialize the primary kernel thread so that it can be handled the
+ * same way as an ordinary thread created by sos_thread_create().
+ */
+sos_ret_t sos_thread_subsystem_setup(sos_vaddr_t init_thread_stack_base_addr,
+ sos_size_t init_thread_stack_size);
+
+
+/**
+ * Create a new kernel thread
+ */
+struct sos_thread *
+sos_create_kernel_thread(const char *name,
+ sos_kernel_thread_start_routine_t start_func,
+ void *start_arg,
+ sos_sched_priority_t priority);
+
+
+/**
+ * Terminate the execution of the current thread. For kernel threads,
+ * it is called by default when the start routine returns.
+ */
+void sos_thread_exit() __attribute__((noreturn));
+
+
+/**
+ * Get the identifier of the thread currently running on CPU. Trivial
+ * function.
+ */
+struct sos_thread *sos_thread_get_current();
+
+
+/**
+ * If thr == NULL, set the priority of the current thread. Trivial
+ * function.
+ *
+ * @note NOT protected against interrupts
+ */
+sos_sched_priority_t sos_thread_get_priority(struct sos_thread *thr);
+
+
+/**
+ * If thr == NULL, get the state of the current thread. Trivial
+ * function.
+ *
+ * @note NOT protected against interrupts
+ */
+sos_thread_state_t sos_thread_get_state(struct sos_thread *thr);
+
+
+/**
+ * If thr == NULL, set the priority of the current thread
+ *
+ * @note NO context-switch ever occurs in this function !
+ */
+sos_ret_t sos_thread_set_priority(struct sos_thread *thr,
+ sos_sched_priority_t priority);
+
+
+/**
+ * Yield CPU to another ready thread.
+ *
+ * @note This is a BLOCKING FUNCTION
+ */
+sos_ret_t sos_thread_yield();
+
+
+/**
+ * Release the CPU for (at least) the given delay.
+ *
+ * @param delay The delay to wait for. If delay == NULL then wait
+ * forever that any event occurs.
+ *
+ * @return SOS_OK when delay expired (and delay is reset to zero),
+ * -SOS_EINTR otherwise (and delay contains the amount of time
+ * remaining).
+ *
+ * @note This is a BLOCKING FUNCTION
+ */
+sos_ret_t sos_thread_sleep(/* in/out */struct sos_time *delay);
+
+
+/**
+ * Mark the given thread as READY (if not already ready) even if it is
+ * blocked in a kwaitq or in a sleep ! As a result, the interrupted
+ * kwaitq/sleep function call of the thread will return with
+ * -SOS_EINTR.
+ *
+ * @return -SOS_EINVAL if thread does not exist, or -SOS_EFATAL if
+ * marked ZOMBIE.
+ *
+ * @note As a result, the semaphore/mutex/conditions/... functions
+ * return values SHOULD ALWAYS be checked ! If they are != SOS_OK,
+ * then the caller should consider that the resource is not aquired
+ * because somebody woke the thread by some way.
+ */
+sos_ret_t sos_thread_force_unblock(struct sos_thread *thread);
+
+
+#endif /* _SOS_THREAD_H_ */
diff --git a/sos-code-article6.75/sos/time.c b/sos-code-article6.75/sos/time.c
new file mode 100644
index 0000000..5181959
--- /dev/null
+++ b/sos-code-article6.75/sos/time.c
@@ -0,0 +1,355 @@
+/* Copyright (C) 2004 David Decotigny
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+
+#include <sos/assert.h>
+#include <sos/klibc.h>
+#include <hwcore/irq.h>
+#include <sos/list.h>
+
+#include "time.h"
+
+
+/**
+ * Number of nanoseconds in 1 second
+ */
+#define NS_IN_SEC 1000000000UL
+
+
+/**
+ * The list of timeout actions waiting for a timeout. The timeout
+ * actions are stored in the list in increasing initial timeout
+ * order. Actually, the "timeout" field won't reflect this initial
+ * timeout: for each element in the list, it stores the timeout
+ * _difference_ between the timeout action and the previous in the
+ * list.
+ */
+static struct sos_timeout_action *timeout_action_list;
+
+
+/**
+ * Current resolution of a time tick
+ */
+static struct sos_time tick_resolution;
+
+
+/**
+ * Time elapsed between boot and last timer tick
+ *
+ * @note No 'volatile' here because the tick value is NEVER modified
+ * while in any of the functions below: it is modified only out of
+ * these functions by the IRQ timer handler because these functions
+ * are protected against timer IRQ and are "one shot" (no busy waiting
+ * for a change in the tick's value).
+ */
+static struct sos_time last_tick_time;
+
+
+sos_ret_t sos_time_inc(struct sos_time *dest,
+ const struct sos_time *to_add)
+{
+ /* nanosec is always < 1e9 so that their sum is always < 2e9, which
+ is smaller than 2^32-1 */
+ sos_ui32_t sigma_ns = dest->nanosec + to_add->nanosec;
+
+ dest->sec += to_add->sec;
+ dest->sec += sigma_ns / NS_IN_SEC;
+ dest->nanosec = sigma_ns % NS_IN_SEC;
+ return SOS_OK;
+}
+
+
+sos_ret_t sos_time_dec(struct sos_time *dest,
+ const struct sos_time *to_dec)
+{
+ /* nanosec is always < 1e9 so that their difference is always in
+ (-1e9, 1e9), which is compatible with the (-2^31, 2^31 - 1)
+ cpacity of a signed dword */
+ sos_si32_t diff_ns = ((sos_si32_t)dest->nanosec)
+ - ((sos_si32_t)to_dec->nanosec);
+
+ /* Make sure substraction is possible */
+ SOS_ASSERT_FATAL(dest->sec >= to_dec->sec);
+ if (dest->sec == to_dec->sec)
+ SOS_ASSERT_FATAL(dest->nanosec >= to_dec->nanosec);
+
+ dest->sec -= to_dec->sec;
+ if (diff_ns > 0)
+ dest->sec += diff_ns / NS_IN_SEC;
+ else
+ dest->sec -= ((-diff_ns) / NS_IN_SEC);
+ dest->nanosec = (NS_IN_SEC + diff_ns) % NS_IN_SEC;
+ if (diff_ns < 0)
+ dest->sec --;
+ return SOS_OK;
+}
+
+
+int sos_time_cmp(const struct sos_time *t1,
+ const struct sos_time *t2)
+{
+ /* Compare seconds */
+ if (t1->sec < t2->sec)
+ return -1;
+ else if (t1->sec > t2->sec)
+ return 1;
+
+ /* seconds are equal => compare nanoseconds */
+ else if (t1->nanosec < t2->nanosec)
+ return -1;
+ else if (t1->nanosec > t2->nanosec)
+ return 1;
+
+ /* else: sec and nanosecs are equal */
+ return 0;
+}
+
+
+sos_bool_t sos_time_is_zero(const struct sos_time *tm)
+{
+ return ( (0 == tm->sec) && (0 == tm->nanosec) );
+}
+
+
+sos_ret_t sos_time_subsysem_setup(const struct sos_time *initial_resolution)
+{
+ timeout_action_list = NULL;
+ last_tick_time = (struct sos_time) { .sec = 0, .nanosec = 0 };
+ memcpy(& tick_resolution, initial_resolution, sizeof(struct sos_time));
+
+ return SOS_OK;
+}
+
+
+sos_ret_t sos_time_get_tick_resolution(struct sos_time *resolution)
+{
+ sos_ui32_t flags;
+ sos_disable_IRQs(flags);
+
+ memcpy(resolution, & tick_resolution, sizeof(struct sos_time));
+
+ sos_restore_IRQs(flags);
+ return SOS_OK;
+}
+
+
+sos_ret_t sos_time_set_tick_resolution(const struct sos_time *resolution)
+{
+ sos_ui32_t flags;
+
+ sos_disable_IRQs(flags);
+ memcpy(& tick_resolution, resolution, sizeof(struct sos_time));
+ sos_restore_IRQs(flags);
+
+ return SOS_OK;
+}
+
+
+sos_ret_t sos_time_get_now(struct sos_time *now)
+{
+ sos_ui32_t flags;
+ sos_disable_IRQs(flags);
+
+ memcpy(now, & last_tick_time, sizeof(struct sos_time));
+
+ sos_restore_IRQs(flags);
+ return SOS_OK;
+}
+
+
+/**
+ * Helper routine to add the action in the list. MUST be called with
+ * interrupts disabled !
+ */
+static sos_ret_t _add_action(struct sos_timeout_action *act,
+ const struct sos_time *due_date,
+ sos_bool_t is_relative_due_date,
+ sos_timeout_routine_t *routine,
+ void *routine_data)
+{
+ struct sos_timeout_action *other, *insert_before;
+ int nb_act;
+
+ /* Delay must be specified */
+ if (due_date == NULL)
+ return -SOS_EINVAL;
+
+ /* Action container MUST be specified */
+ if (act == NULL)
+ return -SOS_EINVAL;
+
+ /* Refuse to add an empty action */
+ if (NULL == routine)
+ return -SOS_EINVAL;
+
+ /* Refuse to add the action if it is already added */
+ if (NULL != act->tmo_next)
+ return -SOS_EBUSY;
+
+ /* Compute action absolute due date */
+ if (is_relative_due_date)
+ {
+ /* The provided due_date is relative to the current time */
+ memcpy(& act->timeout, & last_tick_time, sizeof(struct sos_time));
+ sos_time_inc(& act->timeout, due_date);
+ }
+ else
+ {
+ /* The provided due_date is absolute (ie relative to the system
+ boot instant) */
+
+ if (sos_time_cmp(due_date, & last_tick_time) < 0)
+ /* Refuse to add a past action ! */
+ return -SOS_EINVAL;
+
+ memcpy(& act->timeout, due_date, sizeof(struct sos_time));
+ }
+
+ /* Prepare the action data structure */
+ act->routine = routine;
+ act->routine_data = routine_data;
+
+ /* Find the right place in the list of the timeout action. */
+ insert_before = NULL;
+ list_foreach_forward_named(timeout_action_list,
+ other, nb_act,
+ tmo_prev, tmo_next)
+ {
+ if (sos_time_cmp(& act->timeout, & other->timeout) < 0)
+ {
+ insert_before = other;
+ break;
+ }
+
+ /* Loop over to next timeout */
+ }
+
+ /* Now insert the action in the list */
+ if (insert_before != NULL)
+ list_insert_before_named(timeout_action_list, insert_before, act,
+ tmo_prev, tmo_next);
+ else
+ list_add_tail_named(timeout_action_list, act,
+ tmo_prev, tmo_next);
+
+ return SOS_OK;
+}
+
+
+sos_ret_t
+sos_time_register_action_relative(struct sos_timeout_action *act,
+ const struct sos_time *delay,
+ sos_timeout_routine_t *routine,
+ void *routine_data)
+{
+ sos_ui32_t flags;
+ sos_ret_t retval;
+
+ sos_disable_IRQs(flags);
+ retval = _add_action(act, delay, TRUE, routine, routine_data);
+ sos_restore_IRQs(flags);
+
+ return retval;
+}
+
+
+sos_ret_t
+sos_time_register_action_absolute(struct sos_timeout_action *act,
+ const struct sos_time *date,
+ sos_timeout_routine_t *routine,
+ void *routine_data)
+{
+ sos_ui32_t flags;
+ sos_ret_t retval;
+
+ sos_disable_IRQs(flags);
+ retval = _add_action(act, date, FALSE, routine, routine_data);
+ sos_restore_IRQs(flags);
+
+ return retval;
+}
+
+
+/**
+ * Helper routine to remove the action from the list. MUST be called
+ * with interrupts disabled !
+ */
+static sos_ret_t _remove_action(struct sos_timeout_action *act)
+{
+ /* Don't do anything if action is not in timeout list */
+ if (NULL == act->tmo_next)
+ return -SOS_EINVAL;
+
+ /* Update the action's remaining timeout */
+ if (sos_time_cmp(& act->timeout, & last_tick_time) <= 0)
+ act->timeout = (struct sos_time){ .sec=0, .nanosec=0 };
+ else
+ sos_time_dec(& act->timeout, & last_tick_time);
+
+ /* Actually remove the action from the list */
+ list_delete_named(timeout_action_list, act,
+ tmo_prev, tmo_next);
+ act->tmo_prev = act->tmo_next = NULL;
+
+ return SOS_OK;
+}
+
+
+sos_ret_t sos_time_unregister_action(struct sos_timeout_action *act)
+{
+ sos_ret_t retval;
+ sos_ui32_t flags;
+
+ sos_disable_IRQs(flags);
+ retval = _remove_action(act);
+ sos_restore_IRQs(flags);
+
+ return SOS_OK;
+}
+
+
+sos_ret_t sos_time_do_tick()
+{
+ sos_ui32_t flags;
+
+ sos_disable_IRQs(flags);
+
+ /* Update kernel time */
+ sos_time_inc(& last_tick_time, & tick_resolution);
+
+ while (! list_is_empty_named(timeout_action_list, tmo_prev, tmo_next))
+ {
+ struct sos_timeout_action *act;
+ act = list_get_head_named(timeout_action_list, tmo_prev, tmo_next);
+
+ /* Did we go too far in the actions' list ? */
+ if (sos_time_cmp(& last_tick_time, & act->timeout) < 0)
+ {
+ /* Yes: No need to look further. */
+ break;
+ }
+
+ /* Remove the action from the list */
+ _remove_action(act);
+
+ /* Call the action's routine */
+ act->routine(act);
+ }
+
+ sos_restore_IRQs(flags);
+ return SOS_OK;
+}
diff --git a/sos-code-article6.75/sos/time.h b/sos-code-article6.75/sos/time.h
new file mode 100644
index 0000000..7d3a90b
--- /dev/null
+++ b/sos-code-article6.75/sos/time.h
@@ -0,0 +1,222 @@
+/* Copyright (C) 2004 David Decotigny
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#ifndef _SOS_TIME_H_
+#define _SOS_TIME_H_
+
+/**
+ * @file time.h
+ *
+ * Primitives and callbacks related to kernel time management (timer
+ * IRQ)
+ */
+
+#include <sos/types.h>
+#include <sos/errno.h>
+#include <sos/klibc.h>
+
+
+/* =======================================================================
+ * Library of time manipulation functions
+ */
+struct sos_time
+{
+ sos_ui32_t sec;
+ sos_ui32_t nanosec;
+};
+
+sos_ret_t sos_time_inc(struct sos_time *dest,
+ const struct sos_time *to_add);
+
+sos_ret_t sos_time_dec(struct sos_time *dest,
+ const struct sos_time *to_dec);
+
+int sos_time_cmp(const struct sos_time *t1,
+ const struct sos_time *t2);
+
+sos_bool_t sos_time_is_zero(const struct sos_time *tm);
+
+
+
+/* =======================================================================
+ * Kernel time management. This is not the same as the "system-time",
+ * ie it does not not take into account the system-time adjustments
+ * (NTP, daylight saving times, etc...): this is the job of a
+ * system-time subsystem.
+ */
+
+
+/**
+ * Initialize kernel time subsystem.
+ *
+ * @param initial_resolution The initial time resolution. MUST be
+ * consistent with that of the hardware timer
+ */
+sos_ret_t sos_time_subsysem_setup(const struct sos_time *initial_resolution);
+
+
+/**
+ * Value of the interval between 2 time ticks. Should be consistent
+ * with the configuration of the hardware timer.
+ */
+sos_ret_t sos_time_get_tick_resolution(struct sos_time *resolution);
+
+
+/**
+ * Change the value of the interval between 2 time ticks. Must be
+ * called each time the hardware timer is reconfigured.
+ *
+ * @note MUST be consistent with that of the hardware timer
+ */
+sos_ret_t sos_time_set_tick_resolution(const struct sos_time *resolution);
+
+
+/**
+ * Get the time elapsed since system boot. Does not take into account
+ * the system-time adjustment (NTP, daylight saving times, etc...):
+ * this is the job of a system-time subsystem.
+ */
+sos_ret_t sos_time_get_now(struct sos_time *now);
+
+
+
+/* =======================================================================
+ * Routines to schedule future execution of routines: "timeout" actions
+ */
+
+/* Forward declaration */
+struct sos_timeout_action;
+
+/**
+ * Prototype of a timeout routine. Called with IRQ disabled !
+ */
+typedef void (sos_timeout_routine_t)(struct sos_timeout_action *);
+
+
+/**
+ * The structure of a timeout action. This structure should have been
+ * opaque to the other parts of the kernel. We keep it public here so
+ * that struct sos_timeout_action can be allocated on the stack from
+ * other source files in the kernel. However, all the fields should be
+ * considered read-only for modules others than time.{ch}.
+ *
+ * @note After an action has been allocated (on the stack or kmalloc),
+ * it MUST be initialized with sos_time_init_action below !
+ */
+struct sos_timeout_action
+{
+ /** PUBLIC: Address of the timeout routine */
+ sos_timeout_routine_t *routine;
+
+ /** PUBLIC: (Custom) data available for this routine */
+ void *routine_data;
+
+ /** PUBLIC: 2 meanings:
+ * - before and while in the timeout list: absolute due date of the
+ * timeout action
+ * - once removed from timeout list: the time remaining in the
+ * initial timeout (might be 0 if timeout expired) at removal
+ * time
+ */
+ struct sos_time timeout;
+
+ /** PRIVATE: To chain the timeout actions */
+ struct sos_timeout_action *tmo_prev, *tmo_next;
+};
+
+
+/**
+ * Initialize a timeout action. MUST be called immediately after
+ * (stack or kmalloc) allocation of the action.
+ *
+ * @param ptr_act Pointer to the action to initialize.
+ */
+#define sos_time_init_action(ptr_act) \
+ ({ (ptr_act)->tmo_prev = (ptr_act)->tmo_next = NULL; /* return */ SOS_OK; })
+
+
+/**
+ * Add the given action in the timeout list, so that it will be
+ * triggered after the specified delay RELATIVE to the time when the
+ * function gets called. The action is always inserted in the list.
+ *
+ * @param act The action to be initialized by the function upon
+ * insertion in the timeout list.
+ *
+ * @param delay Delay until the action is fired. If 0, then it is
+ * fired at next timer IRQ. The action will be fired in X ticks, with
+ * X integer and >= delay.
+ *
+ * @param routine The timeout routine to call when the timeout will be
+ * triggered.
+ *
+ * @param routine_data The data available to the routine when it will
+ * be called.
+ *
+ * @note 'act' MUST remain valid until it is either fired or removed
+ * (with sos_time_remove_action)
+ */
+sos_ret_t
+sos_time_register_action_relative(struct sos_timeout_action *act,
+ const struct sos_time *delay,
+ sos_timeout_routine_t *routine,
+ void *routine_data);
+
+
+/**
+ * Add the given action in the timeout list, so that it will be
+ * triggered after the specified ABSOLUTE date (relative to system
+ * boot time). The action is always inserted in the list.
+ *
+ * @param act The action to be initialized by the function upon
+ * insertion in the timeout list.
+ *
+ * @param date Absolute date (relative to system boot time) when the
+ * action will be triggered.
+ *
+ * @param routine The timeout routine to call when the timeout will be
+ * triggered.
+ *
+ * @param routine_data The data available to the routine when it will
+ * be called.
+ *
+ * @note 'act' MUST remain valid until it is either fired or removed
+ * (with sos_time_remove_action)
+ */
+sos_ret_t
+sos_time_register_action_absolute(struct sos_timeout_action *act,
+ const struct sos_time *date,
+ sos_timeout_routine_t *routine,
+ void *routine_data);
+
+
+/**
+ * The action is removed and its timeout is updated to reflect the
+ * time remaining.
+ */
+sos_ret_t sos_time_unregister_action(struct sos_timeout_action *act);
+
+
+/**
+ * Timer IRQ callback. Call and remove expired actions from the list.
+ *
+ * @note The use of this function is RESERVED (to timer IRQ)
+ */
+sos_ret_t sos_time_do_tick();
+
+
+#endif /* _SOS_TIME_H_ */
diff --git a/sos-code-article6.75/sos/types.h b/sos-code-article6.75/sos/types.h
new file mode 100644
index 0000000..bf04314
--- /dev/null
+++ b/sos-code-article6.75/sos/types.h
@@ -0,0 +1,52 @@
+/* Copyright (C) 2004 The SOS Team
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+#ifndef _SOS_TYPES_H_
+#define _SOS_TYPES_H_
+
+/**
+ * @file types.h
+ *
+ * SOS basic types definition
+ */
+
+/** Physical address */
+typedef unsigned int sos_paddr_t;
+
+/** Kernel virtual address */
+typedef unsigned int sos_vaddr_t;
+
+/** Memory size of an object (positive) */
+typedef unsigned int sos_size_t;
+/** Generic count of objects */
+typedef unsigned int sos_count_t;
+
+/** Low-level sizes */
+typedef unsigned long int sos_ui32_t; /* 32b unsigned */
+typedef unsigned short int sos_ui16_t; /* 16b unsigned */
+typedef unsigned char sos_ui8_t; /* 8b unsigned */
+typedef signed long int sos_si32_t; /* 32b signed */
+typedef signed short int sos_si16_t; /* 16b signed */
+typedef signed char sos_si8_t; /* 8b signed */
+
+typedef enum { FALSE=0, TRUE } sos_bool_t;
+
+/** Not a proper type, but highly useful with basic type
+ manipulations */
+#define NULL ((void*)0)
+
+#endif /* _SOS_TYPES_H_ */
diff --git a/sos-code-article6.75/support/build_image.sh b/sos-code-article6.75/support/build_image.sh
new file mode 100755
index 0000000..43929cd
--- /dev/null
+++ b/sos-code-article6.75/support/build_image.sh
@@ -0,0 +1,215 @@
+#!/bin/sh
+# Copyright (C) 2003, David Decotigny
+
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+# USA.
+
+# 1) What does it do ?
+#
+# 1) Check where Grub is installed (lookup_grub)
+# 2) Assign some local variables using the shell script arguments.
+# a) Argument 1 : the destination (either a file or a drive, like a:)
+# b) Argument 2 : the loader (i.e kernel)
+# c) Argument 3 : options passed to the loader
+# d) Argument 4 : the modules (that can be loaded optionally by Grub)
+# 3) Test whether destination is a drive or a file
+# 4) Create the directory structure inside the drive
+# 5) Copy the loader in the drive
+# 6) Generate the 'menu.txt' file used by Grub to generate the boot menu
+# 7) Copy all modules
+# 8) Copy the menu.txt file
+#
+# 2) Why is it so complex ?
+# Because it must support various Grub/mtools installations and versions
+#
+# In fact, this shell script is used in the KOS (kos.enix.org)
+# project. This operating system consists in a loader and many many
+# modules that are linked together at boot time. It is much more
+# complex that a simple monolithic kernel.
+#
+# For your simple monolithic kernel, you only need to give argument 1
+# and 2.
+
+print_usage () {
+ echo "Usage: $0 [X:|image] path/to/loader option path/to/modules..."
+ echo " where X: is a valid floppy drive on your computer"
+ echo " where image is any file name"
+ exit 1
+}
+
+grub_dirs_common="/usr/local/share/grub/i386-freebsd /usr/local/share/grub/i386-pc /usr/share/grub/i386-pc /usr/lib/grub/i386-pc /usr/local/grub /usr/share/grub/i386-redhat /usr/local/src/grub-0.5.94 $HOME/share/grub/i386-pc/"
+sbin_grub_path="/usr/local/sbin /usr/sbin /sbin $HOME/sbin"
+
+PATH=$PATH:/sbin:/usr/sbin:/usr/local/sbin
+export PATH
+
+MTOOLSRC=mtoolsrc
+export MTOOLSRC
+
+# Redefined variables
+FLOPPY_DRIVE=A:
+IMG_FNAME=fd.img
+
+##
+## Format disk image
+##
+init_image () {
+ echo "Initialize disk image $IMG_FILE..."
+ if [ ! -f $IMG_FNAME ] ; then
+ dd if=/dev/zero of=$IMG_FNAME bs=18k count=80 1>/dev/null 2>&1
+ fi
+
+ rm -f $MTOOLSRC
+ echo "drive u: file=\"$IMG_FNAME\" 1.44M filter" > $MTOOLSRC
+
+ if mformat U: ; then : ; else
+ rm -f $MTOOLSRC
+ echo "drive u: file=\"$IMG_FNAME\" 1.44M" > $MTOOLSRC
+ if mformat U: ; then : ; else
+ rm -f $MTOOLSRC
+ echo "drive u: file=\"$IMG_FNAME\"" > $MTOOLSRC
+ mformat U:
+ fi
+ fi
+}
+
+
+##
+## Format (real) floppy disk
+##
+init_floppy () {
+ echo "Formatting floppy..."
+ mformat $FLOPPY_DRIVE || exit 1
+}
+
+
+lookup_grub () {
+ # Look for a correct GRUBDIR
+ for d in $grub_dirs_common ; do
+ if [ -d $d ] ; then
+ GRUBDIR=$d
+ break
+ fi
+ done
+
+ # Try to guess with locate
+ if [ ! -d "$GRUBDIR" ] ; then
+ GRUBDIR=`locate stage2 | head -1 | xargs dirname 2>/dev/null`
+ fi
+
+ # Look for a correct sbin/grub
+ for d in $sbin_grub_path ; do
+ if [ -x $d/grub ] ; then
+ SBIN_GRUB=$d/grub
+ break
+ fi
+ done
+
+ if [ -d "$GRUBDIR" -a -x "$SBIN_GRUB" ] ; then
+ echo "Found correct grub installation in $GRUBDIR"
+ echo "Found correct /sbin/grub at $SBIN_GRUB"
+ else
+ echo "Couldn't find a correct grub installation."
+ exit 1
+ fi
+}
+
+##
+## setup_disk [drive]
+## => setup disk directory structure / copy files
+##
+setup_disk () {
+ echo "Setup destination disk..."
+
+ mmd $1/boot
+ mmd $1/boot/grub
+
+ if [ -d $GRUBDIR/stage1 ] ; then
+ mcopy $GRUBDIR/stage1/stage1 $1/boot/grub/
+ mcopy $GRUBDIR/stage2/stage2 $1/boot/grub/
+ else
+ mcopy $GRUBDIR/stage1 $1/boot/grub/
+ mcopy $GRUBDIR/stage2 $1/boot/grub/
+ fi
+ mmd $1/system
+ mmd $1/modules
+
+ $SBIN_GRUB --batch <<EOT 1>/dev/null 2>/dev/null || exit 1
+device (fd0) $IMG_FNAME
+install (fd0)/boot/grub/stage1 (fd0) (fd0)/boot/grub/stage2 p (fd0)/boot/grub/menu.txt
+quit
+EOT
+}
+
+
+
+#################################################
+## Real start
+##
+#[ "$#" -lt 3 ] && print_usage
+
+lookup_grub
+
+dest="$1" ; shift
+loader_fname="$1" ; shift
+options="$1" ; shift
+modules="$*"
+
+# Init destination disk
+case x$dest in
+ x*:)
+ drive=$dest
+ IMG_FNAME=$dest
+ FLOPPY_DRIVE=$dest
+ init_floppy
+ ;;
+ x*)
+ drive=U:
+ IMG_FNAME=$dest
+ init_image
+ ;;
+esac
+
+# Create directory structure
+setup_disk $drive
+
+# Copy the loader
+mcopy -bo $loader_fname $drive/system/`basename $loader_fname`
+
+# Generate the menu.txt file
+rm -f menu.txt
+cat <<EOF > menu.txt
+timeout 0
+default 0
+title Simple OS
+root (fd0)
+kernel /system/`basename $loader_fname` $options
+EOF
+
+# Copy the modules
+for f in $modules ; do
+ if [ ! -f $f ] ; then
+ echo "ERROR: module $f not correctly compiled in."
+ exit 1
+ fi
+ if ! mcopy -bo $f $drive/modules/`basename $f` ; then
+ echo "ERROR: module $f could not be transferred to floppy."
+ exit 1
+ fi
+ echo module /modules/`basename $f` >> menu.txt
+done
+
+# Transfers the menu.txt file to floppy
+mcopy -bo menu.txt $drive/boot/grub/
diff --git a/sos-code-article6.75/support/sos.lds b/sos-code-article6.75/support/sos.lds
new file mode 100644
index 0000000..497c9b5
--- /dev/null
+++ b/sos-code-article6.75/support/sos.lds
@@ -0,0 +1,115 @@
+/* Copyright (C) 2003, Thomas Petazzoni
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+
+/* We generate binary in the ELF format */
+OUTPUT_FORMAT("elf32-i386","elf32-i386","elf32-i386");
+
+/* The entry point is _start (defined in boot.S) */
+ENTRY(_start)
+
+/* The architecture is i386 */
+OUTPUT_ARCH("i386")
+
+SECTIONS
+{
+ /* our kernel is loaded at 0x200000 */
+ . = 0x200000;
+ __b_load = .;
+
+ /* the multiboot header MUST come early enough in the output
+ object file */
+ .multiboot :
+ {
+ /* The multiboot section (containing the multiboot header)
+ goes here */
+ *(.multiboot);
+
+ /*
+ * With the following line, we force this section to be
+ * allocated in the output file as soon as possible, no matter
+ * when the file containing the multiboot header (multiboot.S)
+ * is compiled. This is to conform to the multiboot spec, which
+ * says "The Multiboot header must be contained completely
+ * within the first 8192 bytes of the OS image, and must be
+ * longword (32-bit) aligned."
+ */
+ LONG(0);
+ }
+
+ /* Defines a symbol '__b_kernel to mark the start of the kernel
+ code/data */
+ . = ALIGN(4096);
+ __b_kernel = .;
+
+ /* Beginning of the text section */
+ .text ALIGN(4096) :
+ {
+ /* This section includes the code */
+ *(.text*)
+ /* Defines the 'etext' and '_etext' at the end */
+ PROVIDE(etext = .);
+ PROVIDE(_etext = .);
+ }
+
+ /* Beginning of the data section */
+ .data . :
+ { *(.data*)
+ PROVIDE(edata = .);
+ PROVIDE(_edata = .);
+ }
+
+ /* Beginning of the read-only data section */
+ .rodata . :
+ { *(.rodata*)
+ PROVIDE(erodata = .);
+ PROVIDE(_erodata = .);
+ }
+
+ /* We take note of the end of the data to load */
+ __e_load = .;
+
+ /* Beginning of the BSS section (global uninitialized data) */
+ .bss SIZEOF(.rodata) + ADDR(.rodata) :
+ { *(.bss)
+ *(COMMON)
+
+ /* We put the stack of the bootstrap thread on a page
+ boundary, because it can be un-allocated later */
+ . = ALIGN(4096);
+ *(.init_stack)
+
+ PROVIDE(ebss = .);
+ PROVIDE(_ebss = .);
+ }
+
+ /* We take note of the end of the kernel: this is where the GPFM
+ will begin */
+ __e_kernel = .;
+
+ /* We don't care of the note, indent, comment, etc.. sections
+ generated by gcc */
+ /DISCARD/ :{
+ *(.note*)
+ *(.indent)
+ *(.comment)
+ *(.stab)
+ *(.stabstr)
+ }
+
+}
+
diff --git a/sos-code-article6.75/userland/Makefile b/sos-code-article6.75/userland/Makefile
new file mode 100644
index 0000000..35fd0e3
--- /dev/null
+++ b/sos-code-article6.75/userland/Makefile
@@ -0,0 +1,82 @@
+## Copyright (C) 2005 David Decotigny
+##
+## This program is free software; you can redistribute it and/or
+## modify it under the terms of the GNU General Public License
+## as published by the Free Software Foundation; either version 2
+## of the License, or (at your option) any later version.
+##
+## This program is distributed in the hope that it will be useful,
+## but WITHOUT ANY WARRANTY; without even the implied warranty of
+## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+## GNU General Public License for more details.
+##
+## You should have received a copy of the GNU General Public License
+## along with this program; if not, write to the Free Software
+## Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+## USA.
+
+CC=gcc
+AR=ar
+CFLAGS = -Wall -nostdinc -ffreestanding -I. -I..
+LDFLAGS = -Wl,--warn-common -nostdlib -Wl,-Tldscript.lds
+
+# Main target
+all: userprogs.kimg
+
+-include .mkvars
+
+
+PWD := $(shell pwd)
+
+# Programs generation
+$(PROGS):
+ $(CC) -static $(LDFLAGS) -o $@ $^
+
+# Generation of the libC
+libc.a: libc.o
+
+# Create a program image to be integrated into the Kernel
+userprogs.kimg: $(PROGS)
+ @echo "# Generating ELF images for inclusion into the kernel image: $@"
+ @echo "SECTIONS { .rodata . : { " > .userprogs.lds
+ @i=0 ; \
+ for f in $^ ; do \
+ i=`expr $$i + 1` ; \
+ echo "extern char _begin_userprog$$i, _end_userprog$$i;" \
+ > .userprog$$i.c ; \
+ echo "char *_userprog"$$i"_entry[]" >> .userprog$$i.c ; \
+ echo " __attribute__((section(\".userprogs_table\")))" \
+ >> .userprog$$i.c ; \
+ echo " = { \"$$f\", &_begin_userprog$$i, &_end_userprog$$i };" \
+ >> .userprog$$i.c ; \
+ $(CC) $(CFLAGS) -c .userprog$$i.c -o .userprog$$i.o ; \
+ objcopy --add-section .userprog$$i=$$f .userprog$$i.o \
+ .userprog$$i.kimg ; \
+ echo " _begin_userprog$$i = .;" >> .userprogs.lds ; \
+ echo " .userprog$$i.kimg(.userprog$$i);" >> .userprogs.lds ; \
+ echo " _end_userprog$$i = .;" >> .userprogs.lds ; \
+ echo " .userprog$$i.kimg(.rodata); .userprog$$i.kimg(.data);" \
+ >> .userprogs.lds ; \
+ done
+ @echo " _userprogs_table = .; *(.userprogs_table) ; LONG(0);" \
+ >> .userprogs.lds
+ @echo "} /DISCARD/ : { *(.text) *(.data) *(.bss) } }" \
+ >> .userprogs.lds
+ @ld -r -o $@ -T.userprogs.lds
+
+# Create libraries from object files
+%.a:
+ $(AR) rcv $@ $^
+
+# Create objects from C source code
+%.o: %.c
+ $(CC) -I$(PWD) -c $< $(CFLAGS) -o $@
+
+# Create objects from assembler (.S) source code
+%.o: %.S
+ $(CC) -I$(PWD) -c $< $(CFLAGS) -DASM_SOURCE=1 -o $@
+
+# Clean directory
+clean:
+ $(RM) *.o *.a *~ $(PROGS) *.kimg
+ $(RM) .userprog*
diff --git a/sos-code-article6.75/userland/ldscript.lds b/sos-code-article6.75/userland/ldscript.lds
new file mode 100644
index 0000000..b0ee954
--- /dev/null
+++ b/sos-code-article6.75/userland/ldscript.lds
@@ -0,0 +1,74 @@
+/* Copyright (C) 2005, David Decotigny
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ USA.
+*/
+
+/* We generate binary in the ELF format */
+OUTPUT_FORMAT("elf32-i386","elf32-i386","elf32-i386");
+
+/* The entry point of the program is _start (defined in crt.c) */
+ENTRY(_start)
+
+/* The architecture is i386 */
+OUTPUT_ARCH("i386")
+
+SECTIONS
+{
+ /* our program is loaded at 2G */
+ . = 0x80000000;
+
+ /* Beginning of the text section */
+ .text :
+ {
+ /* This section includes the code */
+ *(.text*)
+ /* Defines the 'etext' and '_etext' at the end */
+ PROVIDE(etext = .);
+ PROVIDE(_etext = .);
+ }
+
+ /* Beginning of the data section */
+ .data . :
+ { *(.data*)
+ PROVIDE(edata = .);
+ PROVIDE(_edata = .);
+ }
+
+ /* Beginning of the read-only data section */
+ .rodata . :
+ { *(.rodata*)
+ PROVIDE(erodata = .);
+ PROVIDE(_erodata = .);
+ }
+
+ /* Beginning of the BSS section (global uninitialized data) */
+ .bss SIZEOF(.rodata) + ADDR(.rodata) :
+ { *(.bss)
+ *(COMMON)
+ PROVIDE(ebss = .);
+ PROVIDE(_ebss = .);
+ }
+
+ /* We don't care of the note, indent, comment, etc.. sections
+ generated by gcc */
+ /DISCARD/ :{
+ *(.note*)
+ *(.indent)
+ *(.comment)
+ *(.stab)
+ *(.stabstr)
+ }
+}