Linux Kernel Study http://kernelstudy.net Tue, 11 May 2010 02:17:26 +0000 en hourly 1 http://wordpress.org/?v=3.0 Interesting article ‘Interview: Ingo Molnar’ http://kernelstudy.net/?p=177 http://kernelstudy.net/?p=177#comments Tue, 11 May 2010 02:06:50 +0000 admin http://kernelstudy.net/?p=177 One of the main contributor into the Linux kernel is Ingo Molnar. I found this article while checking removal of ‘get_irqlock()’ in Kernel 2.6.

Even though, it doesn’t mention about this in detail, it was good material to understand what jobs Ingo did and what was the main feature of O(1) scheduler and others.

Check this out : http://kerneltrap.org/node/517

]]> http://kernelstudy.net/?feed=rss2&p=177 0 meaning of flags field in /proc/cpuinfo http://kernelstudy.net/?p=175 http://kernelstudy.net/?p=175#comments Tue, 13 Apr 2010 00:42:04 +0000 admin http://kernelstudy.net/?p=175 Cited from : http://www.gentoo-wiki.info/Gentoo:/proc/cpuinfo

About

This file contains useful information about your processor(s). This page explains, what this file actually tells you.

The following is an output from /proc/cpuinfo on a laptop with a Core 2 Duo T7200 CPU.

processor : 1
vendor_id : GenuineIntel
cpu family : 6
model : 15
model name : Intel(R) Core(TM)2 CPU T7200 @ 2.00GHz
stepping : 6
cpu MHz : 1000.000
cache size : 4096 KB
physical id : 0
siblings : 2
core id : 1
cpu cores : 2
fdiv_bug : no
hlt_bug : no
f00f_bug : no
coma_bug : no
fpu : yes
fpu_exception : yes
cpuid level : 10
wp : yes
flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe lm constant_tsc pni monitor ds_cpl vmx est tm2 ssse3 cx16 xtpr lahf_lm
bogomips : 3990.09
clflush size : 64

As you can see, the file tells us we have one processor with two cores. Furthermore the cpu is clocked down to 1000 MHz. We also have a bunch of flags which tells us what extra instructions this processor has to offer.
flags

The flags line tells us what extra instructions the processor has to offer. This is a listing of flags with a short explanation of each. There is an even shorter explanation in the file /usr/include/asm/cpufeature.h.

Intel flags (This table is currently identical with /usr/include/asm/cpufeature.h. Hopefully some hardware god will share his wisdom and expand this table. )
Flag Description Common in processor types
fpu Onboard (x87) Floating Point Unit
vme Virtual Mode Extension
de Debugging Extensions
pse Page Size Extensions
tsc Time Stamp Counter: support for RDTSC and WRTSC instructions
msr Model-Specific Registers
pae Physical Address Extensions: ability to access 64GB of memory; only 4GB can be accessed at a time though
mce Machine Check Architecture
cx8 CMPXCHG8 instruction
apic Onboard Advanced Programmable Interrupt Controller
sep Sysenter/Sysexit Instructions; SYSENTER is used for jumps to kernel memory during system calls, and SYSEXIT is used for jumps back to the user code
mtrr Memory Type Range Registers
pge Page Global Enable
mca Machine Check Architecture
cmov CMOV instruction
pat Page Attribute Table
pse36 36-bit Page Size Extensions: allows to map 4 MB pages into the first 64GB RAM, used with PSE.
pn Processor Serial-Number; only available on Pentium 3
clflush CLFLUSH instruction
dtes Debug Trace Store
acpi ACPI via MSR
mmx MultiMedia Extension
fxsr FXSAVE and FXSTOR instructions
sse Streaming SIMD Extensions. Single instruction multiple data. Lets you do a bunch of the same operation on different pieces of input in a single clock tick.
sse2 Streaming SIMD Extensions-2. More of the same.
selfsnoop CPU self snoop
acc Automatic Clock Control
IA64 IA-64 processor Itanium.
ht HyperThreading. Introduces an imaginary second processor that doesn’t do much but lets you run threads in the same process a bit quicker.
nx No Execute bit. Prevents arbitrary code running via buffer overflows.
pni Prescott New Instructions aka. SSE3
vmx Intel Vanderpool hardware virtualization technology
svm AMD “Pacifica” hardware virtualization technology
lm “Long Mode,” which means the chip supports the AMD64 instruction set
tm “Thermal Monitor” Thermal throttling with IDLE instructions. Usually hardware controlled in response to CPU temperature.
tm2 “Thermal Monitor 2″ Decrease speed by reducing multipler and vcore.
est “Enhanced SpeedStep”

]]> http://kernelstudy.net/?feed=rss2&p=175 0 Make a VM template without using LVM in KVM http://kernelstudy.net/?p=173 http://kernelstudy.net/?p=173#comments Wed, 03 Mar 2010 06:58:39 +0000 admin http://kernelstudy.net/?p=173 In my opinion, template is the most useful feature in virtualization technology. After creating one fully installed VM, you can create several temporary VMs from the original without spend lots of hours or lots of disk space. In LVM environment, you can use ‘snapshot’ feature of lvcreate command. But, LVM volume is not easy to move between systems especially when you want to upgrade to the latest distribution just like Fedora.

