LKM (loadable kernel module) -> alter without reboot, load/unload when needed, smaller core kernel. Example : device driver
as opposed to SK (static kernel) -> need reboot when altered
xxx.c --> xxx.ko (ko= kernel object)
.so = shared object
A. /proc/kallsyms contains all function of kernel (ex. printk) and the services using it.
===> printk is print at kernel (seen at dmesg or /var/log/messages)
===> printf is print at user mode
B. /boot/System.map.xxxxx contains all the system calls (which is a "call" to kernel space, from user space)
Symbols that are visible for Load kernel module is in:
C. /lib/modules/'uname -r'/build/Module.symvers
ABC relation:
C containing the symbol (function/call) and the memory address (address important for debugging). B containing all the symbol(along with the ID) with the services use it (ex. service : ip, ipv6,nfs). A containing the symbol/function/call(along with the ID) available, and with subs of that function.
To compile:
Make the xxx.c file (C source code)
Cretae the Makefile (enough this 1 line ==> obj-m := xxx.o )
compile it by:
make -C /usr/src/kernels/2.6.18-92.el5-i686/ modules M=$PWD
Result many files, one of them is xxx.ko
modinfo xxx.ko (To see the information which is written in the xxx.c)
insmod xxx.ko (opposed : rmmod xxx.ko or rmmod xxx)
==> must use the path/file location, and execute/install module dependency beforehand
==> modules and its alias is in /etc/modules.conf (either can be used)
==> dependency is in /lib/modules/version/modules.dep
modprobe xxx (opposed : modprobe -r xxx)
==> modprobe use insmod too, but it is aware the def location of module /lib/modules/version, and it is aware of the dep. So use this better.
lsmod (to see what is installed) ==> /proc/modules
depmod -a (to refresh the module database list) IMPORTANT!!
To make it (copy auto) to /lib/modules/.........
make -C /usr/src/kernels/2.6.18-92.el5-i686/ modules_install M=$PWD
Thursday 28 October 2010
Monday 25 October 2010
Memory physical types
RAM vs SAM (random addresses vs serial addresses(tape) )
DRAM vs SRAM
*Dynamic(keep refreshed the voltage, up to 1000times/sec)
*Static (need not refreshed, so faster but more expensive)
Note : memory chips containing transistors (each transistor has capacitor for storing electric as represent of bit 1), the transistor function as switch, 0 or 1. Transistor has Base, C and Emitter. These 3 legs make a transistors as electronic switch.
DRAM vs SDRAM
* Synchronous : faster and more expensive (it has feature pipelines, where it can do next task without wait the prev one). The sync is about time clock, so it has cycle to do actions.
== Pipelining means that the chip can accept a new instruction before it has finished processing the previous one. In a pipelined write, the write command can be immediately followed by another instruction without waiting for the data to be written to the memory array. In a pipelined read, the requested data appears after a fixed number of clock pulses after the read instruction, cycles during which additional instructions can be sent. (This delay is called the latency and is an important parameter to consider when purchasing SDRAM for a computer.) ====
Complete on : http://en.wikipedia.org/wiki/Synchronous_dynamic_random_access_memory
DIMM vs SIMM
* dual inline memory module
DDR (dual data rate)vs SDR (single)
*
DDR2 ( is then DDR1)
DDR3 (is faster in transfer than DDR2)
x4 vs x8 (by 4 vs by 8)
DRAM vs SRAM
*Dynamic(keep refreshed the voltage, up to 1000times/sec)
*Static (need not refreshed, so faster but more expensive)
Note : memory chips containing transistors (each transistor has capacitor for storing electric as represent of bit 1), the transistor function as switch, 0 or 1. Transistor has Base, C and Emitter. These 3 legs make a transistors as electronic switch.
DRAM vs SDRAM
* Synchronous : faster and more expensive (it has feature pipelines, where it can do next task without wait the prev one). The sync is about time clock, so it has cycle to do actions.
== Pipelining means that the chip can accept a new instruction before it has finished processing the previous one. In a pipelined write, the write command can be immediately followed by another instruction without waiting for the data to be written to the memory array. In a pipelined read, the requested data appears after a fixed number of clock pulses after the read instruction, cycles during which additional instructions can be sent. (This delay is called the latency and is an important parameter to consider when purchasing SDRAM for a computer.) ====
Complete on : http://en.wikipedia.org/wiki/Synchronous_dynamic_random_access_memory
DIMM vs SIMM
* dual inline memory module
DDR (dual data rate)vs SDR (single)
*
DDR2 ( is then DDR1)
DDR3 (is faster in transfer than DDR2)
x4 vs x8 (by 4 vs by 8)
Sunday 24 October 2010
How raid 5 works and the parity calculated
RAID 5, required 3 disks minimum. The total storage afterward is (n-1) disk capacity, and YES all disks must have same size.
How they calculate it the parity is like this:
disk1 disk2 disk3 .... diskLast
0 1 0 parity:disk1 XOR disk2 then the result is XOR to disk3
parity 0 0 1
Above example of disk stripe segment of 1 bit, in real world the normal ones is between 4bits to 256bits.
The magic is when disk1/2/3 failed, it can rebuild from the result, as following:
disk2 XOR disk3 then XOR to parity(above is in diskLast) = disk1
It is not magic though, it is only about:
if bits same then it friend (0 XOR 0 = 0 (friends) 1 XOR 1 = 0 (friends) )
if bits differs then it is enemy.
So from the friend/enemy, you can figure the other bit from the partner bit.
Here is the best explanation:
http://www.scottklarr.com/topic/23/how-raid-5-really-works/
The other thing you must know, when the drive failed, the server will use more IO and CPU, cause when read operation happening it will calculate to result the missing data ( i wanna say that everything is in place as normal, NOT like the idea where if a drive failed then the parities are all calculated and stores the missing bits to the parity bits place as replacing, it is NOT like that)
When a new drive comes, rebuild happens and same exactly as the failed one + the parity from the write operation after failed time.
How they calculate it the parity is like this:
disk1 disk2 disk3 .... diskLast
0 1 0 parity:disk1 XOR disk2 then the result is XOR to disk3
parity 0 0 1
Above example of disk stripe segment of 1 bit, in real world the normal ones is between 4bits to 256bits.
The magic is when disk1/2/3 failed, it can rebuild from the result, as following:
disk2 XOR disk3 then XOR to parity(above is in diskLast) = disk1
It is not magic though, it is only about:
if bits same then it friend (0 XOR 0 = 0 (friends) 1 XOR 1 = 0 (friends) )
if bits differs then it is enemy.
So from the friend/enemy, you can figure the other bit from the partner bit.
Here is the best explanation:
http://www.scottklarr.com/topic/23/how-raid-5-really-works/
The other thing you must know, when the drive failed, the server will use more IO and CPU, cause when read operation happening it will calculate to result the missing data ( i wanna say that everything is in place as normal, NOT like the idea where if a drive failed then the parities are all calculated and stores the missing bits to the parity bits place as replacing, it is NOT like that)
When a new drive comes, rebuild happens and same exactly as the failed one + the parity from the write operation after failed time.
Subscribe to:
Posts (Atom)