雜記

kernel- hash list

2011-08-11T00:22:00.001+08:00

The overall structure of the hash list in kernel is shown as blow.

Here is the data structure.

struct hlist_head {
    struct hlist_node *first;
};

struct hlist_node {
    struct hlist_node *next, **pprev;
};

Kernel provides some interface to build a whole hash list quickly and they are more useful.

Some figures are illustrated to desrcbie how to use these function calls for the hash list.

static inline void hlist_add_head(struct hlist_node *n, struct hlist_head *h)
{
    struct hlist_node *first = h->first;
    n->next = first;
    if (first)
        first->pprev = &n->next;
    h->first = n;
    n->pprev = &h->first;
}

Insert a node to the head of hash list.

There are 2 case for this operation and please see below.

Case 1:

no any node exists in the hash list.

Case 2:

Otherwise , there are more than one nodes at least in the list.

static inline void hlist_add_before(struct hlist_node *n,
                    struct hlist_node *next)
{
    n->pprev = next->pprev;
    n->next = next;
    next->pprev = &n->next;
    *(n->pprev) = n;
}

Add the node N before the Node next.

static inline void hlist_add_after(struct hlist_node *n,
                    struct hlist_node *next)
{
    next->next = n->next;
    n->next = next;
    next->pprev = &n->next;

    if(next->next)
        next->next->pprev  = &next->next;
}

Add the node Next after node N.

static inline void hlist_del(struct hlist_node *n)
{
    __hlist_del(n);
    n->next = LIST_POISON1;
    n->pprev = LIST_POISON2;
}

Remove the node N from the list.

Linux kernel - contain_of

2011-08-09T23:39:00.006+08:00

This marco is mostly used in kernel .
The figure is illustrated to descible how the marco "contain_of" work.

The following is the source code using the marco "contain_of".

#include <stdio.h>

#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
#define container_of(ptr, type, member) ({            \
     const typeof( ((type *)0)->member ) *__mptr = (ptr);    \
     (type *)( (char *)__mptr - offsetof(type,member) );})

struct  St_Inner{
    int         dw_a;
};

struct St_Outer {
    int         dw_a;
    struct St_Inner    St_b;
    int         dw_c;
};

     
int main ()
{
    struct St_Outer  src;
    struct St_Outer  *p_dest;
    struct  St_Inner *p_Inner;
    p_Inner = &src.St_b;
    
    
    p_dest = container_of (p_Inner,struct St_Outer, St_b);
    
    printf ("p_dest %x == src %x\n",p_dest,&src);
    return 0;
}

Interesting callback function

2011-07-20T00:12:00.001+08:00

typedef void( *fp_t )(char *);

fp_t( *fp) [2];

It is easy to understand to expand it shown as the following.

void(*(*fp)[4])(char*);

Here is an example to show where this callback function can be used.

#include <stdio.h>

typedef void( *fp_t )(char *);

void  spi_read(char *data)
{
printf ("spi_read\n");
}
void  spi_write(char *data)
{
printf ("spi_write\n");
}
void  nand_read(char *data)
{
printf ("nand_read\n");
}
void  nand_write(char *data)
{
printf ("nand_write\n");
}
void (*spi_fp[2]) (char *);
void (*nand_fp[2]) (char *);
int main()
{
    int i;
 
    fp_t( *fp) [2];
    spi_fp[0] = spi_read;    
    spi_fp[1] = spi_write;    
    nand_fp[0] = nand_read;    
    nand_fp[1] = nand_write;    
    
    fp = &spi_fp;
    for (i=0;i<2;i++)
    {
        (*fp)[i] (0);
    }
    return 0;
}

LD_DEBUG and LD_LIBRARY_PATH

2011-06-14T11:22:00.003+08:00

It is useful to find out which library are loaded when running the program.

LD_DEBUG = help ./a.out

Vaild option for LD_DEBUG
libs	display library search paths
reloc	display relocation processing
files	display progress for input file
symbols	display symbol table processing
bindings	display information about symbol binding
versions	display version dependencies
all	all previous options combined
statistics	display relocation statistic
unused	determined unused DSOs
help	display this help message and exit

LD_DEBUG=libs ./a.out

17315:    find library=libc.so.6 [0]; searching
17315:     search cache=/etc/ld.so.cache
17315:      trying file=/lib/tls/i686/cmov/libc.so.6
17315:
17315:
17315:    calling init: /lib/tls/i686/cmov/libc.so.6
17315:
17315:
17315:    initialize program: ./a.out
17315:
17315:
17315:    transferring control: ./a.out
17315:
17315:
17315:    calling fini: ./a.out [0]
17315:
17315:
17315:    calling fini: /lib/tls/i686/cmov/libc.so.6 [0]
17315:

From above result, it will find the file "ld.so.conf" to know where the standard library is located.
In this case, the library I only use is glibc. So it is a simple code.
But it is handy tool if your program is very complex and you want to know which library is linked.

gcc --share b.c -o libb.so
gcc -o a{,.c} -lb -L.

Then you should export libary PATH "LD_LIBRARY_PATH"

export LD_LIBRARY_PATH=$LD_LIBRARY_PATH;./

The program will be executed successfully.
You can try LD_DEBUG again and the loader will search additional path "./" you assigned and load the specific library to memory.

Overlay attribute in LDScript

2011-06-07T23:27:00.002+08:00

For each section within the OVERLAY, the linker automatically defines two symbols. The symbol __load_start_secname is defined as the starting load address of the section. The symbol __load_stop_secname is defined as the final load address of the section.