If we can create new VMs from the file-based image, it could be very convenient to migrate between systems and easy to back up. With qemu-img utility you can do the same thing as LVM do.

Following are the steps I did to create new VM from the old one which is file-based.

1
2
3

$ qemu-img convert rhel4u5.img -O qcow2 rhel4u5.qcow2
$ qemu-img create -b rhel4u5.qcow2 -f qcow2 rhel4u5-test1.qcow2
$ virt-install -nrhel4u5-test1 -r512 -v --os-type=linux --os-variant=rhel4 --import --disk path=rhel4u5-test1.qcow2

Easy, isn’t it?
The first step is only necessary when your original VM was created with raw format.

]]> http://kernelstudy.net/?feed=rss2&p=173 0 How could I reduce kernel’s binary size as small as distribution’s size http://kernelstudy.net/?p=167 http://kernelstudy.net/?p=167#comments Mon, 22 Feb 2010 01:28:56 +0000 admin http://kernelstudy.net/?p=167 The basic steps to compile kernel and modules are similar to following.

1

make modules && make bzImage && make modules_install && make install

It will install the kernel related files into the proper location after compile modules and kernel. But maybe you could be surprised by the final binaries size. Sometimes, it shows more than 10 times bigger size than distributor’s module and kernel size. It even happened with distribution’s configuration.

I will show some basic tips you can use to build your own kernel from distribution’s source files without any increase in size.

