"Some" about the box - Computer

Kernel Debugging

2012-02-06T03:34:00.000-08:00


[Ref: http://publib.boulder.ibm.com/infocenter/aix/v6r1/index.jsp?topic=%2Fcom.ibm.aix.kdb%2Fdoc%2Fkdb%2Fkdb.htm]


kdb command: This command is implemented as an ordinary user-space program and is typically used for; post-mortem analysis of a previously-crashed system by using a system dump file. The kdb command includes subcommands specific to the manipulation of system dumps.

KDB kernel debugger
- The KDB kernel debugger is integrated into the kernel and allows full control of the system while a debugging session is in progress. The KDB kernel debugger allows for traditional debugging tasks such as setting breakpoints and single-stepping through code.
- KDB needs to be enabled when the system boots.
- To check if the KDB is enabled or not, issue
$> bosdebug -L
Memory debugger           off Memory sizes              0 Network memory sizes      0 Kernel debugger           off Real Time Kernel          off Backtracking fault log    on Kernext Memory Tracking   off

- To create a kernel image with KDB enabled, issue
$> bosdebug -D
This will turn on the kernel debugger. You need to bosboot and reboot in order to take this effect.

$> bosboot -a && reboot
[After of about 20-30 mins, you will have a KDB enabled image}
bosboot: Boot image is 49180 512 byte blocks.
- KDB enabled kernel image is ready. All you gotto do now is, reboot.
If you have HMC kinda machine (where you remotely try to reboot the machine), while booting, you can see Kernel Debugging is enabled.
$> reboot
------------------------------------------------------------------------------- Welcome to AIX. boot image timestamp: 11:02:54 12/26/2011 The current time and date: 11:18:52 12/26/2011 processor count: 1; memory size: 2048MB; kernel size: 28147575 boot device: /vdevice/v-scsi@30000003/disk@8100000000000000:2 kernel debugger setting: enabled -------------------------------------------------------------------------------

One color/partial color photo

2012-02-04T03:20:00.001-08:00

http://graphicssoft.about.com/od/gimp/ss/partialcolor_8.htm

Sample vimrc file

2011-10-11T05:02:00.000-07:00

set nocompatible

set backspace=indent,eol,start

set nobackup
set showcmd

set ts=3 sw=3 smarttab
set expandtab
set incsearch
set hlsearch
set nowrap

set cb=exclude:.*
syntax enable

source /opt/freeware/share/vim/vim71/syntax/syntax.vim
source /home/harishse/.vim/plugin/taglist.vim
source /home/harishse/.vim/plugin/comments.vim
source /home/harishse/.vim/plugin/supertab.vim
source /home/harishse/.vim/plugin/surround.vim
source /home/harishse/.vim/plugin/SearchComplete.vim
source /home/harishse/.vim/plugin/NERD_tree.vim
"Below lines are required if you want nerd tree to be opened automatically
"autocmd VimEnter * NERDTree
"autocmd BufEnter * NERDTreeMirror
"autocmd VimEnter * wincmd w

map <C-E> :NERDTree<cr>
map <C-P> :pwd<cr>
map <C-v><C-v> : vs<cr>
map <C-q> :q<cr>

let &t_Co=256
let &t_Sf="\<Esc>[3%dm"
let &t_Sb="\<Esc>[4%dm"

hi Search cterm=bold ctermfg=black
hi Constant cterm=bold ctermfg=red

set tabstop=4
set shiftwidth=4
set formatoptions+=r

set nu
set showmatch
set smartindent
filetype plugin on

To find out the location of the missed calls you got

2011-06-09T00:18:00.001-07:00

http://site3.way2sms.com/jsp/LocateMobile.jsp

Socket Programming - Part 1

2011-03-24T04:43:00.000-07:00

Reference: http://www.tenouk.com/cnlinuxsockettutorials.html

Port Numbers

16 bit integers
So a maximum port numbers are 2^16 = 65536 (0 to 65535)
Unique with a machine/IP address
Each service/application/daemon will have their own port number
Required to make a connection (along with its host IP address)

Server & Client Port Numbers

Connection is defined by: (Server IP and Port number) + (Client IP and port number)
Server Port numbers are low numbers in the range 1 - 1023 (called as WELL KNOWN PORT NUMBER)
Accessible only by Administrators (roots, in linux)
Used for authentication
A server running on a well-known port lets the OS know what port it wants to listen on
Normally, client port numbers are higher number starting at 1024
Client normally simples lets the OS picks a new port that is not already in use.

Background and Foreground Process

2011-03-07T01:45:00.000-08:00

1. When you run a command (process), you can make it to run as a background process using $<cmd> &
2. If you forget to make that command as background, and if you feel you should do it now, then
- Press CTRL+Z (Suspend that process)
- $> bg disown 1 (make that process to be a background
3. Now if you want to check the list of background processes, type $> jobs
4. If you want to bring the background process to foreground, then type
$> fg %1
Again to make it a background process,
$> bg %1

When properties screwed up

2011-02-07T05:09:00.000-08:00

When Properties got screwed up in Visual Studio 2005/2008, in the cmd, type "devenv /resetskippkgs".
It will get you the default properties (color, font etc) for your editor.

Late/Dynamic Binding in C++

2010-08-25T12:39:00.000-07:00









Late Binding using Function Pointers (C)

Locks in Multi-processing/multi-thread programming

2010-08-24T21:59:00.000-07:00

DeadLock:
A deadlock is a situation wherein two or more competing actions are each waiting for the other to finish, and thus neither ever does.

LiveLock:

A livelock is similar to a deadlock, except that the states of the processes involved in the livelock constantly change with regard to one another, none progressing. Livelock is a special case of resource starvation; the general definition only states that a specific process is not progressing.

A real-world example of livelock occurs when two people meet in a narrow corridor, and each tries to be polite by moving aside to let the other pass, but they end up swaying from side to side without making any progress because they both repeatedly move the same way at the same time.

Livelock is a risk with some algorithms that detect and recover from deadlock. If more than one process takes action, the deadlock detection algorithm can repeatedly trigger. This can be avoided by ensuring that only one process (chosen randomly or by priority) takes action.

I2C protocol

2010-08-24T11:42:00.003-07:00

http://www.i2cbus.com/theprotocol.html

new/delete operator

2010-08-24T11:11:00.000-07:00

1. Return type of delete operator is void (not void*)

2. Exception and valid cases

char *p;

delete p; ==> exception (shown in picture)

Where as
char *p = 0;
delete p; .==> You can, however, use delete on a pointer with the value 0. This provision means that, when newreturns 0 on failure, deleting the result of a failed new operation is harmless.

2. Mixing both new/malloc and delete/free

class A {
public:
   A() { cout << "Constructor" << endl;
   ~A() { cout << "Destructor" << endl;
};

int main() {
  A *a = new A;
  free(a); ==> Calls only constructor; not destructor

A *b = (A*)malloc(sizeof(A));
delete b; ==> Calls only destructor; not constructor

A *c = new A;
delete c; ==> Calls both constructor and destructor
}

GDB unknown commands

2010-06-21T04:32:00.000-07:00

All in gdb> prompt

1. Ctrl + p => To get the previous command
2. p array@sizeof(array) => To print all the array elements
3. set print pretty on => To print the structure elements' values in a neat way
4. p /x => prints the value in hexa decimal format

How the linux commands are processed

2010-06-01T02:46:00.001-07:00

http://fog.ccsf.cc.ca.us/~gboyd/cs260a/online/terminals/characters.html

Perl Tutorial

2010-04-01T01:44:00.001-07:00

http://www.comp.leeds.ac.uk/Perl/basic.html - good one

VI keyboard Shortcuts

2010-03-30T06:48:00.001-07:00

:set hlsearch (:nohl)

:set mouse=a

:set nocompatible

:set smartindent

:set nowrapscan (to disable the wrap search)

:highlight String ctermfg=red

:highlight search ctermfg=black

To indent a block of code, keep the cursor in any of the {} braces, and do =%
To comment a block of line, keep the cursor in the first line (from where you want to comment),

   - press CTRL + v (to enter visual mode)
   - use UP DOWN arrows (or j/k keys) to select the lines
   - press I (shift + i) (this enters into visual mode)
   - type "//"
   - Once you press ESC, the // will be applied to all the lines you selected.

To uncomment a block of code, keep the cursor in the first line (from where you want to uncomment)

   - press CTRL + v (to enter visual mode)
   - select RIGHT LEFT arrows to select only the "//" characters
   - press "d" (to delete all the // characters)

To search and replace a text ("src" to "dest"), use

:%s/src/dest/ ==> Replaces first occurence of "src" in each line

:%s/src/dest/g ==> Replaces all the occurences of "src" with "dest" in all the lines

:%s/src/dest/gc ==> Asks for confirmation to replace or not for each occurence

Vimdiff commands:

]c - to go to the next change
[c - to go to the previous change
do - diff obtain; means get the changes from other file
dp - diff put; means put the changes into other file

Putty with Tabs (Putty Connection Manager)

2010-03-28T22:58:00.001-07:00

http://lifehacker.com/351503/add-tabs-to-putty-with-putty-connection-manager

Emacs Keyboard shortcuts

2010-03-26T02:10:00.000-07:00

Movements:

M - f <==> Move forward by one word
M - b <==> Move backward by one word

C - f <==> Move forward by one letter
C - b <==> Move backward by one letter
C - p <==> Move up by one line
C - n <==> Move down by one line

M - v <==> PAGE UP
C - v <==> PAGE DOWN

M - > <==> Goto end of the file (U have to press "SHIFT" here to enter "<" )
M - < <==> Goto the beginning of the file (same as above)

File operations:

C - x C- f <==> To open a file
C - x k <==> Close the current buffer (kill buffer)

M - d <==> Delete next word
C - k <==> Delete current line
C - y <==> Paste (watever copied)

C - [space] <==> Start marking the portion
C - w <==> Cut the portion till the cursor is in currently
M - w <==> Copy the portion till the cursor is in currently

C - x u <==> Undo last operation

M - g g <==> Goto the line

M - x replace-string

<==> Search and replace

C - s [string] <==> To search a string forward
C - r [string] <==> To search a string backward

Windows:

C - x 0 <==> Close the current window
C - x 1 <==> Close all the windows except current window
C - x 2 <==> Split the current window vertically (means top and bottom)
C - x 3 <==> Split the current window horizontally (means left and right)
C - x o ('o' for 'others') <==> Switch between windows

Shell:

M -x shell <==> Open shell (terminal)

Setting Tab Size:

M - x set-variable [ENTER] c-basic-offset [ENTER] 8 <==> Setting tab size to 8

Auto-Indentation:

M -x indented-text-mode <==> set auto indent (does not work through putty)

To search for a string in all the files in a directory:

M - x grep-find [Enter] <==> This will generate a command; at the end of the command, give the string you want to search; and also set the directory in which you wana search

EMACS & SQL links

2010-03-25T03:49:00.001-07:00

Emacs:
- http://www.math.uh.edu/~bgb/emacs_keys.html
- http://xahlee.org/emacs/emacs_unix.html (good one)

SQL:
- http://www.w3schools.com/sql/default.asp

Theme for Visual Studio 2008

2010-03-19T03:57:00.001-07:00

http://www.hanselman.com/blog/VisualStudioProgrammerThemesGallery.aspx

Links

2010-03-18T05:06:00.001-07:00

http://www.catch22.net/tuts/kernel101

Basics

2010-03-18T04:24:00.000-07:00

Courtesy: http://en.wikipedia.org/wiki/Device_driver

Device Driver
- an extension of OS
- a "bridge" between hardware and applications (and Operating Systems)
- abstracted into logical and physical layers (and hence can be categorized as Logical Device Drivers (LDD) and Physical Device Drivers (PDD))
- LDD written by OS vendors where as PDD written by device vendors

An attempt by Microsoft to reduce system instability due to poorly written device drivers by creating a new framework for driver development called "WINDOWS DRIVER FOUNDATION (WDF)".

WDF - includes UMDF (User Mode Driver Framework) and KMDF (Kernel Mode driver Framework)

1. UMDF - implements a message-based protocol for communicating with their devices - as user mode drivers.
- any malfunction on these drivers does not cause any system instability

2. KMDF - allows development of kernel-mode device drivers, but attempts 2 provide std implementations functions that are well known to cause probs, including cancellation of IO operations, power management, and PnP device support

Device Drivers on Windows, can run on *both Ring 0 and Ring 3*

How to enable the chat logging feature in MOC (microsoft ofc communicator)

2010-03-15T01:53:00.000-07:00

Courtesy: http://hosting.intermedia.net/support/kb/default.asp?id=1406

C-States

2010-01-05T23:05:00.000-08:00

- Internal CPU Clock signal is stopped
- BIU and APIC are still fed with internal Clock Generator to allow the CPU to temporarily exits the HLT state
- Since CPU temporarily “leaves” the HALT state, this state is called as “Stop Clock Snoop State” or “HALT/Grant Snoop State” or “Snoop State”

Intel C1E

- Exactly similar to C1; but reduces the internal CPU voltage as well
- If this is enabled in BIOS, the CPU will enter this mode instead of “traditional” C1 state on executing HLT instruction
- Also called as Extended Halt/Stop Grant Snoop State”

AMD C1E

- Works just like C3 (shutting down all CPU clocks – both internal and external)
- Processor enters C1E state when this option is enabled in BIOS AND all CPU cores enter the regular C1 (HLT) state.
- The diff between C1E and C3 is basically how the CPU enters the Sleep state:
- While on traditional C3 state, CPU must be put in that state usually by a command from the OS
- Where as on C1E, the CPU enters the Sleep state automatically when all cores are at HLT (C1) state

- Intel - Introduced by adding one extra pin to CPU called “STPCLK” (Stop Clock)
- AMD - C2 state is entered by simply reading a register from the ACPI, circuit that is physically located on the chipset;
- When this pin is asserted, the CPU core clock is cut
- As you can notice, both C1 and C2 cuts the CPU core clock; the diff is in how the CPU achieves this
- C1 is activated by software (HLT instruction) while C2 is activated by hardware (by sending a signal to CPU pin “STPCLK)
- Two modes

o Stop Grant

§ As explained above; CPU core clock is stopped but the clock generator chip (also know as PLL) is still active and generating the external bus reference clock i.e., CPU external clock

o Stop Clock

§ Here the Clock Generator itself is turned off and thus the external clock generator chip would be turned off, thus saving more energy

§ Current CPUs don’t have this Stop Clock mode inside C2 state but on the C3 Deep Sleep State

C2E

- Similar to C2; but reduces the CPU voltage besides stopping the CPU internal clock

- Also known as “Sleep” state
- Both BIU and APIC clocks will be cut off (which means it cant answer to important requests coming from CPU external bus or interruptions)
- C3 implementation on Intel

o Given an extra pin called SLP (or DPSLP depending on CPU model) which must be activated when the CPU is in C2 state in order to switch the CPU into C3 state

o So first STPCLK pin must be activated and then one should activate the SLP pin

o Achieving the Deep Sleep state is achieved by simply cutting the “external clock signal”

- C3 implementation on AMD

o Achieved by simply reading a register from ACPI, circuit that is physically located on the chipset (P_LVL3) in the Processor control Block (P_BLK)

- Two modes

o Sleep – as explained above

o Deep Sleep (pin is DPSLP instead SLP) – achieved by simply cutting the “external clock signal”

o AltVid – allows reduction on CPU voltage while they are in C3 mode

- Note: AMD C1E and C3 (Sleep State; not the Deep Sleep state) are similar

- Also known as Deeper Sleep State
- Since on C3, all clock signals inside the CPU are stopped, there is no other way to save power by playing with CPU clock signals. The next step on reducing the CPU idle power is to reduce the CPU voltage (Power = VI)
- Intel – C4 is achieved from C3 i.e., CPU must first enter C3 and then, from there, it can reduce its internal voltage

C4E

- C4 + CPU voltage is reduced even more after the L2 memory cache has been disabled (some calls this C5 which is not the real name of this mode)

- Also known as Deep Power Down
- When CPU enters this state, it saves its entire architectural state inside a special static (intel) or DRAM (which is fed from an independent power source)
- This allows the CPU internal voltage to be lowered to any value, *including 0V*
- When the CPU is waked up, it loads the previous state of all internal units from its special static RAM (waking up CPU from this state takes a lot longer)
Notice that there is only one voltage line for the entire CPU( the only component with a different voltage source is the above mentioned static or DRAM where the entire architectural state is stored) and lowering or turning off the CPU voltage is an all-or-nothing kind of deal; if you turn off the CPU, you have to turn off it entirely when it goes into C6 mode

System Call - Good Man page

2010-01-03T21:29:00.001-08:00

http://www.stwikipedia.org/teaching/2105CIT/cgi-bin/man.cgi?system

Unlocker

2009-12-14T22:09:00.001-08:00

http://download.cnet.com/Unlocker/3000-2248_4-10493998.html
The application removes file-access restrictions that prevent a user from moving, deleting, or renaming a file. The user right-clicks on a file and selects Unlocker, which displays information regarding the selected file, such as Path Locked, PID, Handle, and Process Path

Free SMS

2009-09-10T07:20:00.001-07:00

http://www.160by2.com
http://www.way2sms.com

Stack Operation

2009-09-09T03:07:00.000-07:00

http://www.tenouk.com/Bufferoverflowc/Bufferoverflow3.html (good)
http://abrickshort.wordpress.com/2005/04/10/how-function-calls-work/ (OK)

Setting Default OS to boot in Vista and Windows 7

2009-09-04T02:15:00.000-07:00

To set the default OS (in case of dual boot Windows OS) to be either Vista or Windows 7, do the following
1. Click "My Computer" - > Properties (You can also go here from "Control Panel"->"System")

2. Click on "Advanced System Settings" on the left side panel (This will open "Advanced" tab in "System Properties" dialog)

3. Click on "Settings" of "Startup and Recovery" group

4. Select the "Default Operating System" in "System Startup" group

Cannot open Control Panel or My Computer Properties

2009-09-04T02:10:00.000-07:00

If you are using Vista or Windows 7, and if when you try to open Control Panel or "My Computer"->Properties, sometimes it wont open it. It appears to be loading for few seconds and after that it wont load.
This is due to the corrupted .cpl files.

To resolve this issue, do the following

1. Type "services.msc" in the run command
2. Restart "Software Licensing" service

Now you should be able to open the Control Panel and My Computer Properties.

Socket Programming - ASYNCHRONOUS

2009-09-03T12:01:00.000-07:00

What is Asynchronous Socket Programming?

"Event-driven" programming or "select()" based multiplexing
A concept of "handling" multiple connections in "single thread/process"

When do we need this?

Assume you have to write a server that will be "hit" by "n" number of clients with some requests
You would prefer any of the follow

synchronous: you handle one request at a time, each in turn.
pros: simple
cons: any one request can hold up all the other requests
fork: you start a new process to handle each request.
pros: easy
cons: does not scale well, hundreds of connections means hundreds of processes.
fork() is the Unix programmer's hammer. Because it's available, every problem looks like a nail. It's usually overkill
threads: start a new thread to handle each request.
pros: easy, and kinder to the kernel than using fork, since threads usually have much less overhead
cons: your machine may not have threads, and threaded programming can get very complicated very fast, with worries about controlling access to shared resources.

The best solution would be "select" system call.

How "select" works?

The normal heirarchy of socket programming calls in the server side would be "socket()->bind()->listen()->accept()".
If you notice, here "accept" is the blocking call. In order to avoid this blocking stuff, we use "select" which will "run" through all the connected sockets to check if there are any requests pending for "reading, writing or error conditions".
If any requests pending, "select" will return the number of requests pending to be processed.
Hence the heirarchy would be "socket()-> bind()->listen()->select()->accept()"
But here the disadvantage is that, we need to iterate through all the "connections" (descriptors) connected to check "Are you the one with pending requests?" questions.

To diable Firewall

2009-09-03T11:16:00.000-07:00

1. Run "services.msc" in command prompt

2. Go to "Windows Firewall"

3. Right click - > Properties. Then you stop it.

4. Then you "disable" it in the startup type and then exit.

Socket Programming

2009-09-02T10:16:00.000-07:00

SOCKET:

http://www.security-freak.net/sockets/socket-programming.html (best- video)

http://beej.us/guide/bgnet/output/html/singlepage/bgnet.html (best - tutorial)

http://squirl.nightmare.com/medusa/async_sockets.html (good - tutorial)

CPU Architecture:
http://74.125.153.132/search?q=cache:s9SPwQo-mc0J:afis.ucc.ie/tbutler/IS3313%2520Lecture%2520Notes/Lecture%25202%2520Basic%2520CPU%2520Architectures.doc+internal+logic+in+the+CPU&cd=8&hl=en&ct=clnk&gl=in
http://homepage.cs.uri.edu/faculty/wolfe/book/Readings/Reading04.htm

Computer Memory
http://computer.howstuffworks.com/computer-memory3.htm

Glibc, SVN and Qt

2009-09-02T06:59:00.001-07:00

SUSE:

QT4: http://www.linuxfromscratch.org/blfs/view/svn/x/qt4.html

Installation Guidelines: http://doc.trolltech.com/4.4/install-x11.html

SVN:

REDHAT and FEDORA

GLIBC-3.4.9 (64-bit): http://rpm.pbone.net/index.php3/stat/4/idpl/12189689/com/libstdc++-4.4.0-0.20.x86_64.rpm.html

GLIBC-3.4.9(32 bit): http://rpm.pbone.net/index.php3?stat=26&dist=32&size=321482&name=libstdc%2B%2B-4.4.0-0.20.i586.rpm

unresolved external symbol

2009-09-02T02:47:00.000-07:00

unresolved external symbol __imp___CrtDbgReportW:

1. When u get this error, go to visual studio project settings -> C/C++ ->
Code Generation -> RunTime Library has the "debug" enabled (ex: Multi Threaded Debug DLL).
If not enabled, enable it and rebuild again.

2. Also check if Linker->Debugging->Generate Debug Info is on or not

Good Quotes

2009-08-16T07:24:00.000-07:00

“It’s supposed to be hard; if it wasn’t hard everyone would do it. The hard is what makes it great.” -- Tom Hanks
"Being in the right place at the right time won’t make you a success – unless you’re ready. The important question is: Are you ready?” -- Johnny Carson
If at first you dont' succeed, cal it version 1.0
If you are willing to admit faults, you have one less fault to admit

Mentioning Library path for .lib (s)

2009-08-13T22:27:00.000-07:00

If you have dependency on some .libs, you cannot specify this path of .libs in "Include" path of your project. In order to specify the path, you need to specify the path of .libs in "Linker" as shown, in "Additional Library Directories" of General Category.

Changing the user name while inserting comment

2009-08-13T01:37:00.000-07:00

1. Go to Review Tab.

2. Select the "Track Changes" combo

3. Select "Change User Name"

4. In the "Popular" page, at the bottom you wud find "Initials". Enter your initials there.

Data Execution Prevention (DEP)

2009-07-19T12:36:00.000-07:00

DEP is a security feature included in modern Microsoft Windows OS that is intended to prevent an application or service from executing code from a non-executable memory region.

It is a system-level memory protection feature that is built into OS starting with Windows XP and Windows Server 2003.

DEP enables the system to mark one or more pages of memory as non-executable. Marking memory regions as non-executable means that code cannot be run from that region of memory, which makes it harder for the exploitation of buffer overruns (buffer overflow). It is a set of hardware and software technologies that perform additional checks on memory to help protect against malicious code exploits.

This level of pagin has been introduced with AMD64 (the ability to indicate that code should not be executed from a page or a set of pages by setting NX bit = 1; this is 63rd bit in 64-bit entry in the page table)
This feature is enabled if NO execute bit in Enable Feature Extended Register (EFER.NXE) and the PAE in CR4 are set, regardless of operating mode (this is because x86's original 32-bit page table format obviously has no bit 63)

Modes of Enforcement

Hardware Enforcement: Achieving this DEP using NX bit (bit number 63) of a 64-bit Page Translation Entry. It marks all memory locations in a process as non-executable unless the location explicitly contains executable code. There is a class of attacks that attempt to insert and execute code from non-executable memory locations. DEP helps prevent these attacks by intercepting them and raising an exception.
Software Enforcement: System software (kernel) can mark pages used for program stacks and data sections as non-executable.

Processor-corresponding features

AMD: Enhanced Virus Protection (EVP in AMD64)
Intel: Execute Disable (XD in EM64T)

Page State

2009-07-19T06:43:00.000-07:00

Any page in VAS (PAS) of a process can be in one of the three states.

Committed: A page state of a page which is mapped to a page frame in physical memory (or to a page-sized entry in a file on disk)
Reserved: A page state of a page which been set aside for future use so that it cannot be re-used for any other purpose within the process, but has no associated physical page storage
Free: A page state of a page which is available to be reserved

Copy-On-Write

2009-07-18T10:54:00.000-07:00

Copy-On-Write (COW)

optimization strategy used in computer systems
Idea is that if multiple callers ask for resources, they can all be given pointers to the same resource. Now, all "callers" (processes) will be in assumption that "I m holding this X resource; and I can do whatever I want". But, when this "caller" tries to modify its so - called "My resource X", a true private copy is created actually, to prevent the changes becoming visible to other "callers".
Hence, the primary advandage is that if a caller never makes any modifications, *NO PRIVATE COPY IS CREATED*.

In Virtual Memory:

COW finds its main-use in virtual memory OS; when a process creates a copy of itself (fork), the pages in memory that might be modified by either the process or its copy, are marked "Copy-On-Write".
When one process modifies the memory, the OS kernel intercepts the operation and copies the memory so that changes in one process's memory are not visible to other

COW and MMU

COW can be implemented by telling MMU that certain pages in the process's address space are read only.
When data is written to these pages, MMU raises an exception which is handled by kernel, which allocates new space in physical memory and makes the page being written to correspond to that new location in physical memory

Basics of Memory Management

2009-07-18T10:32:00.000-07:00

Memory Manager:

Implements virtual memory, provides a core set of services such as memory mapped files, copy-on-write memory, large memory support and underlying support for the cache manager.

(For details on Copy-on-Write http://spot-myblog.blogspot.com/2009/07/copy-on-write.html)

Each process on a 32-bit Windows OS has a virtual address space (PAS) of 4GB (It is 8TB for a process in 64-bit Windows). Threads cannot access memory that belongs to another process, which protects a process from being corrupted by another process.

VAS (PAS):

VAS for a process is the set of virtual memory addresses that it can use. The address space of a process P1, cannot be accessed by other process(es) P2, *unless it is shared*.
This PAS does not represent the actual physical location in memory; instead the system maintains a Page Table for each process (an internal data structure used to translate VA to PA). Each time a thread references an address, the system translates the VA to PA.
VAS for 32-bit (Windows) process is divided into two partitions; one for process itself and the other for kernel. Default partition will be 2GB:2GB (0x00000000 - 0x7FFFFFFF: 0x80000000 - 0xFFFFFFFF). If 4GT (4GB Tuning) is enabled, then it will be 3GB:1GB (0x00000000 - 0xBFFFFFFF: 0xC0000000 - 0xFFFFFFFF).
After 4GT, the process that has IMAGE_FILE_LARGE_ADDRESS_AWARE flag set in its image header will have access to the additional 1GB of memory above the low 2GB.

IMPORTANT NOTE:

We can adjust the VAS of 32-bit process, using the following command, which sets a boot entry option that configures the size of the partition that is available for use by the process to a value between 2048 MB (2GB) and 3072 MB(3GB).

BCDEdit /set increaseuserva <XYZ Megabytes>

after which, partition would be like (0x00000000 - XYZ: XYZ+1 - 0xFFFFFFFF).

Working Set:

The subset of VAS of a process that resides in physical memory is known as "Working Set"
If the thread of a process attemt to use more physical memory than is currently available, the kernel, "pages" (swaps) some of the memory contents to disk (the total amount of VAS available to a process is limited by physical memory and the free space on disk available for the paging file)
Physical storage and the VAS of each process are organized into "pages", units of memory, whose size depends on the host computer (usually 4 KB for x86 computers - Use GetSystemInfo API to get the page size)
When a thread needs space in RAM, the kernel moves the "least recently used" pages in RAM to paging file in disk.
When a thread references a page that is not a part of Working Set (means not present in main memory, a "page fault"(called Page Exception) occurs, on which Kernel's Page Fault Handler attempts to resolve the page fault (by "Demand Paging") and if it succeeds, the page is added to the working set.
Hard Page Fault: Occurs when the demanded page is not on Main Memory
Soft Page Fault: Occurs when the demanded page is on Main memory but in the working set of some other process or if it is demanded for the first time (called "Demand-Zero" fault)
Process can reduce or empty its working set by calling "SetProcessWorkingSetSize" or "EmptyWorkingSet" functions

PS: The details on the page state at http://spot-myblog.blogspot.com/2009/07/page-state.html

DLL - Programming basics

2009-07-14T11:44:00.000-07:00

Points to be noted:

__declspec() : Declares the following class or function to be exported/imported (mainly). For example, __declspec(dllexport) void func() {} implies, func() is exported for applications use
Wondering, when my app could not able to get the handle of exported APIs when the .h file of DLL had the definitions. When i moved the definitions to .cpp file of DLL project, my app could get the handle successfully
If using visual studio, you can use "Pre-Build Event" (under Build Events) to copy the DLL to the app folder
When using LoadLibrary call, due to UNICODE probs, the dll may not get loaded. Hence use _T casting like hHandle = LoadLibrary( _T ( "mydll.dll" ) );
To check the "sections" contained in the DLL, open the Visual Studio command prompt (not the normal windows prompt) and go to the directory which has the dll file, and type dumpbin /exports mydll.dll

===============================

DLL CODE

===============================

* This is .h file of a DLL

#include <windows.h>

/* If we try to export all the APIs to the app by preceding each API with __declspec(dllexport)

* then the corresponding API will always be exported even when app does not require it.

* For this very reason, DLL developer tries to export it from his project, where as the

* app developer, will try to import it in his code. */

#if defined EXPORT_DIR

#define DECLAPI __declspec( dllexport )

#else

#define DECLAPI __declspec( dllimport )

#endif

/* Tell the compiler that its OK to use these APIs in either C or C++ */

extern "C"

{

DECLAPI int addition( int a, int b );

DECLAPI int multiply( int a, int b );

}

* This is .cpp file of DLL project

#include "mydll.h"

/* [Important]: Define this macro to try to export the APIs (even though not catched by apps) */

#define EXPORT_DIR

extern "C"

{

DECLAPI int addition ( int a, int b ) { return a + b; }

DECLAPI int multiply ( int a, int b ) { return a * b; }

}

================================

APP Code

================================

* This is the application which uses the DLLs

#include <iostream>

#include <windows.h>

typedef int ( *Addition ) ( int, int );

typedef int ( *Multiply ) ( int, int );

int main()

{

HINSTANCE hInstance;

Addition additionPtr;

Multiply multiplyPtr;

hInstance = LoadLibrary( _T ( "mydll.dll" ) );

if( hInstance )

{

additionPtr = ( Addition ) GetProcAddress ( hInstance, "addition" );

multiplyPtr = ( Multiply ) GetProcAddress ( hInstance, "multiply" );

if( additionPtr )

printf( "DLL addition called and sum: %d.\n", additionPtr( 10, 5 ) );

if( multiplyPtr )

printf( "DLL multiply called and sum: %d.\n", multiplyPtr( 10, 5 ) );

FreeLibrary( hInstance );

}

else

{

printf( "Failed to load mydll.dll!!!!..\n" );

}

return 0;

}

BIOS Boot Sequence - A Closer Look

2009-07-13T12:44:00.000-07:00

Internal power supply turns on, initializes and then takes few moments to generate reliable power for rest of the system. If power received is not within expectd parameters (by chipset and subsequently processor), then the chipset will generate a reset signal to the processor in the same fashion as you were to touch the reset button. This will continue until motherboard receives "Power Good" signal from power supply
Since processor has no idea on what to do next as there is nothing to execute in memory, it has been designed to look at the same place in the system, the BIOS ROM, for the small bit of startup code to begin the boot process (CS = 0xFFFF and EIP = zero => 0xFFFF0). Since there are 16 bytes (total is FFFFF), this location contains just a "jump" instruction telling the processor where to go to find the real BIOS startup program (see the diagram).
BIOS then performs POST (Power-On Self Test). If there are any fatal errors, the boot process stops. If the POST is successful, the BIOS calls INT 19 (Interrupt 19) and then proceeds to look for devices attached to the motherboard
BIOS enables the video: The BIOS code begins searching by looking for a video card, and video card's built in BIOS program (normally at 0xC000 in memory) and if found, it runs it.
Once video is enabled, the BIOS begins searching for other devices that may have their own ROM and whether ROM has its own BIOS code. Normally, the floppy driver is located at 0000:7c00 and the IDE/ATA HDD BIOS will be found at C8000h. If any of these is found, their codes are executed. If during this INT 19 process, any other device BIOS's are found, they are executed as well
BIOS displays its startup screen, which provides some key information about the BIOS as well as other system information
BIOS then performs some kind of inventory of the hardware installed in the system and then communicates or interrogates it to ensure that the hardware is functioning (at this stage, BIOS will populate BIOS table, can be ACPI table, if the system is ACPI compliant. This table can be used by several purposes including power management, by the OS applications)
During the final phase of POST and BIOS boot process, the BIOS will display a summary screen with your systems' configuration.
NOW, BIOS finishes what it needs to do, it begins searching for a drive to boot an OS. If its searching a hard disk, it looks for a MBR at cylinder 0, head 0 and sector 1, the first sector on the disk. If its searching for Floppy disk, it looks at the same address on the floppy disk for a volume boot sector
Once the boot sector is found, BIOS starts the process of booting OS by using the info in boot sector. If its floppy, the boot sector is also read into memory at 0000:7C00 and then MBR program itself jumps to memory location 0000:7c00 (NOTE: Each OS has its own boot sector format. The next step involves the small program in the boot sector locating the first part of OS's kernel loader proram or in some cases the kernel itself or perhaps a boot manager program, and read then that into memory. In windows, this kernel loader referred to as NTLDR.
If no boot device of any type can be found, the system will display an error message and stop.

NOTE: This entire process is called as "cold boot" (since the machine was off, or cold, when it started). A "warm boot" also known as "soft boot" is the same thing except it occurs when the machine is rebooted using Ctrl+Alt+Del keys. In this case, POST is skipped and boot process continues at roughly step 8 above. As a side note, INT19 is also called when the CTRL+ALT+DEL keys are used.

MBR and its necessary

2009-07-13T11:37:00.000-07:00

1. When you turn on your PC, the processor does not really have anything to execute or even know where to look for it. To ensure that the PC will always boot regardless of BIOS, bot chip and BIOS manufractures developed their code so that the processor, once turned on, always starts executing at the same place, FFFF0h. This magical address is called "reset vector"

(NOTE: Similarly, every hard disk must have a consistent "starting point" where the key information is stored about the disk, such as number of partitions and their types. There also must be someplace where the BIOS can load the initial boot program that starts the process of loading the OS and this place is called Master Boot Record - MBR, also referred to as Master Boot Sector - MBS or even just Boot Sector - BS)

2. MBR is always located at cylinder 0, head 0 and sector 1, the first sector on the disk (512 bytes). When a computer starts and the BIOS boots the machine, it will always look at this first sector for instructions and information on how to proceed with the boot process and load the OS.

3. MBR contains following structures

Master Partition Table (MPT): Small bit of code that is referred to as a table contains a complete description of the partitions that are contained on the HDD. (Alas!!.. when the developers designed the size of this MPT, they left juz enuf room for description of 4 partitions, and hence the four partition [four physical partitions] limit. Any additional partions must be logical partitions that are linked to (or are part of) one of the primary partitions.) One of these partitions is marked as active, indicating that it is the one that the computer should used to continue the boot process
Master Boot Code (MBC): MBC is a small bit of computer code that the BIOS loads and executes to start the boot process. This code, when fully executed transfers control to boot program stored in boot (active) partition to load the operating system (NOTE: MBC is the first program executed when you turn on your PC, and is often the target of a virus)

4. BIOS however, does not care about any of this: it simply loads the contents of the MBR into memory location 0x7c00 and jumps to that location to start executing whatever code is in the MBR.

Traditionally, Microsoft MBR code takes a look at the partition table, finds the (only) partition marked as active, loads the boot sector for that partition, and runs that code. This boot sector is the first sector of a partition, as opposed to the first sector for the whole disk. If something is wrong with the partition table, you would get messages like "Invalid Partition Table" or "Missing Operating System". This message does not come from BIOS but rather from MBR code loaded from disk.

Linux boot loaders LiLo and GRUB (GRand Uniform Boot) loader can handle a wide variety of OSs, file systems and boot configurations. Their MBR code does not necessarily follow the "boot the active partition" approach described above. But functionally the process goes like this:

1. MBR itself contains the first stage of boot loader. GRUB calls this stage 1.

2. Due to its tiny size, the code in MBR does just enuf to load another sector from disk that contains additional bootstrap code. This sector might be the boot sector for a partition, but could also be a sector that was hard-coded into the MBR code when the MBR was installed.

3. MBR code plus code loaded in step 2, then read a file containing the second stage of the boot loader. In GRUB, this is GRUB Stage 2, and in Windows Server, this is C:\NTLDR. If step 2 fails in windows, you 'd get message like "NTLDR is missing". This stage 2 code then reads a boot configuration file (eg., grub.conf in GRUB, boot.ini in windows). It then presents boot choices to the user or simply goes ahead in a single-boot system.

4. At this point, the boot loader code needs to fire up a kernel. It must know enuf about file systems to read the kernel from the boot partition. In Linux, this means reading a file like "vmlinuz-2.6.22-14-server" containing the kernel, loading the file into memory and jumping to the kernel bootstrap code. In Windows Server 2003, some of the kernel start-up code is separte from the kernel image itself and is actually embedded into NTLDR. After performing several initializations, NTLDR loads the kernel image from file C:\Windows\System32\ntoskrnl.exe, just as GRUB does, jumps to kernel entry point.

What is IPMI basic working "algorithm"?

2009-07-06T11:44:00.000-07:00

Block Diagram of IPMI

What is IPMI?

2009-07-06T11:19:00.000-07:00

1. What is "Platform Management"?

Monitoring and control functions that are built in to the platform hardware and primarily used for the purpose of monitoring the health of the system hardware (includes monitoring elements such as System Temperatures, voltages, fans, power supplies, bus errors, system physical security etc)
Inventory, monitoring, logging and recovery functions

2. What is "Intelligent Platform Management (IPM)"?

The above functions available independent of the main processors, BIOS and OS.
Also available when the system is in powered down state.

3. What is "Intelligent Platform Management Interface (IPMI)"?

Hardware level interface specification providing "above" functions, that can be exposed thro' standard management software interfaces such as DMI, WMI, CIM, SNMP etc (see fig below)

More on RPM Files and Spec Files

2009-06-09T05:57:00.001-07:00

http://linuxshellaccount.blogspot.com/2008/03/beginning-your-spec-file-for-building.html

How the EXE is loaded into main memory for execution - The system Program Loader

2009-06-04T03:40:00.001-07:00

Once BIOS hands control over to the OS, you may then request execution of a program.

NOTE: The program can be either .COM or .EXE. A .COM program is useful as a small utility program or as a resident program (one that is installed in memory and is available while other programs run). In real mode, an .EXE program consists of separate code, data and stack segments and is the method used for more serious programs.

When you double click on an .EXE program (when you request the system to load an .EXE program from disk into memory for execution), the System Program Loader performs following steps

Accesses the .EXE program from disk
Constructs a 256-byte (100H) Program Segment Prefix (PSP) on a paragraph boundary in available internal memory (NOTE: PSP is a data structure used in DOS systems to store the state of a program)
Stores the program in memory immediately following PSP
Loads the address of PSP in DS and ES registers
Loads the address of code segment in CS register and sets the IP register to the offset of the first instruction (usually zero) in the code segment
Loads the address of the stack in SS register and sets the SP register to the size of the stack
Transfers control to the program for execution, beginning usually with the first instruction in the code segment

The BIOS Boot Process

2009-06-04T03:29:00.000-07:00

1. Turning on Computers' power causes the processor to enter a reset state, clears all memory locations to zero, perform a parity check of memory and set the CS register to segment address FFFFh and IP register to zero.

2. Hence the first instruction to execute, therefore is at address formed by CS:IP pair, which is FFFF0H, the entry point to BIOS in ROM

3. BIOS routine at FFFF0H checks the various ports to identify and initialize devices taht are attached to the computer and provides services that are used for reading to and for writing from the devices.

4. BIOS then establishes two data areas -

IVT (Interrupt Vector Table): Begins in low memory at location 0 and contains 256 4-bytes address in the form of segment:offset (Both BIOS and OS uses these IVT for interrupts that occur)
BIOS data Areas: Beginning at location 400H, largely concerned with the status of attached devices

5. BIOS next determines whether a disk containing the system files is present and, if so, it accesses the bootstrap loader from the disk

6. This BSP (Boot strap program) loads system files from the disk into memory and transfers control to them (System files contains device drivers and other hardware-specific code which initializes internal system tables and the systems' portion of IVT)

NOTE: When a user program requests an IO services of OS, it transfers request to BIOS, which in turn accesses requested device. Sometimes, program makes requests directly to BIOS, such as keyboard and screen services. At other times, a program can bypass both OS and BIOS to access a device directly

CPU Registers

2009-06-04T02:40:00.001-07:00

CPU registers are classified into five categories as follows

Segment registers
Pointer registers
General Purpose registers
Index registers
Flags register

1. Segment registers

Segments (20-bit wide) are special areas defined in a program for containing the code, the data and stack.
segment begins on a paragraph boundary; that is at a location evenly divisible by 16
segment registers are 16-bit size and contains starting address of the segment (Reason: since segments are starting on a paragraph boundary, the designers decided that it would be unnecessary to store the zero digit in the segment register)
Offset is 16 bits wide (and is specified in Pointer registers described later)
Further classified into Code, data, stack and extra - corresponds to CS, DS, SS, ES, FS and GS registers

2. Pointer registers

Pointer registers are 32-bit EIP, ESP and EBP; the rightmost are IP, SP and BP respectively (16-bit wider as mentioned above)
IP register is associated with CS register (as CS:IP => Segment:Offset)

Example - Segment address in CS 39B40h

Offset address in IP +0514h

------------

Address of next instruction 3A054h

------------

SP register is associated with SS register (as SS:SP => Segment:Offset)

Example - Segment address in SS 39B40h

Offset address in SP +0514h

------------

Address in stack 3A054h

------------

BP facilitates referencing parameters, which are data and addresses that a program passes via the stack. Processor combines the address in SS with the offset in BP. BP can also be combined with DI and with SI as a base register for special addressing.

3. General Purpose registers

32-bit general purpose registers
AX - primary accumulator - used for operations involving input/output and most arithmetic - more efficient compared to other registers
BX - base register - only register used as an index to extend addressing - can also be combined with DI or SI as a base register for special addressing
CX - count register - may contain a value to control the number of times a loop is repeated or a value to shift bits left or right
DX - data regsiter - works with AX sometimes, to compute operations that involve large values

4. Index registers

SI (soure index) - may be required for some string (character) handling operations - in this context, SI is associated with DS register (as DS:SI)
DI (destination index) - is required for some string operations - in this context, DI is associated with ES register

5. Flags register

32 bit wder
OF (overflow), IF (interrupt), TF (trap), SF (sign), ZF (zero), AF (auxiliary carry), PF (parity) and CF (carry)

Execution unit and Bus Interface Unit

2009-06-04T01:43:00.000-07:00

Processor is partitioned into two logical units

1. Execution unit (EU) - to execute instructions

2. Bus Interface Unit (BIU) - to deliver instructions and data to EU

Execution unit:

Maintains CPU status and control flags
manipulates general registers and instruction operands. (Registers and data paths are 16 bits wider)
has no connection to "outside world".
obtains instructions from Instruction Q maintained by BIU.
when an instruction requires access to memory or to a peripheral device, EU requests the BIU to obtain or store the data

Bus Interface unit:

performs all bus operations for EU
data transferred between CPU and momory/IO devices upon demand from EU
during periods, when EU is busy executing instructions, the BIU "looks ahead" and fetches more instructions from memory.
these instructions are stores in an internal RAM array called "Instruction Stream Q" - from which EU takes instructions to execute

Processor history

2009-06-04T01:25:00.001-07:00

How the Linux Kernel Boots

2009-05-14T10:49:00.000-07:00

1. Computer is powered ON (Now the RAM chips contains random data and no OS is running)

2. Special Hardware circuit raises the logical value of RESET pin of the CPU

3. On RESET, some registers of the processor (including cs and eip) are set to fixed values and the code found at physical address 0xffff fff0 is executed (Note this address is mapped by the hardware to a certain read-only, persistent memory chip called ROM)

Set of programs stored in ROM is traditionally called Basic Input/Output System (BIOS). This includes several interrupt-driven low-level procedures that make up the computer. (Some OSs, such as MSDOS rely on BIOS to implement most system calls)

4. Linux is forced to use BIOS in bootstrapping phase to retrieve the kernel image from the disk or from some other external device. The BIOS bootstrap program does

Executes POST (Power-On Self-Test) to make note of the devices present and its working condition (Recent computers make use of ACPI)
Initializes the hardware devices to make sure all hardware devices operates without conflicts on the IRQ lines and I/O pots
Searches for OS to boot. Depending on BIOS setting, the BSP may try to access first sector (boot sector) of floppy disk, hard disk and CD-ROM in the system (order can be changed)
Once valid OS image found in the first sector, it copies the contents of its first sector into RAM starting from physical address 0x0000 7c00 and then jumps into that address and executes the code just loaded (see below description without fail!!)

NOTE: Boot loader is the program invoked by BIOS to load the image of an operating system kernel into RAM. Here, booting from floppy disk is as simple as loading the instructions in its first sector into the RAM. (These instructions copy all the remaining sectors containing the kernel image into RAM). But booting from !hard-disk! is done differently. First sector of hard disk is MBR (partition table + a small pgm which loads the first sector of the partition containing the OS to be started)

5. A two-stage boot loader is required to boot a linux kernel from disk

LILO (LInux LOader)
GRand Unified Bootloader (GRUB) [More advanced than LILO as it recognizes several disk-based filesystems and is thus capable of reading portions of the boot program from files]

LILO may be installed either on MBR (replacing the small program that loades the boot sector of the active partition) or in the boot sector of every disk partition. In both cases, LILO is executed at boot time, and the user may choose which OS to load.

Now what does the LILO boot loader actually does...

Invokes a BIOS proceduce to display a "loading" message
Invokes BIOS procedure to load an initial portion of kernel image from disk: the first 512 bytes of the kernel image are put in RAM at address 0x0009 0000, while the code of the *setup()* function (discussed below) is put in RAM starting from address 0x0009 0200
Invokes a BIOS procedure to load the rest of the kernel image from disk and puts the image in RAM starting from either low address 0x0001 0000 (for small kernel images compiled with "make zImage" => "loaded low" kernel image) or high address 0x0010 0000 (for big kernel images compiled with "make bzImage" => "loaded high" kernel image)
Jumps to the setup() code (this assembly language function is placed by the linker at offset 0x200 of the kernel image file. Hence, LILO can easily locate this and copy it into RAM, starting from physical address 0x0009 0200 as mentioned above)

6. This setup() code initializes the hardware devices in the computer and setup the environment for the execution of kernel program. (Here a question arises... then wat *$($(#$ devices are been initialized by BIOS then?... Ofcourse.. but Linux does not rely on it. Hence reinitialized the devices on its own manner to enhance portability and robustness). This setup() does the following..

in ACPI compliant systems, invokes BIOS routine that builds a table in RAM describing the layout of the systems' physical memory
sets the keyboard repeat delay and rate (when user keeps a key pressed past a certain amount of time, the keyboard device sends the coreesponding keycode over and over to CPU)
initializes video adapter card
reinitialized the disk controller and determines the hard disk parameters
checks for an IBM micro channel bus (MCA) and PS/2 pointing device (bus mouse)
checks for APM BIOS support (Advanced Power Management BIOS)
If "loaded low" kernel (at 0x0001 0000), the function moves it to physical address 0x0000 1000. No changes for "loaded high" kernel. (This step is necessary because to be able to store the kernel image on a floppy disk and to reduce the booting time, the kernel image stored on disk is compressed and the decompression routing needs some free space to use as a temporary buffer following the kernel image in RAM) !!! Me too not clear with this step !!!
Sets the A20 pin located on the 8042 keyboard controller. A20 pin is a hack introduced n 80286 based systems to make physical addresses compatible with those of the ancient 8088 microprocessors. Unfortunately, the A20 pin must be properly set before switching to Protected mode, otherwise the 21st bit of every physical address will always be regarded as zero by CPU. To set this pin is a messy operation
Sets up a provisional IDT (Interrupt Descriptor Table) and a provisional GDT (Global Descriptor Table)

Resets the floating-point unit (FPU)
Reprograms the PIC (Programable Interrupt Controllers) to mask all interrupts except IRQ2 which is the cascading interrupt between the two PICs
Switches the CPU from Real Mode to Protected mode by setting PE bit in CR0 status register. (NOTE: The PG bit in CR0 register is cleared, so paging is still disabled. Linear address is considered as Physical address)
Jumps to "startup_32()" assembly language function (Yeah.. coming coming.. i know there are two startup_32 functions.. the one which we are referring is at arch/i386/boot/compressed/head.S file)

7. After "setup()" function terminates, the function has been moved to either to 0x0010 0000 to 0x0000 1000 depending on whether the kernel image was loaded high or low in RAM. Letz see whats this "startup_32()" gotto do

initializes segmentation registers and a provisional stack
clears all bits in eflags register
fills the area of uninitialized data of kernel identified by _edata and _end symbols with zeros
invokes decompress_kernel() function to decompress the kernel image. (Messages like "Uncrompressing Linux..." and once decompressed, "OK, booting the kernel.." are shown) (Again, if kernel image was loaded low, the decompressed kernel is placed at physical address 0x0010 0000. Else placed in a temporary buffer located after the compressed image. The decompressed image is then moved into its final position, which starts at physical address 0x0010 0000)
Jumps to physical address 0x0010 0000

8. The decompressed kernel image begins with anotehr startup_32 (this time at arch/i386/kernel.head.S; Same name for both functions does not create any probs besides confusin us). This second "startup_32()" sets up the execution environment for the first linux process (process id = 0). Here we go wat else it does..

initializes segmentation registers with their final values
fills the 'bss' segment of the kernel with zeros
initializes the provisional kernel Page Tables contained in swapper_pg_dir and pg0 to identically map the linear addresses to same physicall addresses (more explanation required.. will do sooner)
stores the address Page Global Directory in cr3 register and enables paging by settng PG bit in cr0 register
Sets up the Kernel Mode stack for process 0
again clears all bits in eflags register
invokes setup_idt() to fill IDT with null interrupt handlers
puts the system parameters obtained from BIOS and parameters passed to operating system into the first page frame (again sooner will explain this too)
identifies the model of the processor
loads the gdtr and idtr registers with addresses of GDT and IDT tables
jumps to our one and only "start_kernel()" function which completes the initialization of Linux Kernel

9. Nearly every kernel component is initialized by this function. Mentioned below are juz a few of them

sched_init() - to initialize scheduler
build_all_zonelists() - to initialize memory zones
page_alloc_init() & mem_init() - to initialize Buddy system allocators
trap_init() & init_IRQ() - to initialize IDT for final time
softirq_init() - to initialize TASKLET_SOFTIRQ and HI_SOFTIRQ
time_init() - to initialize system date and time
kmem_cache_init() - to initialize slab allocator
calibrate_delay() - to determine the speed of the CPU clock
kernel_thread() - to create the kernel thread for process 1; in turn, this kernel thread creates other kernel threads and executes /sbin/init program

10. After this init program and many kernel threads, at the end, the familiar login prompt appears on the console (or in the graphical screen, if the X Window System is launched at startup), telling the user that the Linux kernel is up and running

Once in protected mode, Linux does not use BIOS any longer, but it provides its own device driver for every hardware device on the computer (Moreover, BIOS procedures must be executed in real mode, so they cannot share functions even if that would be beneficial)

Compiling Linux Kernel

2009-05-13T02:40:00.001-07:00

If you want to remove/add some kernel symbols to be exported, then go to

/usr/src/linux/fs/proc/proc_misc.c

and do the changes you want. If you want to remove, comment EXPORT_SYMBOL of that symbol

Now to compile the kernel, do

1. make

2. make modules_install

3. make install

in /usr/src/linux directory.

Frequently used commands

2009-05-13T01:45:00.000-07:00

1. To find a file in current directory

find . -name "something.h"

2. To find a file (in current directory) with some text in it

grep "sometext" . -wrn

-r is for recursive; -n is to print the line numbers; -w for "whole" words only

3. To find the dependencies of an exe on .so files
ldd exe-name

4. To remove the debug symbols from an exe

strip --strip-debug or

strip -g or

strip - d

6. To list down exported symbols from kernel

cat /proc/kallsyms | grep "__ksymtab_proc_root"

NOTE: "__ksymtab" prefixed symbols are the symbols exported from the kernel.

7. To install from the spec file
rpm -ba "spec"

8. To find the distribution of the Linux (11.1 or 10.2 or 10.3), use

lsb_release -a

NOTE: lsb stands for Linux Standard Base

9. To find the size of the files (in friendly format) in a directory, go inside that directory
du -ch *

Symbols exported by Linux Kernel

2009-05-13T01:31:00.000-07:00

To see the list of kernel exported symbols, use

vim /boot/System.map or
cat /proc/kallsyms | more

NOTE: Only the symbols that are preceded with "__ksymtab" can be used in application. Eg. __ksymtab_proc_root_kcore

Memory mapped and IO mapped devices

2009-05-13T01:28:00.000-07:00

Memory Mapped Devices: Device registers are mapped to physical memory.

IO Mapped Devices: Device registers are within the device itself. Requires special instructions (like inport, outport) to access those registers.