OVERLAY 0x1000 : AT (0x4000)
{
   .text0 { o1/*.o(.text) }
   .text1 { o2/*.o(.text) }
}

This will define both `.text0' and `.text1' to start at address 0x1000. `.text0' will be loaded at address 0x4000, and `.text1' will be loaded immediately after `.text0'. The following symbols will be defined: __load_start_text0, __load_stop_text0,__load_start_text1, __load_stop_text1.

C code to copy overlay .text1 into the overlay area might look like the following.

extern char __load_start_text1, __load_stop_text1;
memcpy ((char *) 0x1000, &__load_start_text1,
          &__load_stop_text1 - &__load_start_text1);

Note that the OVERLAY command is just syntactic sugar, since everything it does can be done using the more basic commands. The above example could have been written identically as follows.

.text0 0x1000 : AT (0x4000) { o1/*.o(.text) }
__load_start_text0 = LOADADDR (.text0);
__load_stop_text0 = LOADADDR (.text0) + SIZEOF (.text0);
.text1 0x1000 : AT (0x4000 + SIZEOF (.text0)) { o2/*.o(.text) }
__load_start_text1 = LOADADDR (.text1);
__load_stop_text1 = LOADADDR (.text1) + SIZEOF (.text1);
. = 0x1000 + MAX (SIZEOF (.text0), SIZEOF (.text1));

Reference from The GNU linker.

Weak function

2011-06-04T01:50:00.001+08:00

From gnu gcc document:
The weak attribute causes the declaration to be emitted as a weak symbol rather than a global. This is primarily useful in defining library functions which can be overridden in user code, though it can also be used with non-function declarations.

libweak.c

#include <stdio.h>

void weakfunc() __attribute__((weak));

void weakfunc()
{
    printf ("default weak function\n");

}

main.c

#include <stdio.h>
void weakfunc()
{
    printf ("weak function from main\n");    
}

int main ()
{
    weakfunc();
    return 0;
}

Compile the library and main function.

#gcc -shared -o libweak.so weakfunc.c
#gcc  -o weakfunc{,.c} -lweak -L.
#LD_LIBRARY_PATH=. ./main
weak function from main

From above, it is very clear that the weak function of the library is replaced.

#objdump -t libweak.so |grep weakfunc
0000046c  w    F .text 00000014   weakfunc

In the library, this function has weak attribute.

#objdump -t main |grep weakfunc
080484e4  g    F .text 00000014   weakfunc

However, this function is presented as global attribute.

Andriod 專有名詞整理

2011-06-02T12:36:00.000+08:00

最近研究了Andriod，整理了一些專有名詞如
IPL (InitialProgramLoader):
Initialize the hardware setting, such as memory, cpu clock , flash, about the development board.
It is similar with the bootloader in the embedded system, like u-boot.

SPL (Second Program Loader):
The main goal is to load system OS to memory.
In addition, some features is provided as the below list.
(1) check hardware, like LCD, led.
(2) search the active partion and load it to memory.
(3) connection with PC and recieve commands from PC host.

HBoot:
This is HTC’s SPL
fastboot:
Fastboot is protocol used to update the flash filesystem in Android devices from a host over USB.
The command "fastboot.exe" you can run on your host after fastboot has been started on a device connected via USB.
e.g.
$ fastboot erase boot

Andriod Recovery:
The recovey of the mainstream andriod can provide some options to recovery your systems or factory-to-default, even
though it can load official ROM in the zip file of SD card and recovey the system.
ClockworkMod recovery is one of the widely used custom andriod recovery and it provide more options to recovery unofficial or official
ROM from the zip file of SD card.

CGI debug

2009-10-26T10:03:00.005+08:00

Web server will redirect STDIN, STDOUT and STDERR to CGI interface so the following function is used to print out debug messages from C code.

Function 1:

void debug_printf(const char *degmsg, ... )  
 {  
     int old = dup(STDOUT);  
     int ttyfd ;  
     int ret;  
     va_list ap;  
     char msg[512];  
     
     ttyfd = open("/dev/ttyS0", O_RDWR);  
     va_start(ap,degmsg);  
     ret = vsprintf(msg,degmsg,ap);  
     va_end(ap);  
     dup2(ttyfd, STDOUT);  
     close(ttyfd);  
     printf("%s",msg);  
     dup2(old, STDOUT);   }

Function 2:

void debug_printf(const char *degmsg, ... ){  
     va_list ap;  
     int ret;  
     FILE *con_ptr;  
     char msg[512];  
     
     va_start(ap,degmsg);  
     ret = vsprintf(msg,degmsg,ap);  
     va_end(ap);  
     con_ptr = fopen("/dev/ttyS1","w+");;      
     if (!con_ptr) {  
         perror("fopen");  
     }  
     fprintf(con_ptr,"%s",msg);  
     fflush(con_ptr);  
     fclose(con_ptr);  
 }

How to mount JFFS2 image

2009-10-01T01:38:00.002+08:00

Use memory to emulate the MTD device
mknod /tmp/mtdblock0 b 31 0
modprobe mtdblock
modprobe mtdram total_size=65536 erase_size=256

modprobe jffs2

dd if=image.jffs2 of=/tmp/mtdblock0

mkdir /mnt/jffs2
mount -t jffs2 /tmp/mtdblock0 /mnt/jffs2

IPV6 DHCPV6 Configuration

2009-07-03T10:45:00.001+08:00

Router Advertisement Daemon (radvd)
/etc/radvd.conf

interface eth0 {
  AdvSendAdvert on;
  MinRtrAdvInterval 3;
  MaxRtrAdvInterval 10;
  prefix 2001:0db8:0100:f101::/64 {
   AdvOnLink on;
   #Disable Stateless Address Autoconfiguration
   #AdvAutonomous on;
   AdvRouterAddr on;
  };
};

Wide-DHCPv6
Server configuration: dhcp6s.conf

option domain-name-servers 2001:470:1f01:2191::1 2001:470:1f01:2191::2;
option domain-name "dean.net";
interface eth0{
  address-pool pool1 3600;
};
pool pool1 {
  range 2001:5c0:1101:b700::1000 to 2001:5c0:1101:b700::2000 ;
};
host host0 {
  duid 00:00:00:00:a0:a0;
  prefix 3ffe:ffff:102::120/64 infinity;
};

Client configuration
DHCPV6 client for the stateful autoconfigutation

interface eth0 {

send ia-na 0;

request domain-name-servers;

request domain-name;

script "/tmp/dean/dhcp6c-script";

};

id-assoc na 0 {

# non-temporary addresses

};

DHCPV6 client for the stateless autoconfigutation

interface eth0

{

information-only;

request domain-name-servers;

request domain-name;

script "/tmp/dean/dhcp6c-script";

};

DHCPV6 script

update DNS in resolv.conf

#!/bin/sh

if [ -n "$new_domain_name" -o -n "$new_domain_name_servers" ]; then

new_resolv_conf=/tmp/resolv.conf.dhcp6c-new

rm -f $new_resolv_conf

if [ -n "$new_domain_name" ]; then

echo search $new_domain_name >> $new_resolv_conf

if [ -n "$new_domain_name_servers" ]; then

for nameserver in $new_domain_name_servers; do

echo nameserver $nameserver >> $new_resolv_conf

done

# To preserve IPv4 informations...

cat /etc/resolv.conf >> $new_resolv_conf

mv -f $new_resolv_conf /etc/resolv.conf

exit 0

Shell script tricks

2009-06-25T14:32:00.002+08:00

1. The array of shell script

names=( Jennifer Tonya Anna Sadie )
for name in ${names[@]}
do
   echo $name
done

names=( Jennifer Tonya Anna Sadie )
for (( i = 0 ; i &lt; ${#names[@]} ; i++ ))
do
    echo ${names[$i]}
done

2. Variable substitution for shell script

$DEVICE0=eth0
$echo "Configure interface " ${!DEVICE${i}}

$n=1
$ eval echo \${$n}

$ n="date"
$ echo $($n)

Output :Wed May 21 20:39:00 EEST 2008
3. Increment i in the while loop

i=$(($i+1))
i=`expr i + $i`

Re-entrant vs Thread safe

2009-06-15T16:49:00.002+08:00

Both concepts of reentrancy and thread safety relate to the way functions handle resources. However, they are not the same. While the concept of reentrancy can affect the external interface of a function, thread safety only concerns the implementation of the function and not its external interface.

In most cases, to make a non-reentrant function reentrant, its external interface must be modified such that all data is provided by the caller of the function.

To make a thread-unsafe function thread-safe, only the implementation needs to be changed, usually by addingsynchronization blocks to protect shared resources from concurrent accesses by different threads.

Therefore, reentrancy is a more fundamental property than thread-safety and by definition, leads to thread-safety: Every reentrant function is thread-safe; however, not every thread-safe function is reentrant.

Reference from http://en.wikipedia.org/wiki/Reentrant_(subroutine)

How to show the page table entry

2009-06-09T15:05:00.003+08:00

excerpt from arch/arm/mm/fault.c

void show_pte(struct mm_struct *mm, unsigned long addr)
{
       pgd_t *pgd;

       if (!mm)
               mm = &init_mm;

       printk(KERN_ALERT "pgd = %p\n", mm->pgd);
       pgd = pgd_offset(mm, addr);
       printk(KERN_ALERT "[%08lx] *pgd=%08lx", addr, pgd_val(*pgd));

       do {
               pmd_t *pmd;
               pte_t *pte;

               if (pgd_none(*pgd))
                       break;

               if (pgd_bad(*pgd)) {
                       printk("(bad)");
                       break;
               }

               pmd = pmd_offset(pgd, addr);
#if PTRS_PER_PMD != 1
               printk(", *pmd=%08lx", pmd_val(*pmd));
#endif

               if (pmd_none(*pmd))
                       break;

               if (pmd_bad(*pmd)) {
                       printk("(bad)");
                       break;
               }

#ifndef CONFIG_HIGHMEM
               /* We must not map this if we have highmem enabled */
               pte = pte_offset_map(pmd, addr);
               printk(", *pte=%08lx", pte_val(*pte));
               printk(", *ppte=%08lx", pte_val(pte[-PTRS_PER_PTE]));
               pte_unmap(pte);
#endif
       } while(0);

       printk("\n");
}