First, you should download source files from distributor’s site or get it from distribution media. In my case, I downloaded the kernel rpm from Red Hat Network (http://rhn.redhat.com).

After installing source rpms and you need to rebuild source codes from the spec.

1
2
3
4

$ rpm -ivh kernel-2.6.18-128.1.1.el5.src.rpm
$ cd /usr/src/redhat/SPECS
$ rpmbuild -bp --target=i686 kernel-2.6.spec
$ cd /usr/src/redhat/BUILD/kernel-2.6.18/linux-2.6.18.x86_64/

You can see the patched kernel codes in BUILD directory. After doing some modification for your purpose, it is time to rebuild kernel. To reduce kernel size, add ‘INSTALL_MOD_STRIP=1′ options in make command.

1

make modules && make bzImage && make INSTALL_MOD_STRIP=1 modules_install && make INSTALL_MOD_STRIP=1 install

It will strip off unnecessary debug information from the compiled images. If you can keep another kernel images separately which has debug information for the debugging purpose.

This methods work for RHEL5 and Fedora 11 or 12 (I couldn’t check this with earlier version but would be applied for earlier version of Fedora). If you want to reduce sizes in RHEL4 or earlier version, you should strip off DEBUG_* related options from the configuration file before do compile.

Following is the part of RHEL4 spec file.

1
2
3
4
5
6
7
8
9
10
11
12
13

# set the EXTRAVERSION to <version>custom, so that people who follow a kernel building howto
# don't accidentally overwrite their currently working moduleset and hose
# their system
perl -p -i -e "s/^EXTRAVERSION.*/EXTRAVERSION = -%{release}custom/" $RPM_BUILD_ROOT/usr/src/linux-%{KVERREL}/Makefile
 
# some config options may be appropriate for an rpm kernel build but are less so for custom user builds,
# change those to values that are more appropriate as default for people who build their own kernel.
perl -p -i -e "s/^CONFIG_DEBUG_INFO.*/# CONFIG_DEBUG_INFO is not set/" $RPM_BUILD_ROOT/usr/src/linux-%{KVERREL}/configs/*
perl -p -i -e "s/^.*CONFIG_DEBUG_PAGEALLOC.*/# CONFIG_DEBUG_PAGEALLOC is not set/" $RPM_BUILD_ROOT/usr/src/linux-%{KVERREL}/configs/*
perl -p -i -e "s/^.*CONFIG_DEBUG_SLAB.*/# CONFIG_DEBUG_SLAB is not set/" $RPM_BUILD_ROOT/usr/src/linux-%{KVERREL}/configs/*
perl -p -i -e "s/^.*CONFIG_DEBUG_SPINLOCK.*/# CONFIG_DEBUG_SPINLOCK is not set/" $RPM_BUILD_ROOT/usr/src/linux-%{KVERREL}/configs/*
perl -p -i -e "s/^.*CONFIG_DEBUG_HIGHMEM.*/# CONFIG_DEBUG_HIGHMEM is not set/" $RPM_BUILD_ROOT/usr/src/linux-%{KVERREL}/configs/*
perl -p -i -e "s/^.*CONFIG_MODULE_SIG.*/# CONFIG_MODULE_SIG is not set/" $RPM_BUILD_ROOT/usr/src/linux-%{KVERREL}/configs/*

As you can see, it strips off some DEBUG related options to blank.

]]> http://kernelstudy.net/?feed=rss2&p=167 0 Configuring a Bridge Interface for the KVM-based virtual machines http://kernelstudy.net/?p=165 http://kernelstudy.net/?p=165#comments Mon, 22 Feb 2010 00:26:35 +0000 admin http://kernelstudy.net/?p=165 If you are going to run virtualized host as a web server or some services for the clients, the systems should be accessible from the outside. Unfortunately, the default network configuration in KVM is NAT (Network Address Translation). It is good for some VMs who will co-work with other VMs, but for the server, it can be a big obstacle.

The bridged network is a solution for that circumstances. Bridged network allows VMs to have their own IP addresses which are accessible from the outside.

I’ll show how you can create bridged network in here with one physical network device – eth0. In ethernet environment, you can use ‘brctl’ command to administrate bridged network.

1
2

[root@dhcp-160-193 ~]# brctl show
bridge name	bridge id		STP enabled	interfaces

Before you create bridge, you should make a backup of the files which will be used in this example.

1
2
3
4
5
6
7

[root@dhcp-165-234 ~]# brctl show
bridge name	bridge id		STP enabled	interfaces
[root@dhcp-165-234 ~]# cd /etc/sysconfig/network-scripts/
[root@dhcp-165-234 network-scripts]# ls ifcfg-*
ifcfg-eth0  ifcfg-lo
[root@dhcp-165-234 network-scripts]# mkdir backup
[root@dhcp-165-234 network-scripts]# cp ifcfg-* backup

Dump current eth0 configuration using virsh command.

1
2
3
4
5
6
7
8
9

[root@dhcp-165-234 network-scripts]# virsh iface-dumpxml eth0
<interface type='ethernet' name='eth0'>
  <start mode='onboot'/>
  <mac address='00:21:9B:04:05:99'/>
  <protocol family='ipv4'>
    <dhcp peerdns='yes'/>
  </protocol>
</interface>
[root@dhcp-165-234 network-scripts]# virsh iface-dumpxml eth0 > bakup/eth0.xml

It will save your eth0′s configuration into backup/eth0.xml file. Next thing you need to is create XML file for bridge using the saved eth0.xml. Following is the br0.xml I created from eth0.xml.

1
2
3
4
5
6
7
8
9
10
11
12

<interface type='bridge' name='br0'>
  <start mode='onboot'/>
  <protocol family='ipv4'>
    <dhcp peerdns='yes'/>
  </protocol>
 
  <bridge>
    <interface type='ethernet' name='eth0'>
      <mac address='00:21:9B:04:05:99'/>
    </interface>
  </bridge>
</interface>

Next thing to do is define the bridge interface to libvirt as shown below.

1
2
3

[root@dhcp-165-234 network-scripts]# virsh iface-define br0.xml
error: Failed to define interface from br0.xml
error: invalid argument in virGetInterface

It will show error messages but it’s OK at this point. Next step is to configure ifcfg-eth0 and create ifcfg-br0 interface. Following is my configuration.

1
2
3
4
5
6
7
8
9
10
11

[root@dhcp-160-181 network-scripts]# cat ifcfg-eth0
DEVICE=eth0
HWADDR=00:21:9B:04:05:99
ONBOOT=yes
BRIDGE=br0
[root@dhcp-160-181 network-scripts]# cat ifcfg-br0
DEVICE=br0
ONBOOT=yes
TYPE=Bridge
BOOTPROTO=dhcp
PEERDNS=yes

Next step is restart network service. You also need to stop NetworkManager service.

1
2
3
4
5
6
7
8
9

[root@dhcp-160-181 network-scripts]# service network restart
Shutting down interface eth0:  bridge br0 does not exist!
                                                           [  OK  ]
Shutting down loopback interface:                          [  OK  ]
Disabling IPv4 packet forwarding:  net.ipv4.ip_forward = 0
                                                           [  OK  ]
Bringing up loopback interface:                            [  OK  ]
Bringing up interface eth0:                                [  OK  ]
Bringing up interface br0:                                 [  OK  ]

Now, br0 is activated.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

[root@dhcp-160-181 network-scripts]# virsh iface-list
Name                 State      MAC Address
--------------------------------------------
br0                  active     00:21:9b:04:05:99
lo                   active     00:00:00:00:00:00
 
[root@dhcp-160-181 network-scripts]# ifconfig 
br0       Link encap:Ethernet  HWaddr 00:21:9B:04:05:99  
          inet addr:100.20.50.181  Bcast:100.20.50.255  Mask:255.255.255.0
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:1021814 errors:0 dropped:0 overruns:0 frame:0
          TX packets:583293 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:0 
          RX bytes:373480692 (356.1 MiB)  TX bytes:170390832 (162.4 MiB)
 
eth0      Link encap:Ethernet  HWaddr 00:21:9B:04:05:99  
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:1812236 errors:0 dropped:0 overruns:0 frame:0
          TX packets:1342244 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:100 
          RX bytes:666795722 (635.9 MiB)  TX bytes:263334525 (251.1 MiB)
          Memory:fdfc0000-fdfe0000 
...

Now you are ready to use bridge interface in VMs. If you have a guest already, you only need to change the interface part as shown below. You don’t need to change mac address of course. :) 

1
2
3
4
5
6

[root@dhcp-160-181 networks]# virsh dumpxml win2003 | grep -A 3 interface
    <interface type='bridge'>
      <mac address='52:54:00:42:54:04'/>
      <source bridge='br0'/>
      <target dev='vnet0'/>
    </interface>

If you are creating new virtual machines, your only job is to choose ‘eth0 (Bridge br0)’ in Network configuration step.

Unfortunately, at this time I write this, RHEL5 does not have some features in libvirt so not working well. I tested this on Fedora 12 and some other useful links when you use RHEL5.4 instead of Fedora 12 are http://www.redhat.com/docs/en-US/Red_Hat_Enterprise_Linux/5.4/html/Virtualization_Guide/sect-Virtualization-Network_Configuration-Bridged_networking_with_libvirt.html and http://benincosa.org/blog/?p=93.

]]> http://kernelstudy.net/?feed=rss2&p=165 0 Set up test environment with two virtual machines. http://kernelstudy.net/?p=157 http://kernelstudy.net/?p=157#comments Mon, 18 Jan 2010 02:19:29 +0000 admin http://kernelstudy.net/?p=157 To test some problems usually I have to have two machines which is not easy to have. Especially if I have to configure it for each version, RHEL4, RHEL5, Fedora, etc.

Virtualzation comes here to solve those kinds of difficulty. But, just installing new operating system each time is also not a perfect solution. You should wait couple of hours before you can do test something. It’s also applied even though you already have that operating system because you need fresh system. Most easiest way is to use LVM’s snapshot feature.