crontab

2009-06-09T13:31:00.001+08:00

Crontab command

#export to the file

crontab -l > filename

# import from the file

crontab filename

# import from the file for the specific user

crontab -u user filename

# edit

crontab -e

# delete all

crontab -r

Crontab special usage

Entry	Description	Equivalent To
@reboot	Run once, at startup.	None
@yearly	Run once a year	0 0 1 1 *
@annually	(same as @yearly)	0 0 1 1 *
@monthly	Run once a month	0 0 1 * *
@weekly	Run once a week	0 0 * * 0
@daily	Run once a day	0 0 * * *
@midnight	(same as @daily)	0 0 * * *
@hourly	Run once an hour	0 * * * *

reference from http://en.wikipedia.org/wiki/Cron

Crontab Example

# .---------------- minute (0 - 59) 
# |  .------------- hour (0 - 23)
# |  |  .---------- day of month (1 - 31)
# |  |  |  .------- month (1 - 12) OR jan,feb,mar,apr ... 
# |  |  |  |  .---- day of week (0 - 6) (Sunday=0 or 7)  OR sun,mon,tue,wed,thu,fri,sat 
# |  |  |  |  |
# *  *  *  *  *  command to be executed

min	hour	day/month	month	day/week	Execution time
30	0	1	1,6,12	*	-- 00:30 Hrs on 1st of Jan, June & Dec.
:
0	20	*	10	1-5	--8.00 PM every weekday (Mon-Fri) only in Oct.
:
0	0	1,10,15	*	*	-- midnight on 1st ,10th & 15th of month
:
5,10	0	10	*	1	-- At 12.05,12.10 every Monday & on 10th of every month
:

*/8 * * * * root init 6

After 8 minutes , execute "reboot" command

ps: "*/8" in the minute time field is equivalent to "0,8,16,24,32,48,56"

Linux 2.6 Driver Template

2009-06-08T16:19:00.004+08:00

#include <linux/module.h>
#include <linux/config.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/ioport.h>
#include <asm/io.h>

#include <linux/fs.h>
#include <linux/cdev.h>
#include <asm/uaccess.h>

typedef struct
{
 void **data;
 struct cdev *cdev ;
  
}DBG_Dev_Tag;

#define DBG_MAJOR         111
#define DBG_MINOR          1
#define MAXDEVICENUM 1

#define DEBUG_IOC_MAGIC 'D'
#define DEBUG_IOCSHOWDEB    _IOR(DEBUG_IOC_MAGIC,   1, int)

DBG_Dev_Tag *DBG_devices;


int dbg_major = DBG_MAJOR;
int dbg_minor;

static struct file_operations DBG_fops =
{
.ioctl   = DBG_ioctl,
.read    = DBG_read,
.write   = DBG_write,
.open    = DBG_open,
.release = DBG_release,
};

int DBG_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg)
{
     struct net_device *dev = &_wpcm450_netdevice;
  
     switch (cmd)
     {
         case DEBUG_IOCSHOWDEB:
                 //show something
              
                     break;
                default:
                     break;
     }
  
     return 0;
}

ssize_t DBG_read (struct file *filp, char *buf, size_t count, loff_t *offset)
{
 return 0;
}

ssize_t DBG_write (struct file *file, const char *buf, size_t count, loff_t *offset)
{
 return 0;
}

static int DBG_open(struct inode *inode, struct file *filp)
{
     DBG_Dev_Tag *dev;
  
     dev = container_of (inode->i_cdev,DBG_Dev_Tag,cdev);
  
     filp-> private_data = dev;

 return 0;
}

static int DBG_release(struct inode *inode, struct file *filp)
{


 return 0;
}



static void dbg_setup_cdev(DBG_Dev_Tag *dev,int index)
{
      int err;
      int dev_id = MKDEV(dbg_major,dbg_minor + index );
   
      cdev_init(dev->cdev,&DBG_fops);
   
      dev->cdev->owner = THIS_MODULE;
   
      dev->cdev->ops = &DBG_fops;
   
      err = cdev_add(dev->cdev,dev_id,1);
   
      if (err)
              printk ("error %x adding dbg%x\n",err,index);
   
}


static int __init DBG_init(void)
{
int result;
dev_t dev_id;


DBG_devices = kmalloc (sizeof (DBG_Dev_Tag) * MAXDEVICENUM ,GFP_KERNEL);

if (DBG_devices == NULL)
{
          result = -ENOMEM;
          return result;
}

memset(DBG_devices, 0, MAXDEVICENUM * sizeof(DBG_Dev_Tag));

if (dbg_major)
{
             dev_id = MKDEV(dbg_major,dbg_minor);
          
             result = register_chrdev_region(dev_id, 1, "debug");
}
else
{
             result = alloc_chrdev_region(&dev_id,DBG_MINOR,1,"dbg");
                   dbg_major = MAJOR(dev_id);
}

if (result < 0 )
{
             printk ("can't get major %d\n",dbg_major);
             return result;
}
  
DBG_devices->cdev = cdev_alloc();

dbg_setup_cdev(DBG_devices,1);

 return 0;     
}

static void __exit DBG_exit(void)
{
 dev_t dev_id;

 kfree(DBG_devices);

 cdev_del(DBG_devices ->cdev);

 dev_id = MKDEV(dbg_major,dbg_minor);
 unregister_chrdev_region(dev_id,1);
 return;
}

MODULE_AUTHOR("XXXXXXXXXX");
MODULE_DESCRIPTION("Debug driver");
MODULE_LICENSE("GPL");

module_init(DBG_init);
module_exit(DBG_exit);

//**************************Makefile *******************************

KERNELDIR =   obj-m := test_drv.o

#combine two drivers into the one.

#test_drv-objs := testA_drv.o testB_drv.o

ifneq ($(KERNELRELEASE),)

CFLAGS +=  -D__KERNEL__ -DMODULE  -Wall -DEXPORT_SYMTAB -O2

else

all:

 $(MAKE) -C $(KERNELDIR) M=$(shell pwd) modules endif

TCP keepalive under linux

2009-06-05T10:32:00.003+08:00

TCP keepalive During TCP connection idle
Main goal:

Checking for dead peers
Preventing disconnection due to network inactivity- TCP connections through NATs or proxy but they keep limited memory resources (mantain a few TCP connections, discard old connections)

How to use TCP keepalive under Linux

tcp_keepalive_time - the interval between the last data packet sent (simple ACKs are not considered data) and the first keepalive probe; after the connection is marked to need keepalive
tcp_keepalive_intvl - the interval between subsequential keepalive probes, regardless of what the connection has exchanged in the meantime
tcp_keepalive_probes - the number of unacknowledged probes to send before considering the connection dead and notifying the application layer

procfs interface

echo 20 > /proc/sys/net/ipv4/tcp_keepalive_probes

echo 600 > /proc/sys/net/ipv4/tcp_keepalive_time

echo 60 > /proc/sys/net/ipv4/tcp_keepalive_intvl

sysctl interface

sysctl -w \