Here are the steps I did to build my own test environment.

To use snapshot feature, you should make LVM partition first. There are many useful documentations for this steps. Easiest way to make room for virtual image is using ‘system-config-lvm’ if you use Fedora or RHEL. With GUI, you can resize the existing volume and make new volume on the free space. This new volume will be the space for the original operating system.

If you preper command line tools, you can use ‘lvreduce’ for reducing exsiting filesystem’s size and ‘lvcreate’ for creating new logical volume.

In my case, I created logical volume for RHEL5U4 with name rhel5u4. Following is the output from ‘lvdisplay’ command.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

  --- Logical volume ---
  LV Name                /dev/VolGroup/rhel5u4
  VG Name                VolGroup
  LV UUID                kkk383-IDE3-Lzh1-tKm4-a3YT-3k23-EIKFD5E
  LV Write Access        read/write
  LV Status              available
  # open                 0
  LV Size                20.00 GB
  Current LE             5120
  Segments               1
  Allocation             inherit
  Read ahead sectors     auto
  - currently set to     256
  Block device           253:3

Create new virtual system with this volume. ‘virt-manager’ is a good tool to this. I’ll not describe how to install new operating system with ‘virt-manager’.

After installing new operating system and configured everything that will be necessary to work basically, you also need to edit ‘/etc/hosts’ file in this operating system if you want to make two different virtual machine easily communicate. I did it as following for my test environment.

1
2

192.168.122.100		station1.example.com		station1
192.168.122.101		station2.example.com		station2

If you want have more than two systems, you also add more lines with new IP address. I decided to use internal IP addresses but if you want the systems accessible from the outside, you should build bridge network first. I’ll not describe it here. After add above lines in to the ‘etc/hosts’ you need to shutdown the virtual machine and you will not use it until you want to install something common between each virtual machine.

It is time to create new volume for each virtual machine. I made simple script for this.

1
2
3
4
5
6
7
8
9
10
11
12
13

#!/bin/bash
 
if [ /dev/VolGroup/rhel5u4_test1 ]
then
	lvremove /dev/VolGroup/rhel5u4_test1
fi
lvcreate --size 1g --snapshot --name rhel5u4_test1 /dev/VolGroup/rhel5u4
 
if [ /dev/VolGroup/rhel5u4_test2 ]
then
	lvremove /dev/VolGroup/rhel5u4_test2
fi
lvcreate --size 1g --snapshot --name rhel5u4_test2 /dev/VolGroup/rhel5u4

It will remove exsiting volume and will create new volume as a snapshot based on existing rhel5u4 volume with 1G of space for modification.

As a last step, you should fix IP address for each machine. If you do not, you can’t reach each machine with their name and always have to recheck current IP address for testing. Some documents says that it is necessary to restart dnsmasq because virtual machine get address from dnsmasq, but it it not true. Only thing you should have to do is stay on ‘virsh’ command.

Basic steps are as something like following.

1. cd /etc/libvirt/qemu/networks/
2. vi default.xml
3. virsh net-destroy default
4. virsh net-define default.xml
5. virsh net-start default

At the second step, you should add each virtual machine’s MAC address with desired IP address. As a result, mine is something like this.

1
2
3
4
5
6
7
8
9
10
11
12
13

<network>
  <name>default</name>
  <uuid>8dc538f3-ce99-4708-8e53-46aad24e6157</uuid>
  <forward mode='nat'/>
  <bridge name='virbr0' stp='on' delay='0' />
  <ip address='192.168.122.1' netmask='255.255.255.0'>
    <dhcp>
      <range start='192.168.122.2' end='192.168.122.254' />
      <host mac='52:54:00:77:c8:94' name='station1.example.com' ip='192.168.122.100' />
      <host mac='52:54:00:af:5d:59' name='station2.example.com' ip='192.168.122.101' />
    </dhcp>
  </ip>
</network>

You don’t need to restart dnsmasq or libvirtd at all. Just update this configuration file and restart each virtual machine is the enough step. From now, you have configured two systems and at any time you can restart with recreate snapshot.

]]> http://kernelstudy.net/?feed=rss2&p=157 0 Videos about Android architecture http://kernelstudy.net/?p=147 http://kernelstudy.net/?p=147#comments Mon, 28 Dec 2009 11:54:28 +0000 admin http://kernelstudy.net/?p=147 Recently, I’m fascinated by the Google’s Android platform. So, I started to study this but I hope I can start from very basic tutorials and hope it could be more helpful if it has a video format.

Fortunately, Google provides several videos regarding Android.

Here are some useful very basic videos.



]]> http://kernelstudy.net/?feed=rss2&p=147 0 /dev/kvm http://kernelstudy.net/?p=119 http://kernelstudy.net/?p=119#comments Thu, 11 Jun 2009 06:46:00 +0000 admin http://kernelstudy.net/?p=119 I’ll show the very basic path into the KVM from the User Space. If you loaded ‘kvm’ module, you can find kvm as a device node, usually in /dev/ directory. This character device node provides the way to control Virtualization features such as checking the ability, creating VM, and destroying VM.

While kvm module loading, it registers character device as a misc device.

1
2
3
4
5
6
7
8
9
10
11
12

r = misc_register(&kvm_dev);
 
static struct file_operations kvm_chardev_ops = {
        .unlocked_ioctl = kvm_dev_ioctl,
        .compat_ioctl   = kvm_dev_ioctl,
};
 
static struct miscdevice kvm_dev = {
        KVM_MINOR,
        "kvm",
        &kvm_chardev_ops,
};

As you can see here, they only implemented ioctl call. It means that you can’t find anything useful with general read/write call or redirection on the command line. You always have to write an application to use kvm’s feature.

kvm_dev_ioctl function is implemented as following:

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

static long kvm_dev_ioctl(struct file *filp,
                          unsigned int ioctl, unsigned long arg)
{
        long r = -EINVAL;
 
        switch (ioctl) {
        case KVM_GET_API_VERSION:
                r = -EINVAL;
                if (arg)
                        goto out;
                r = KVM_API_VERSION;
                break;
        case KVM_CREATE_VM:
                r = -EINVAL;
                if (arg)
                        goto out;
                r = kvm_dev_ioctl_create_vm();
                break;
        case KVM_CHECK_EXTENSION:
                r = kvm_dev_ioctl_check_extension_generic(arg);
                break;
        case KVM_GET_VCPU_MMAP_SIZE:
                r = -EINVAL;
                if (arg)
                        goto out;
                r = PAGE_SIZE;     /* struct kvm_run */
#ifdef CONFIG_X86
                r += PAGE_SIZE;    /* pio data page */
#endif
#ifdef KVM_COALESCED_MMIO_PAGE_OFFSET
                r += PAGE_SIZE;    /* coalesced mmio ring page */
#endif
                break;
        case KVM_TRACE_ENABLE:
        case KVM_TRACE_PAUSE:
        case KVM_TRACE_DISABLE:
                r = kvm_trace_ioctl(ioctl, arg);
                break;
        default:
                return kvm_arch_dev_ioctl(filp, ioctl, arg);
        }
out:
        return r;
}

There are 7 predefined commands. If it is not recognized by this function, it goes into kvm_arch_dev_ioctl() function which do additional check with actual hardware module such as kvm_intel and kvm_adm.

KVM_GET_API_VERSION
It returns the version of KVM. In kernel 2.6.30, it is 12 (defined in kvm.h as a KVM_API_VERSION).

KVM_CREATE_VM

KVM_CHECK_EXTENSION

KVM_GET_VCPU_MMAP_SIZE

KVM_TRACE_ENABLE
KVM_TRACE_PAUSE
KVM_TRACE_DISABLE

]]> http://kernelstudy.net/?feed=rss2&p=119 0 How kernel determind the low and high memory zone? http://kernelstudy.net/?p=115 http://kernelstudy.net/?p=115#comments Tue, 24 Mar 2009 05:10:28 +0000 admin http://kernelstudy.net/?p=115 I thought Linux fixed highmem zone and low mem zone at the compile time. But, I was wrong. I even found the command line parameter named ‘highmem=’ which can set the highmem size.