> net.ipv4.tcp_keepalive_time=600 \

> net.ipv4.tcp_keepalive_intvl=60 \

> net.ipv4.tcp_keepalive_probes=20

How to program network applications with TCP keepalive

System call :setsockopt(s, SOL_SOCKET, SO_KEEPALIVE, &optval, optlen)

Other three socket options for the current socket overide system-wide variables as the follwoing

TCP_KEEPCNT: overrides tcp_keepalive_probes

TCP_KEEPIDLE: overrides tcp_keepalive_time

TCP_KEEPINTVL: overrides tcp_keepalive_intvl
reference from http://tldp.org/HOWTO/html_single/TCP-Keepalive-HOWTO/#whatis

GDB Script file

2008-10-09T11:18:00.002+08:00

For Linux Applications

set solib-absolute-prefix /home/dean/rootfs/

set solib-search-path /home/dean/rootfs/lib/

target remote 192.168.38.38:1234

handle SIG32 nostop

For bootloader

Use JTAG (J-link) to debug bootloader ;take a example for u-boot

# J-LINK GDB SERVER initialization

# This connects to a GDB Server listening

# for commands on localhost at tcp port 2331

target remote 192.168.42.42:2331

# Set JTAG speed to 30 kHz

monitor speed 30

# Set GDBServer to big endian

monitor endian little

# Reset the chip to get to a known state.

monitor reset 1

#monitor WaitHalt 2000

# CPU core initialization (to be done by user)

# Set the processor mode

monitor reg cpsr = 0xd3

# Set auto JTAG speed

monitor speed auto

# Setup GDB FOR FASTER DOWNLOADS

set remote memory-write-packet-size 1024

set remote memory-write-packet-size fixed

# Load the program executable called "image.elf"

load /home/dean/u-boot-1.2.0/u-boot

#assign PC conter to the start of the program (address 0x01400004) saved in the flash

monitor reg pc = 0x01400004

#add symbol file to this flash start address (0x01400000) ;this context is the useless data

#for identification

add-symbol-file u-boot-1.2.0/u-boot 0x01400000

#set hardware breakpoint

monitor setBP 0x01400058

Compile GDB for arm and U-boot相關資料

2008-03-24T00:18:00.002+08:00

compile ARM gdb and insight
Environment
ubuntu 7.10
arm linux kernel 2.6.15.7
ARM gcc-3.4.2 and glibc-2.3.3
compile GDB and GDBServer

compile GDB

get termcap and build arm termcap library
moidfy Makefile
assign
CC=arm-linux-gcc
LD=arm-linux-ld
AR=arm-linux-ar
make;
copy libtermcap.a into the library of the toolchains and termcap.h into the include path of the toolchain
build GDB
./configure --host= i686-pc-linux-gnu --target=arm-linux ;make

compile GDBServer

CC=arm-linux-gcc AR= arm-linux-ar LD=arm-linux-ld ./configure --host= i686-pc-linux-gnu --target=arm-linux;make

compile Insight

./configure --host= i686-pc-linux-gnu --target=arm-linux --prefix=/usr/local/insight ;make;make install

燒Kernel的過程

boot# tftp 41000000 uImage

Using faradaynic#0 device

TFTP from server 192.168.42.50; our IP address is 192.168.42.51
Filename 'uImage'.
Load address: 0x41000000
Loading: #################################################################
done
Bytes transferred = 1090003 (10a1d3 hex)
boot# erase 14080000 141fffff

........................ done
Erased 24 sectors

boot# cp.b 41000000 14080000 10a1d3(image size)

環境變數的設定

setenv bootargs mem=36M console=ttyS1
root=/dev/nfs rw nfsroot=192.168.42.50:/home/dean/MyTMP/0.18/aspeed/rootfs ip=192.168.42.45:192.168.42.50:192.168.42.1.255.255.0.0:::eth0:off
格式如下:
ip=ipaddr:tftp_serverip:gatewayip:netmask:::網卡名稱:off

Add netconsole parameters as the below:

netconsole=@192.168.42.45/eth0,@192.168.42.46/

The kernel will throw the data of console to the remote pc

Please execute the command in the remote PC and show the console data

netcat -u -l -p 6666 -v

u-boot之mkimage的使用方式

[root@localhost tftpboot]#mkimage -A arm -O linux -T kernel -C none -a 0x30000 -e 0x30008000 -d zImage zImage.img

參數的意義：
-A :set architecture
-O :set OS
-T :set image type
-C :set compression type
-a :set load address
-e :set entry point
-n :set image name
-d :use image data
-x :set XIP (execute in place)

VIM的指令

2008-03-24T00:15:00.000+08:00