Actually, this calculation is done during the initialization and following is the code which actually do the thing.

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

/*
 * Determine low and high memory ranges:
 */
unsigned long __init find_max_low_pfn(void)
{
        unsigned long max_low_pfn;
 
        max_low_pfn = max_pfn;
        if (max_low_pfn > MAXMEM_PFN) {
                if (highmem_pages == -1)
                        highmem_pages = max_pfn - MAXMEM_PFN;
                if (highmem_pages + MAXMEM_PFN < max_pfn)
                        max_pfn = MAXMEM_PFN + highmem_pages;
                if (highmem_pages + MAXMEM_PFN > max_pfn) {
                        printk("only %luMB highmem pages available, ignoring highmem size of %uMB.\n", pages_to_mb(max_pfn - MAXMEM_PFN), pages_to_mb(highmem_pages));
                        highmem_pages = 0;
                }
                max_low_pfn = MAXMEM_PFN;
#ifndef CONFIG_HIGHMEM
                /* Maximum memory usable is what is directly addressable */
                printk(KERN_WARNING "Warning only %ldMB will be used.\n",
                                        MAXMEM>>20);
                if (max_pfn > MAX_NONPAE_PFN)
                        printk(KERN_WARNING "Use a PAE enabled kernel.\n");
                else
                        printk(KERN_WARNING "Use a HIGHMEM enabled kernel.\n");
                max_pfn = MAXMEM_PFN;
#else /* !CONFIG_HIGHMEM */
#ifndef CONFIG_X86_PAE
                if (max_pfn > MAX_NONPAE_PFN) {
                        max_pfn = MAX_NONPAE_PFN;
                        printk(KERN_WARNING "Warning only 4GB will be used.\n");
                        printk(KERN_WARNING "Use a PAE enabled kernel.\n");
                }
#endif /* !CONFIG_X86_PAE */
#endif /* !CONFIG_HIGHMEM */
        } else {
                if (highmem_pages == -1)
                        highmem_pages = 0;
#ifdef CONFIG_HIGHMEM
                if (highmem_pages >= max_pfn) {
                        printk(KERN_ERR "highmem size specified (%uMB) is bigger than pages available (%luMB)!.\n", pages_to_mb(highmem_pages), pages_to_mb(max_pfn));
                        highmem_pages = 0;
                }
                if (highmem_pages) {
                        if (max_low_pfn-highmem_pages < 64*1024*1024/PAGE_SIZE){
                                printk(KERN_ERR "highmem size %uMB results in smaller than 64MB lowmem, ignoring it.\n", pages_to_mb(highmem_pages));
                                highmem_pages = 0;
                        }
                        max_low_pfn -= highmem_pages;
                }
#else
                if (highmem_pages)
                        printk(KERN_ERR "ignoring highmem size on non-highmem kernel!\n");
#endif
        }
        return max_low_pfn;
}
]]> http://kernelstudy.net/?feed=rss2&p=115 0 how linux get maximum pfn number? http://kernelstudy.net/?p=111 http://kernelstudy.net/?p=111#comments Tue, 24 Mar 2009 04:52:57 +0000 admin http://kernelstudy.net/?p=111 I wondered where linux get information about memory capacity in the machine. In i386 machine, we can get information from BIOS or e820 which is shorthand for BIOS function name. You can find some information from whikipedia : http://en.wikipedia.org/wiki/E820

Anyway, after checking basic memory map information, kernel call following function to get max_pfn value.

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

/*
 * Find the highest page frame number we have available
 */
void __init find_max_pfn(void)
{
        int i;
 
        max_pfn = 0;
        if (efi_enabled) {
                efi_memmap_walk(efi_find_max_pfn, &max_pfn);
                return;
        }
 
        for (i = 0; i < e820.nr_map; i++) {
                unsigned long start, end;
                /* RAM? */
                if (e820.map[i].type != E820_RAM)
                        continue;
                start = PFN_UP(e820.map[i].addr);
                end = PFN_DOWN(e820.map[i].addr + e820.map[i].size);
                if (start >= end)
                        continue;
                if (end > max_pfn)
                        max_pfn = end;
        }
}
]]> http://kernelstudy.net/?feed=rss2&p=111 0