[VIM DIFF]

]c 跳到下一個差異點
[c 跳到上一個差異點

dp （diff "put"）把當前文件的內容複製到另一個文件
do  (diff "get") 把另一個文件的內容複製到當前行中

diffupdate 重新刷新比較結果
wqa （write, then quit all）儲存全部文件，然后離開
set diffopt=context:3 預設是會把不同之處上下各 6 行的顯示出來

zo （folding open）
zc （folding close）


[VIM]
VIM Registers 0 : For Yank operation
最近一次做 yank 動作所存進去的東西

VIM Registers [1-9] : for delete operation
di:顯示Registers 的內容
"Np N=1~9 會把Register的內容貼上
按一下.會依序貼上Register的內容

VIM Registers [a-z A-Z]:
使用者指定才會用到的東西
PS:小寫的[a-z]表示覆蓋 大寫的[A-Z]表示附加
ex:%s/pattern/y a =>%s/pattern/y A

"*p 把OS剪貼簿上的東西來取代選取的區域

[多行註解]
Ctrl+v進入Visual Block模式
選取要註解的那幾行(j向下、k向上)。
按下大寫I(d or x為刪除)，會進入編輯模式，輸入註解符號。
然後按下Esc，這時候剛才有選取的那幾行都會加上剛才輸入的字串

FIND的使用方式

2008-03-01T15:35:00.000+08:00

一、find 命令格式
1、find命令的一般形式為；
find pathname -options [-print -exec -ok ...]
2、find命令的參數；
pathname: find命令所查找的目錄路徑。例如用.來表示當前目錄，用/來表示系統根目錄。
-print： find命令將匹配的文件輸出到標準輸出。
-exec： find命令對匹配的文件執行該參數所給出的shell命令。相應命令的形式為'command' { } ;，注意{ }和；之間的空格。
-ok：和-exec的作用相同，只不過以一種更為安全的模式來執行該參數所給出的shell命令，在執行每一個命令之前，都會給出提示，讓用戶來確定是否執行。
3、find命令選項
-name
按照文件名查找文件。
-perm
按照文件權限來查找文件。
-prune
使用這一選項可以使find命令不在當前指定的目錄中查找，如果同時使用-depth選項，那麼-prune將被find命令忽略。
-user
按照文件屬主來查找文件。
-group
按照文件所屬的組來查找文件。
-mtime -n +n
按照文件的更改時間來查找文件， - n表示文件更改時間距現在n天以內，+ n表示文件更改時間距現在n天以前。find命令還有-atime和-ctime 選項，但它們都和-m time選項。
-nogroup
查找無有效所屬組的文件，即該文件所屬的組在/etc/groups中不存在。
-nouser
查找無有效屬主的文件，即該文件的屬主在/etc/passwd中不存在。
-newer file1 ! file2
查找更改時間比文件file1新但比文件file2舊的文件。
-type
查找某一類型的文件，諸如：
b - 塊設備文件。
d - 目錄。
c - 字符設備文件。
p - 管道文件。
l - 符號鏈接文件。
f - 普通文件。
-size n：[c] 查找文件長度為n塊的文件，帶有c時表示文件長度以字節計。
-depth：在查找文件時，首先查找當前目錄中的文件，然後再在其子目錄中查找。
-fstype：查找位於某一類型文件系統中的文件，這些文件系統類型通常可以在配置文件/etc/fstab中找到，該配置文件中包含了本系統中有關文件系統的信息。
-mount：在查找文件時不跨越文件系統mount點。
-follow：如果find命令遇到符號鏈接文件，就跟蹤至鏈接所指向的文件。
-cpio：對匹配的文件使用cpio命令，將這些文件備份到磁帶設備中。
另外,下面三個的區別:
-amin n
　　查找系統中最後N分鐘訪問的文件
　　-atime n
　　查找系統中最後n*24小時訪問的文件
　　-cmin n
　　查找系統中最後N分鐘被改變文件狀態的文件
　　-ctime n
　　查找系統中最後n*24小時被改變文件狀態的文件
　-mmin n
　　查找系統中最後N分鐘被改變文件數據的文件
　　-mtime n
　　查找系統中最後n*24小時被改變文件數據的文件
4、使用exec或ok來執行shell命令
使用find時，只要把想要的操作寫在一個文件裡，就可以用exec來配合find查找，很方便的
在有些操作系統中只允許-exec選項執行諸如l s或ls -l這樣的命令。大多數用戶使用這一選項是為了查找舊文件並刪除它們。建議在真正執行rm命令刪除文件之前，最好先用ls命令看一下，確認它們是所要刪除的文件。
exec選項後面跟隨著所要執行的命令或腳本，然後是一對兒{ }，一個空格和一個，最後是一個分號。為了使用exec選項，必須要同時使用print選項。如果驗證一下find命令，會發現該命令只輸出從當前路徑起的相對路徑及文件名。
例如：為了用ls -l命令列出所匹配到的文件，可以把ls -l命令放在find命令的-exec選項中
# find . -type f -exec ls -l { } \;
-rw-r--r-- 1 root root 34928 2003-02-25 ./conf/httpd.conf
-rw-r--r-- 1 root root 12959 2003-02-25 ./conf/magic
-rw-r--r-- 1 root root 180 2003-02-25 ./conf.d/README
上面的例子中，find命令匹配到了當前目錄下的所有普通文件，並在-exec選項中使用ls -l命令將它們列出。
在/logs目錄中查找更改時間在5日以前的文件並刪除它們：
$ find logs -type f -mtime +5 -exec rm { } \;
記住：在shell中用任何方式刪除文件之前，應當先查看相應的文件，一定要小心！當使用諸如mv或rm命令時，可以使用-exec選項的安全模式。它將在對每個匹配到的文件進行操作之前提示你。
在下面的例子中， find命令在當前目錄中查找所有文件名以.LOG結尾、更改時間在5日以上的文件，並刪除它們，只不過在刪除之前先給出提示。
$ find . -name "*.conf" -mtime +5 -ok rm { } \;
< rm ... ./conf/httpd.conf > ? n
按y鍵刪除文件，按n鍵不刪除。
任何形式的命令都可以在-exec選項中使用。
在下面的例子中我們使用grep命令。find命令首先匹配所有文件名為「 passwd*」的文件，例如passwd、passwd.old、passwd.bak，然後執行grep命令看看在這些文件中是否存在一個sam用戶。
# find /etc -name "passwd*" -exec grep "sam" { } \;
sam:x:501:501::/usr/sam:/bin/bash
二、find命令的例子；
1、查找當前用戶主目錄下的所有文件：
下面兩種方法都可以使用
$ find $HOME -print
$ find ~ -print
2、讓當前目錄中文件屬主具有讀、寫權限，並且文件所屬組的用戶和其他用戶具有讀權限的文件；
$ find . -type f -perm 644 -exec ls -l { } \;
3、為了查找系統中所有文件長度為0的普通文件，並列出它們的完整路徑；
$ find / -type f -size 0 -exec ls -l { } \;
4、查找/var/logs目錄中更改時間在7日以前的普通文件，並在刪除之前詢問它們；
$ find /var/logs -type f -mtime +7 -ok rm { } \;
5、為了查找系統中所有屬於root組的文件；
$find . -group root -exec ls -l { } \;
-rw-r--r-- 1 root root 595 10月 31 01:09 ./fie1
6、find命令將刪除當目錄中訪問時間在7日以來、含有數字後綴的admin.log文件。
該命令只檢查三位數字，所以相應文件的後綴不要超過999。先建幾個admin.log*的文件，才能使用下面這個命令
$ find . -name "admin.log[0-9][0-9][0-9]" -atime -7 -ok
rm { } ;
< rm ... ./admin.log001 > ? n
< rm ... ./admin.log002 > ? n
< rm ... ./admin.log042 > ? n
< rm ... ./admin.log942 > ? n
7、為了查找當前文件系統中的所有目錄並排序；
$ find . -type d sort
8、為了查找系統中所有的rmt磁帶設備；
$ find /dev/rmt -print
三、xargs
xargs - build and execute command lines from standard input
在使用find命令的-exec選項處理匹配到的文件時， find命令將所有匹配到的文件一起傳遞給exec執行。但有些系統對能夠傳遞給exec的命令長度有限制，這樣在find命令運行幾分鐘之後，就會出現溢出錯誤。錯誤信息通常是「參數列太長」或「參數列溢出」。這就是xargs命令的用處所在，特別是與find命令一起使用。
find命令把匹配到的文件傳遞給xargs命令，而xargs命令每次只獲取一部分文件而不是全部，不像-exec選項那樣。這樣它可以先處理最先獲取的一部分文件，然後是下一批，並如此繼續下去。
在有些系統中，使用-exec選項會為處理每一個匹配到的文件而發起一個相應的進程，並非將匹配到的文件全部作為參數一次執行；這樣在有些情況下就會出現進程過多，系統性能下降的問題，因而效率不高；
而使用xargs命令則只有一個進程。另外，在使用xargs命令時，究竟是一次獲取所有的參數，還是分批取得參數，以及每一次獲取參數的數目都會根據該命令的選項及系統內核中相應的可調參數來確定。
來看看xargs命令是如何同find命令一起使用的，並給出一些例子。
下面的例子查找系統中的每一個普通文件，然後使用xargs命令來測試它們分別屬於哪類文件
#find . -type f -print xargs file
./.kde/Autostart/Autorun.desktop: UTF-8 Unicode English text
./.kde/Autostart/.directory: ISO-8859 text在整個系統中查找內存信息轉儲文件(core dump) ，然後把結果保存到/tmp/core.log 文件中：
$ find / -name "core" -print xargs echo "" >/tmp/core.log
上面這個執行太慢，我改成在當前目錄下查找
#find . -name "file*" -print xargs echo "" > /temp/core.log
# cat /temp/core.log
./file6
在當前目錄下查找所有用戶具有讀、寫和執行權限的文件，並收回相應的寫權限：
# ls -l
drwxrwxrwx 2 sam adm 4096 10月 30 20:14 file6
-rwxrwxrwx 2 sam adm 0 10月 31 01:01 http3.conf
-rwxrwxrwx 2 sam adm 0 10月 31 01:01 httpd.conf
# find . -perm -7 -print xargs chmod o-w
# ls -l
drwxrwxr-x 2 sam adm 4096 10月 30 20:14 file6
-rwxrwxr-x 2 sam adm 0 10月 31 01:01 http3.conf
-rwxrwxr-x 2 sam adm 0 10月 31 01:01 httpd.conf
用grep命令在所有的普通文件中搜索hostname這個詞：
# find . -type f -print xargs grep "hostname"
./httpd1.conf:# different IP addresses or hostnames and have them handled by the
./httpd1.conf:# VirtualHost: If you want to maintain multiple domains/hostnames
on your
用grep命令在當前目錄下的所有普通文件中搜索hostnames這個詞：
# find . -name * -type f -print xargs grep "hostnames"
./httpd1.conf:# different IP addresses or hostnames and have them handled by the
./httpd1.conf:# VirtualHost: If you want to maintain multiple domains/hostnames
on your
注意，在上面的例子中，用來取消find命令中的*在shell中的特殊含義。

find命令配合使用exec和xargs可以使用戶對所匹配到的文件執行幾乎所有的命令。
四、find 命令的參數
下面是find一些常用參數的例子，有用到的時候查查就行了，像上面前幾個貼子，都用到了其中的的一些參數，也可以用man或查看論壇裡其它貼子有find的命令手冊
1、使用name選項
文件名選項是find命令最常用的選項，要麼單獨使用該選項，要麼和其他選項一起使用。
可以使用某種文件名模式來匹配文件，記住要用引號將文件名模式引起來。
不管當前路徑是什麼，如果想要在自己的根目錄$HOME中查找文件名符合*.txt的文件，使用~作為 'pathname'參數，波浪號~代表了你的$HOME目錄。
$ find ~ -name "*.txt" -print
想要在當前目錄及子目錄中查找所有的『 *.txt』文件，可以用：

$ find . -name "*.txt" -print
想要的當前目錄及子目錄中查找文件名以一個大寫字母開頭的文件，可以用：
$ find . -name "[A-Z]*" -print
想要在/etc目錄中查找文件名以host開頭的文件，可以用：
$ find /etc -name "host*" -print
想要查找$HOME目錄中的文件，可以用：
$ find ~ -name "*" -print 或find . -print
要想讓系統高負荷運行，就從根目錄開始查找所有的文件。
$ find / -name "*" -print
如果想在當前目錄查找文件名以兩個小寫字母開頭，跟著是兩個數字，最後是.txt的文件，下面的命令就能夠返回名為ax37.txt的文件：
$find . -name "[a-z][a-z][0--9][0--9].txt" -print
2、用perm選項
按照文件權限模式用-perm選項,按文件權限模式來查找文件的話。最好使用八進制的權限表示法。
如在當前目錄下查找文件權限位為755的文件，即文件屬主可以讀、寫、執行，其他用戶可以讀、執行的文件，可以用：
$ find . -perm 755 -print
還有一種表達方法：在八進制數字前面要加一個橫槓-，表示都匹配，如-007就相當於777，-006相當於666
# ls -l
-rwxrwxr-x 2 sam adm 0 10月 31 01:01 http3.conf
-rw-rw-rw- 1 sam adm 34890 10月 31 00:57 httpd1.conf
-rwxrwxr-x 2 sam adm 0 10月 31 01:01 httpd.conf
drw-rw-rw- 2 gem group 4096 10月 26 19:48 sam
-rw-rw-rw- 1 root root 2792 10月 31 20:19 temp
# find . -perm 006
# find . -perm -006
./sam
./httpd1.conf
./temp
-perm mode:文件許可正好符合mode
-perm +mode:文件許可部分符合mode
-perm -mode: 文件許可完全符合mode
3、忽略某個目錄
如果在查找文件時希望忽略某個目錄，因為你知道那個目錄中沒有你所要查找的文件，那麼可以使用-prune選項來指出需要忽略的目錄。在使用-prune選項時要當心，因為如果你同時使用了-depth選項，那麼-prune選項就會被find命令忽略。
如果希望在/apps目錄下查找文件，但不希望在/apps/bin目錄下查找，可以用：
$ find /apps -path "/apps/bin" -prune -o -print
4、使用find查找文件的時候怎麼避開某個文件目錄
比如要在/usr/sam目錄下查找不在dir1子目錄之內的所有文件
find /usr/sam -path "/usr/sam/dir1" -prune -o -print
find [-path ..] [expression] 在路徑列表的後面的是表達式
-path "/usr/sam" -prune -o -print 是 -path "/usr/sam" -a -prune -o
-print 的簡寫表達式按順序求值, -a 和 -o 都是短路求值，與 shell 的 && 和類似如果 -path "/usr/sam" 為真，則求值 -prune , -prune 返回真，與邏輯表達式為真；否則不求值 -prune，與邏輯表達式為假。如果 -path "/usr/sam" -a -prune 為假，則求值 -print ，-print返回真，或邏輯表達式為真；否則不求值 -print，或邏輯表達式為真。
這個表達式組合特例可以用偽碼寫為
if -path "/usr/sam" then
-prune
else
-print
避開多個文件夾
find /usr/sam ( -path /usr/sam/dir1 -o -path /usr/sam/file1 ) -prune -o -print
圓括號表示表達式的結合。
表示引用，即指示 shell 不對後面的字符作特殊解釋，而留給 find 命令去解釋其意義。
查找某一確定文件，-name等選項加在-o 之後
#find /usr/sam (-path /usr/sam/dir1 -o -path /usr/sam/file1 ) -prune -o -name "temp" -print
5、使用user和nouser選項
按文件屬主查找文件，如在$HOME目錄中查找文件屬主為sam的文件，可以用：
$ find ~ -user sam -print
在/etc目錄下查找文件屬主為uucp的文件：
$ find /etc -user uucp -print

為了查找屬主帳戶已經被刪除的文件，可以使用-nouser選項。這樣就能夠找到那些屬主在/etc/passwd文件中沒有有效帳戶的文件。在使用-nouser選項時，不必給出用戶名； find命令能夠為你完成相應的工作。

例如，希望在/home目錄下查找所有的這類文件，可以用：
$ find /home -nouser -print
6、使用group和nogroup選項
就像user和nouser選項一樣，針對文件所屬於的用戶組， find命令也具有同樣的選項，為了在/apps目錄下查找屬於gem用戶組的文件，可以用：
$ find /apps -group gem -print
要查找沒有有效所屬用戶組的所有文件，可以使用nogroup選項。下面的find命令從文件系統的根目錄處查找這樣的文件
$ find / -nogroup-print
7、按照更改時間或訪問時間等查找文件
如果希望按照更改時間來查找文件，可以使用mtime,atime或ctime選項。如果系統突然沒有可用空間了，很有可能某一個文件的長度在此期間增長迅速，這時就可以用mtime選項來查找這樣的文件。
用減號-來限定更改時間在距今n日以內的文件，而用加號+來限定更改時間在距今n日以前的文件。
希望在系統根目錄下查找更改時間在5日以內的文件，可以用：
$ find / -mtime -5 -print
為了在/var/adm目錄下查找更改時間在3日以前的文件，可以用：
$ find /var/adm -mtime +3 -print
8、查找比某個文件新或舊的文件
如果希望查找更改時間比某個文件新但比另一個文件舊的所有文件，可以使用-newer選項。它的一般形式為：
newest_file_name ! oldest_file_name
其中，！是邏輯非符號。
查找更改時間比文件sam新但比文件temp舊的文件：
例：有兩個文件
-rw-r--r-- 1 sam adm 0 10月 31 01:07 fiel
-rw-rw-rw- 1 sam adm 34890 10月 31 00:57 httpd1.conf
-rwxrwxr-x 2 sam adm 0 10月 31 01:01 httpd.conf
drw-rw-rw- 2 gem group 4096 10月 26 19:48 sam
-rw-rw-rw- 1 root root 2792 10月 31 20:19 temp
# find -newer httpd1.conf ! -newer temp -ls
1077669 0 -rwxrwxr-x 2 sam adm 0 10月 31 01:01 ./httpd.conf
1077671 4 -rw-rw-rw- 1 root root 2792 10月 31 20:19 ./temp
1077673 0 -rw-r--r-- 1 sam adm 0 10月 31 01:07 ./fiel
查找更改時間在比temp文件新的文件：
$ find . -newer temp -print
9、使用type選項
在/etc目錄下查找所有的目錄，可以用：
$ find /etc -type d -print
在當前目錄下查找除目錄以外的所有類型的文件，可以用：
$ find . ! -type d -print
在/etc目錄下查找所有的符號鏈接文件，可以用
$ find /etc -type l -print
10、使用size選項
可以按照文件長度來查找文件，這裡所指的文件長度既可以用塊（block）來計量，也可以用字節來計量。以字節計量文件長度的表達形式為N c；以塊計量文件長度只用數字表示即可。
在按照文件長度查找文件時，一般使用這種以字節表示的文件長度，在查看文件系統的大小，因為這時使用塊來計量更容易轉換。
在當前目錄下查找文件長度大於1 M字節的文件：
$ find . -size +1000000c -print
在/home/apache目錄下查找文件長度恰好為100字節的文件：
$ find /home/apache -size 100c -print
在當前目錄下查找長度超過10塊的文件（一塊等於512字節）：
$ find . -size +10 -print
11、使用depth選項
在使用find命令時，可能希望先匹配所有的文件，再在子目錄中查找。使用depth選項就可以使find命令這樣做。這樣做的一個原因就是，當在使用find命令向磁帶上備份文件系統時，希望首先備份所有的文件，其次再備份子目錄中的文件。
在下面的例子中， find命令從文件系統的根目錄開始，查找一個名為CON.FILE的文件。
它將首先匹配所有的文件然後再進入子目錄中查找。
$ find / -name "CON.FILE" -depth -print
12、使用mount選項
在當前的文件系統中查找文件（不進入其他文件系統），可以使用find命令的mount選項。
從當前目錄開始查找位於本文件系統中文件名以XC結尾的文件：
$ find . -name "*.XC" -mount -print

[Note]Shell Script變數

2008-03-01T12:09:00.000+08:00

${FNAME}
顯示變數值的全部。
/home/kenny/tmp/test.1.sh
${FNAME##/*/}
比對變數值開端﹐如果以 /*/ 開頭的話﹐砍掉最長的部份。 test.1.sh
${FNAME#/*/}
比對變數值開端﹐如果以 /*/ 開頭的話﹐砍掉最短的部份。 kenny/tmp/test.1.sh
${FNAME%.*}
比對變數值末端﹐如果以 .* 結尾的話﹐砍掉最短的部份。
/home/kenny/tmp/test.1
${FNAME%%.*}
比對變數值末端﹐如果以 .* 結尾的話﹐砍掉最長的部份。
/home/kenny/tmp/test
${FNAME/sh/bash}
如果在變數值中找到 sh 的話﹐將第一個 sh 換成 bash。
/home/kenny/tmp/test.1.bash
${FNAME//sh/bash}
如果在變數值中找到 sh 的話﹐將全部 sh 換成 bash。
/home/kenny/tmp/test.1.bash

不定參數的用法

2008-03-01T12:06:00.000+08:00

printf 的原型：
int printf( const char *format [, argument]... );
在format後面的參數不但不定個數且型態也是不定的。
這些參數是one bye one 的堆在stack裡面。
printf這個函式如何正確的取出這些參數？
秘訣就在 format，函式根據format裡的格式("%d %f...")
依序把堆在stack裡的參數取出。而這取出的動作就是用到
va_arg, va_end, va_start這三個macro再加上va_list。
va_list 事實上是一個 char * 的型態：
typedef char * va_list;
其它的三個macro的例子(不同的平台會有不太一樣的macro)
/* A guess at the proper definitions for other platforms */
#define _INTSIZEOF(n) ( (sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1) )

#define va_start(ap,v) ( ap = (va_list)&v + _INTSIZEOF(v) )
#define va_arg(ap,t) ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )
#define va_end(ap) ( ap = (va_list)0 )

這三個macro若看得懂，對了解它們的運作會很有幫助；看不太懂也沒關係
，看一下下面的說明也差不可以了。
首先 va_start 把取出的指標(va_list)指到第一個不定參數。
然後就可以用 va_arg 以指定的型態從va_list取出資料並把va_list
指標移到下一個位置(例如取走了一個int 4 bytes 的資料， va_list便會加 4)
當取完資料後便可使用 va_end 把 va_list 歸零(這個macro應看得懂吧)。
其實對大部份的應用來說 va_end 做不做是沒太大的關係的。

下面是一個不定參數函式的範例(轉載自MSDN)：
int average( int first, ... )
{
int count = 0, sum = 0, i = first;
va_list marker;

va_start( marker, first ); /* Initialize variable arguments. */
while( i != -1 )
{
sum += i;
count++;
i = va_arg( marker, int);
}
va_end( marker ); /* Reset variable arguments. */
return( sum ? (sum / count) : 0 );
}

註：_INTSIZEOF 是 int size memory alignment，如果你不知那是什麼
　　就把　_INTSIZEOF 看成這樣的定義會比較容易理解：
#define _INTSIZEOF(n) sizeof(n)
為什麼不直接用sizeof(n)就好了，使用 macro 是為了跨平台時能保持運
作正確。若傳了一個2 bytrs的不定參數(如 short)，但在一個 32 bits的
平台推入堆疊就會是4個bytes(32 bits)不是2 bytes，所以參數的取出
就要非常的小心。使用_INTSIZEOF 在於保證引數指標移動的正確。

#define _INTSIZEOF(n) ( (sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1) )

令N=sizeof(n)+sizeof (int)-1
X=sizeof()int
若X為2之倍數

_INTSIZEOF(n)可簡化為N&~(X-1)

而原式為N-N%X，以下證明
N&~(X-1)=N-N%X
IF X=1
N&~(1-1)=N&~(0xFFFF..F)=N-N%1

IF X=2
N&~(2-1)=N&~(0xFFFF...FE)=N-N%2

IF X=4
N&~(4-1)=N&~(0xFFFF...FC)=N-N%4

目的為了讓_INTSIZEOF(n)成為X之倍數，也就是sizeof(int)之倍數

Memory Aligment

2008-03-01T12:04:00.000+08:00

對一個 16位元的系統來說，意味著，系統有16條data bus，各能存取一個
bit資料。
16位元當然就是2bytes,正如我們2個一數，數數會是2,4,6,8一樣，address
也不會(也不需要)出現奇數位置1,3,5,7...
現在來看看硬體存取一個byte在奇偶數地址的情況：
1.
要取偶數位置E時，會抓到 (E,E+1)一個WORD(因為data bus是16bits)，
因為E是在Lo Byte 所以硬體只要把 Hi Bytes 拋棄掉就成了。
2.
要取奇數位置O時，會抓到 (O-1,O)一個WORD(因為data bus
是16bits)，因為O是在Hi Byte 所以硬體得要把 Hi Bytes 搬到 Lo Bytes
才能算完成存取。

看到奇數地址存取會比偶數地址麻煩了嗎？差一點點而已有什麼關係？
好吧！我們再來看看硬體存取一個WORD在奇偶數地址的情況：
3.
要取偶數位置(E,E+1)時，會抓到 (E,E+1)一個WORD，這樣就完成
存取了。
4.
要取奇數位置(O,O+1)時，要先抓到 (O-1,O)取得Lo Byte O，然後
再抓(O,O+1)得到 Hi Byte(O+1)，最後合併(O,O+1)才算完成一個奇數
位址WORD的存取。

比較一下3,4，你就不會說只差一點點了吧！？
在32位元和64位元的系統，可以類推。這也是為什麼很多編譯器會預設
把變數位置調整在 2/4/8 倍數上來得到較佳的存取效率。
但這樣做會使像結構的資料大小意外的變化，若是某個結構的大小是很重要
的，你就必需找出編譯器相關的設定或directive(如VC的pack)來控制
aligment。

多維動態陣列

2008-03-01T12:03:00.000+08:00

多維動態陣列在 C 中大概只能用 malloc，但這在一維時尚
不構成問題，但需要多維陣列時怎麼辦呢？這算是程式論壇
最常被問到的問題之一了。
我把它整理了相關的回覆，都只用二維做說明，更多維的陣列
類推即可。
就從 C 談起吧！

動態產生一個[m][n]陣列 Array 的方法

code:------------------------------------------------------------------
int i;
int **Array;
Array= (int **)malloc(m*sizeof(void *));
for (i=0; i<m; i++)
Array=(int *)malloc(n*sizeof(int *));
--------------------------------------------------------------------------

這樣你就有一個 int Array[m][n]; 可以用了
是C 喔！不是 C++
但這不夠好，若你要的是一個較大的mXn陣列，那麼太多的malloc
會使記憶體碎片化(memory fragment)！沒關係，窮則變，變則通！
問題既出在for loop不斷的 memory allocation，就從那兒下手：

code:---------------------------------------------------------------------
int i;
int **Array, *pData;
Array= (int **)malloc(m*sizeof(int *));
pData= (int *)malloc(m*n*sizeof(int));
for (i=0; i<m; i++, pData+=n)
Array[i]=pData;
---------------------------------------------------------------------------

注意到嗎？這次只用了二次的malloc。
當要release memory也只要free Array[0] 和 Array 就成了！
(注意先free Array[0] 再 free Array)
如果嫌兩個alloc/free還是太多，也可簡單併成一個：

code:-----------------------------------------------------------------------
int i;
int **Array, *pData;
Array= (int **)malloc(m*sizeof(int *)+m*n*sizeof(int));
for (i=0,pData= (int *)(Array+m); i<m; i++, pData+=n)
Array[i]=pData;
----------------------------------------------------------------------------

要 free 時只要 free Array 就行了，帥吧？
如果用的是C++，那可用的方法就更多了！

《幼幼班》嘗試錯誤的階段
?> int Array[][] = new int [10][20];//這樣行ㄇ？
當然不行！ int Array[][]不是一個指標，而且只能有
一維為不定大小。

《小班》終於會從1數到100了
?> 那...
?> int *Array[] = new int [10][20];//這樣行ㄇ？
有點想法了！但可惜的是 '*' 在 C++的語法是修飾前面的
識別字，所以 int *Array[]的意思是 "Array是一個 int 指標
的一維陣列！"

如果能使那個 '*' 以獨立指標型態去宣告Array，就會變成
"Array是一個指標，指向一維 int 的陣列"，而我們知道指標
本身就可以當做一維的陣列，那麼是不是就成了"Array是一個二維
的int陣列"？
對了！這正是我們要的！問題是怎麼讓'*'成為獨立指標型態，
不會去修飾前面的int識別字？答案是使用括號：
int (*Array)[20] = new int [10][20];//這是正解！

但問題又來了， new 運算子可以使用 new int [m][n]，但
int (*Array)[20] 的 [20]卻沒辦法以 [n] 來取代，所以就
沒辦法做到不定大小的宣告了。所以這只能算是小班的答案，
要做到不定大小的動態多維宣告，加上 STL 的運用，是不錯
的想法。

《中班》vector 模板的運用
vector<int> *array=new vector<int>[m];
for (int i=0; i<n; i++) array[i].reserve(n);
嘿嘿...不錯吧！？不定大小的二維陣列，而且每個維度還
可以隨時調整大小喔！
不過還是有缺點ㄟ！！那行 for loop 看起來有點礙眼，不能
拿掉嗎？拿掉的話，基本上Array 還是二維陣列，但第二維
並沒有預留空間放東西你可以用push.back等成員函式來增加
空間和存放data，但不能在還沒有空間時使用像
array[5][3]=3; 這種陣列的存取方式。沒更好的方法了嗎？
vector 不是有預留空間大小的建構子嗎？像一維的宣告：
vector<int> *Array= new vector <int>(n);
//這不是預留了 n 個元素的陣列了嗎？
只可惜，這是一維的宣告，若你嘗試做這樣的宣告：
vector<int> *Array= new vector <int>[m](n);
編譯器會給你無情的嘲諷：陣列不能呼叫帶參數的建構子！
這是很令人失望的！為十麼不行？不是邏輯的問題，或許下
一版本的C++會可以這樣宣告吧！但為今之計只能自力救濟
了。

《大班》使用模板在模版中
仔細觀察下面的宣告：
vector<vector<int> > Array(m, vector<int>(n));

Makefile的一些用法

2008-03-01T12:02:00.000+08:00

make 內建變數的涵義

Target:Prequeite

$@ Target的檔名

$% 程式庫成員中的檔名元素

$< 第一個prequeite的檔名

$? Timestamp 在Target之後的Prequeite

$^ 所有的Prequeite的檔名但不包含重複部分

$+ 所有的Prequeite的檔名

$* Target的主檔名

$(@D) $(<D) 指的是Target的檔案路徑

$(@F) $(<F) 指的是Target的檔案名稱

OBJS = foo.o bar.o
CC = gcc
CFLAGS = -Wall -O -g

myprog : $(OBJS)
$(CC) $^ -o $@

foo.o : foo.c foo.h bar.h
$(CC) $(CFLAGS) -c $< -o $@
bar.o : bar.c bar.h
$(CC) $(CFLAGS) -c $< -o $@

.clean: 　　

rm edit $(objects)

更安全的作法PHONY表示clean為一個偽裝目標，也就是說，不管clean這個目標發生什麼問題，都繼續執行　
.PHONY : clean
clean : 　　
-rm edit $(objects)

patsubst是把第二個參數換成第一個參數中所指定的pattern，而第三個參數則是代表所有要代換的東西
%.o:%.c ${CC} ${CLAGS} -o ${patsubst %.o,%,$@} ${STATIC_LIBS}
${CC} ${CLAGS} -o ${@:.o=.cgi} ${STATIC_LIBS}

通配符自動在規則中進行。但是在變量賦值的和函數的參數中通配符不會擴展，如果在這些情況下需要通配符擴展，
必須使用'wildcard'函數。語法如下：
$(wildcard PATTERN...)
這個在makefile任何地方出現的字符串，會被匹配任何一個文件名格式的以空格隔開的現有文件列表替換。
如果沒有任何文件匹配一個模式，這個模式從'wildcard'的輸出中忽略，注意，這和上述的通配符的處理是不一樣的。
『wildcard'函數的一個功能是找出目錄中所有的'.c'文件：
$(wildcard *.c)
可以通過替換後綴'.c'為'.o'從C文件列表得到目標文件的列表：
$(patsubst %.c,%.o,$(wildcard *.c))
這樣，上節中的makefile改寫為：
objects := $(patsubst %.c,%.o,$(wildcard *.c))
foo : $(objects) cc -o foo $(objects)

這個makefile利用了編譯C程序的隱含規則，所以不需要對編譯寫出顯式的規則。
（':='是'='的一個變體）注意：'PATTERN'是大小寫敏感的。