[技術] 在Linux上用C撰寫RS-232通訊程式

Written on 12:41 下午 by Yu Lai

最近工作上玩到的，總結一下當Note吧。
主要是Ref: Serial Programming Guide for POSIX Operating Systems。
配合pthread把收跟送的部份分開，
以下是收的部份。

struct tty_q {
 int len;
 unsigned char buff[TTY_Q_SZ]; /* TTY_Q_SZ=1024 */
} tty_q;

int tty_fd;
pthread_mutex_t tty_mutex;

void * rs232com(void *arg) {

 int c=0, len;
 struct termios oldtio, newtio;
 char buf[256];

 pthread_detach(pthread_self());
 pthread_mutex_init(&tty_mutex, NULL);

 /* Open the rs232 port */
 tty_fd = open(TTYDEVICE, O_RDWR|O_NOCTTY);
 if (tty_fd < 0) {
  perror(TTYDEVICE);
  exit(1);
 }

 /* Get the current options */
 tcgetattr(tty_fd, &oldtio);

 /* Set new options */
 bzero(&newtio, sizeof(newtio));
 newtio.c_cflag = BAUDRATE|CS8|CLOCAL|CREAD;
 newtio.c_iflag = IGNPAR;
 newtio.c_oflag = 0;
 newtio.c_lflag = ICANON;
 
 /* Set the options */
 tcflush(tty_fd, TCIFLUSH);
 tcsetattr(tty_fd, TCSANOW, &newtio);

 while(1) {
  len = read(tty_fd, buf, 255);
  buf[len]=0;

  MCP_LOG("RS-232 recv, len=%03d, buf=%s\n", len, buf);

  pthread_mutex_lock(&tty_mutex);

  if(tty_q.len + len > TTY_Q_SZ) {
   memset(tty_q.buff, 0, TTY_Q_SZ);
   tty_q.len = 0;
  }

  memcpy(&tty_q.buff[tty_q.len], buf, len);
  tty_q.len += len;

  pthread_mutex_unlock(&tty_mutex);
 }
}

而送的部份在這裡。

int rs232send(U8 * buf) {

 pthread_mutex_lock(&tty_mutex);

 memset(tty_q.buff, 0, TTY_Q_SZ);
 tty_q.len = 0;

 pthread_mutex_unlock(&tty_mutex);

 return write(tty_fd, buf, strlen(buf));

}

Posted in 技術, C, Linux, RS-232 | 0 意見

[技術] 在Linux中透過ioctl來設定ARP Table

Written on 11:39 上午 by Yu Lai

一般我們在Linux上可以使用arp這個指令來顯示或設定ARP Table。
而在程式中如果要操作系統的ARP Table的話，除了用system()來呼叫
arp指令外，也可以透過socket fd所提供的ioctl命令來達成，共有3種，
分別是SIOCSARP(設定ARP mapping)，SIOCDARP(刪除ARP mapping)，
SIOCGARP(獲取ARP mapping)。在操作上需配合struct arpreq，
定義如下：

struct arpreq {
 struct sockaddr   arp_pa;      /* protocol address */
 struct sockaddr   arp_ha;      /* hardware address */
 int               arp_flags;   /* flags */
 struct sockaddr   arp_netmask; /* netmask of protocol address */
 char              arp_dev[16]; 
};

其中，arp_pa必須是AF_INET的socket。而指定的network device
也必須填入arp_dev中。而arp_flag的value定義如下：
ATF_COM = Lookup complete
ATF_PERM = Permanent entry
ATF_PUBL = Publish entry
ATF_USETRAILERS = Trailers requested
ATF_NETMASK = Use a netmask
ATF_DONTPUB = Don't answer

使用SIOCSARP命令時，需設定arpreq的arp_pa，arp_ha和arp_flags。
此時若ARP Table己經存在這筆IP位址，它會將它取出更新。若不存在，則新增。

使用SIOCDARP命令時，只需設定arpreq中的arp_pa和arp_dev，kernel會
根據arp_pa的IP位址從ARP Table的hash中取出，並將其state更新為NUD_FAILED。
這樣在下一次ARP GC時就會被清掉。

使用SIOCGARP命令時，只需要設定arpreq中的arp_pa即可。不過一般我們
不會透過SIOCGARP命令，而是使用/proc/net/arp直接讀取。

以下是SIOCSARP的範例程式：

#include <sys/ioctl.h> 
#include <sys/socket.h> 
#include <net/if.h> 
#include <netinet/if_ether.h>
#include <netinet/in.h>

int set_arp(char * ip, char * mac, char * dev) {
 
 struct arpreq req;
 struct sockaddr_in addr;
 int sockfd, rc;
 unsigned int s_addr;
  
 sockfd = socket(AF_INET, SOCK_DGRAM, 0);
 if(sockfd < 0) {
  return 1;
 }

 /* Inet sockaddr_in struct */
 memset(&addr, 0, sizeof(struct sockaddr_in));
 addr.sin_family = AF_INET;
 addr.sin_addr.s_addr = inet_addr(ip);
 
 /* ARP arpreq struct */
 memset(&req, 0, sizeof(req));
 memcpy(&req.arp_pa, &addr, sizeof(struct sockaddr));
 memcpy(req.arp_ha.sa_data, mac, 6);
 req.arp_flags = ATF_PERM | ATF_COM;
 strcpy(req.arp_dev, dev);
 
 rc = ioctl(sockfd, SIOCSARP, &req);
 close(sockfd);
 
 return rc;
 
}

Posted in C, Linux, Network | 0 意見

[技術] 在Makefile中加入Check file size的機制

Written on 9:11 下午 by Yu Lai

今天在porting新板子的loader，
因為flash memory layout的關係，
整個loader大小才128kb。
而我沒注意到Image Size己經暴了一點，
沒想到flash還是寫成功了，
結果reboot後跑起來果然怪怪的。
連基本的printf都怪怪的，囧～
只能拿JTAG來救了，唉。

於是我想到要在Makefile裡加入檢查檔案大小的機制，
讓make時適時的提醒我檔案大小是否ok？

結果讓我搞了一個快下午還搞不定 @_@，
我試了老半天還是不知該怎麼把bash的if加到Makefile裡。
最後到GNU Makefile仔細的找了找才發現原來是我想錯了，
Makefile裡的command部份其實是呼叫sub shell執行命令，
然後判斷其return value。
所以要加入檢查檔案大小的機制連if都不必用到，
直接用test就可以了。

e.g.

check:
 @echo -e "\nCheck redboot.img file size ....."
 @test `stat -c %s boot/install/bin/redboot.img` -lt 129792
 @echo "Ok."

Posted in 技術, C, Embedded, Makefile | 0 意見

[技術] 在Linux User-Space下實做L3 Protocol

Written on 4:01 下午 by Yu Lai

其實這篇應該是要接續上一篇寫的，因為用到的方法是和上一篇相同
的，但由於主題比較不太一樣，所以就分開來寫了。

在Linux中，一般要實做新的L3 protocol，大都是從kernel去下手，
效能較好，能存取的資源也比較多。但在開發embedded system下往
往有專案時間壓力以及軟體彈性的需求，去改kernel來達到這些要求
也就有點不太實際。所以我採用了在上一篇中使用的方法，也就是
Raw Socket與LPF(Linux Packet Filter)來完成一個L3 Protocol的
實做。

和Sniffer一樣的，我們使用了Raw Socket與LPF，比較不同的地方在
於LPF所使用的Filter。由於我們的protocol是定義成採用0x1219的
ether type，所以在配合tcpdump生成BPF code時用了以下的指令。

# tcpdump -dd -s 2048 ether proto 0x1219
{ 0x28, 0, 0, 0x0000000c },
{ 0x15, 0, 1, 0x00001219 },
{ 0x6, 0, 0, 0x00000800 },
{ 0x6, 0, 0, 0x00000000 }

以下是部份的實做的程式碼：

#include <stdio.h>
#include <fcntl.h>
#include <pthread.h>
#include <signal.h>
#include <dirent.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <net/if.h>
#include <netinet/in.h>
#include <linux/types.h>
#include <linux/if_ether.h>
#include <linux/if_packet.h>
#include <linux/filter.h>
#include <linux/sockios.h>

void *mcpV2Handler(void *arg) {

 int sock, n;
 int rr;
 U8 buf[2048];
 U8 tmp[8], tmpSlot;
 U8 lastBegMac[6];
 U32 lastBegTime = 0;
 U32 * pGroupKey;
 tMcpFrame *frame;
 tMcpPacket *packet;
 tMcpCardInfo *cardInfo;
 pthread_t mcpV2Sender_tid;
 pthread_t mcpV2TxRx_tid;
 struct sock_fprog filter;

 /* Using tcpdump to generate BPF code */
 /*
     # tcpdump -d -s 2048 ether proto 0x1219
     (000) ldh      [12]
     (001) jeq      #0x1219          jt 2    jf 3
     (002) ret      #2048
     (003) ret      #0
 */
 struct sock_filter bpf_code[]= {
  { 0x28, 0, 0, 0x0000000c },
  { 0x15, 0, 1, 0x00001219 },
  { 0x6, 0, 0, 0x00000800 },
  { 0x6, 0, 0, 0x00000000 }
 };

 filter.len = sizeof(bpf_code)/sizeof(bpf_code[0]);
 filter.filter = bpf_code;

 /* set detached thread */
 pthread_detach(pthread_self());

 if ((sock=socket(PF_PACKET, SOCK_PACKET, htons(ETH_P_ALL)))<0) {
  perror("socket");
  exit(1);
 }

 /* Attach the bpf filter to the socket */
 if (setsockopt(sock, SOL_SOCKET, SO_ATTACH_FILTER, &filter, sizeof(filter))<0){
  perror("setsockopt");
  close(sock);
  exit(1);
 }

 /* ----------- Start implement ----------- */

 while(1) {
  n = recvfrom(sock, buf, sizeof(buf), 0, NULL, NULL);
  if(n < 22) { /* 6+6+2+2+4+2+N */
   printf("invalid packet\n");
   continue;
  }

  frame = (tMcpFrame *)buf;

  if(memcmp(frame->srcAddr, myMac, 6) == 0)
   continue;

  MCP_LOG("Dump: %02x%02x%02x%02x%02x%02x|"
   "%02x%02x%02x%02x%02x%02x|"
   "%04x|%04x|%08x|%04x|"
   "%02x %02x %02x %02x %02x %02x %02x %02x %02x",
   frame->dstAddr[0], frame->dstAddr[1], frame->dstAddr[2], 
   frame->dstAddr[3], frame->dstAddr[4], frame->dstAddr[5],
   frame->srcAddr[0], frame->srcAddr[1], frame->srcAddr[2], 
   frame->srcAddr[3], frame->srcAddr[4], frame->srcAddr[5],
   ntohs(frame->etherType),
   ntohs(frame->mcpProtoType),
   ntohl(frame->groupKey),
   ntohs(frame->dataLength),
   frame->data[0], frame->data[1], frame->data[2], frame->data[3], 
   frame->data[4], frame->data[5], frame->data[6], frame->data[7], frame->data[8]);

  if(ntohs(frame->mcpProtoType) == 1 && ntohl(frame->groupKey) == myGroupKey) {
   /* blah blah */
   /* blah blah */
   /* blah blah */
  }

 }

 close(sock);

}

Posted in 技術, C, Linux, Network | 0 意見

[技術] 在Linux下實作Sniffer

Written on 1:39 下午 by Yu Lai

在這裡先感謝一下黃仁竑老師，因為這篇其實這是之前唸研究所時，
上課所要交的作業。沒想到最近在工作上也用到了，呵呵。

雖然在Linux下有許多好用的Sniffer工具，如: tcpdump 或 libpcap等。
但若了解如何自己實作Sniffer，對於實作網路相關的protocol會有更深的了解。
在實作sniffer之前，在Linux下有幾個東西我們要先了解。

首先是raw socket，透過raw socket，可以讓我們從Layer 2(Ethernet)
的資料開始解讀，而不是已經被核心處理過的tcp/udp payload。

sock=socket(PF_PACKET, SOCK_RAW, htons(ETH_P_IP));

接著是LPF(Linux Packet Filter)，在Linux的kernel中，有個LPF的機制
可以預先設定過濾socket讀取到的內容。當然這個在實作sniffer不是必要
的，我們大可在讀取資料後自行filter掉非必要的data。但透過LPF，可以
讓我們專心在實作資料的呈現上。
而LPF的使用，我們可以使用一種pseudo-machine code language叫作BPF。
它是一種用來描述filter的語言，我們可以透過tcpdump這支好用的工具來
產生bpf的sample code。使用方法就是使用tcpdump -d 和
tcpdump -dd 來生出C使用的code。另外，tcpdump所生成的
sample code預設只會抓取96個字元，所以要再加上-s參數來指定抓取的數量。

tcpdump -d -s 2048 tcp and host 140.123.230.166
(000) ldh [12]
(001) jeq #0x86dd jt 10 jf 2
(002) jeq #0x800 jt 3 jf 10
(003) ldb [23]
(004) jeq #0x6 jt 5 jf 10
(005) ld [26]
(006) jeq #0x8c7be6a6 jt 9 jf 7
(007) ld [30]
(008) jeq #0x8c7be6a6 jt 9 jf 10
(009) ret #2048
(010) ret #0

tcpdump -dd -s 2048 tcp and host 140.123.230.166
{ 0x28, 0, 0, 0x0000000c },
{ 0x15, 8, 0, 0x000086dd },
{ 0x15, 0, 7, 0x00000800 },
{ 0x30, 0, 0, 0x00000017 },
{ 0x15, 0, 5, 0x00000006 },
{ 0x20, 0, 0, 0x0000001a },
{ 0x15, 2, 0, 0x8c7be6a6 },
{ 0x20, 0, 0, 0x0000001e },
{ 0x15, 0, 1, 0x8c7be6a6 },
{ 0x6, 0, 0, 0x00000800 },
{ 0x6, 0, 0, 0x00000000 }

把Filter設到socket上。
struct sock_filter BPF_code[]= {
{ 0x28, 0, 0, 0x0000000c },
{ 0x15, 8, 0, 0x000086dd },
{ 0x15, 0, 7, 0x00000800 },
{ 0x30, 0, 0, 0x00000017 },
{ 0x15, 0, 5, 0x00000006 },
{ 0x20, 0, 0, 0x0000001a },
{ 0x15, 2, 0, 0x8c7be6a6 },
{ 0x20, 0, 0, 0x0000001e },
{ 0x15, 0, 1, 0x8c7be6a6 },
{ 0x6, 0, 0, 0x00000060 },
{ 0x6, 0, 0, 0x00000000 }
};
struct sock_fprog Filter;
Filter.len = 11;
Filter.filter = BPF_code;

setsockopt(sock, SOL_SOCKET, SO_ATTACH_FILTER, &Filter, sizeof(Filter))

最後是把網卡的promiscuos mode打開，網卡一般會比對dst mac和自己的
Mac Address，若不相同或不是broadcast的封包會被drop掉不處理。
若要實作sniffer，這個mode一定要打開，才能監聽到別人的封包。

strncpy(ethreq.ifr_name,"eth0",IFNAMSIZ);
ioctl(sock,SIOCGIFFLAGS,ðreq);
ethreq.ifr_flags|=IFF_PROMISC;
ioctl(sock,SIOCSIFFLAGS,ðreq);

以下是完整的sample code，不過年代久遠，也沒時間compile測試，
如有錯誤不能compile，請見諒。XD

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <linux/in.h>
#include <linux/if_ether.h>
#include <net/if.h>
#include <linux/filter.h>
#include <sys/ioctl.h>

int main(int argc, char **argv) {

  int sock, sock_server, sock_client, n, i;
  char buffer[2048];
  unsigned char *iphead, *ethhead, *tcphead;
  int addr_len;  
  struct sockaddr_in sa_cli;
  struct ifreq ethreq;
  FILE* fPtr;

  struct sock_filter BPF_code[]= {
    { 0x28, 0, 0, 0x0000000c },
    { 0x15, 8, 0, 0x000086dd },
    { 0x15, 0, 7, 0x00000800 },
    { 0x30, 0, 0, 0x00000017 },
    { 0x15, 0, 5, 0x00000006 },
    { 0x20, 0, 0, 0x0000001a },
    { 0x15, 2, 0, 0x8c7be6a6 },
    { 0x20, 0, 0, 0x0000001e },
    { 0x15, 0, 1, 0x8c7be6a6 },
    { 0x6, 0, 0, 0x00000800 },
    { 0x6, 0, 0, 0x00000000 }
  };
                    
  struct sock_fprog Filter; 
  
  Filter.len = 11;
  Filter.filter = BPF_code;
  
  if ((sock=socket(PF_PACKET, SOCK_RAW, htons(ETH_P_IP)))<0) {
    perror("socket");
    exit(1);
  }
  
  /* Set the network card in promiscuos mode */
  strncpy(ethreq.ifr_name,"eth0",IFNAMSIZ);
  if (ioctl(sock,SIOCGIFFLAGS,ðreq)==-1) {
    perror("ioctl (SIOCGIFCONF) 1");
    close(sock);
    exit(1);
  }
  ethreq.ifr_flags|=IFF_PROMISC;
  if (ioctl(sock,SIOCSIFFLAGS,ðreq)==-1) {
    perror("ioctl (SIOCGIFCONF) 2");
    close(sock);
    exit(1);
  }
  
  /* Attach the filter to the socket */
  if (setsockopt(sock, SOL_SOCKET, SO_ATTACH_FILTER, &Filter, sizeof(Filter))<0){
    int temp=sizeof(Filter);
    printf( "%d" , temp);
    perror("setsockopt");
    close(sock);
    exit(1);
  }
  
  /* Open the result file. */
  if ((fPtr = fopen("dump.txt", "w")) == NULL) {
    perror("fopen");
    close(sock);
    exit(1);
  }
  
  while (1) {
    n = recvfrom(sock, buffer, 2048, 0, NULL, NULL);
    printf("%d bytes read\n",n);
    
    /* Check to see if the packet contains at least 
    * complete Ethernet (14), IP (20) and TCP/UDP 
    * (8) headers.
    */
    if (n<42) {
     perror("recvfrom():");
     printf("Incomplete packet (errno is %d)\n", errno);
     close(sock);
     exit(0);
    }
 
    ethhead = buffer;
    printf("Source MAC address: %02x:%02x:%02x:%02x:%02x:%02x\n",
     ethhead[0], ethhead[1], ethhead[2], ethhead[3], ethhead[4], ethhead[5]);
    printf("Destination MAC address: %02x:%02x:%02x:%02x:%02x:%02x\n",
     ethhead[6], ethhead[7], ethhead[8], ethhead[9], ethhead[10], ethhead[11]);
    
    iphead = buffer+14; /* Skip Ethernet  header */
    if (*iphead==0x45) { /* Double check for IPv4 and no options present */
     printf("Source host %d.%d.%d.%d\n",
      iphead[12], iphead[13], iphead[14], iphead[15]);
     printf("Dest host %d.%d.%d.%d\n",
      iphead[16], iphead[17], iphead[18], iphead[19]);
     printf("Source,Dest ports %d,%d\n",
      (iphead[20]<<8)+iphead[21], (iphead[22]<<8)+iphead[23]);
     printf("Layer-4 protocol %d\n",
      iphead[9]);
    }
    
    tcphead = iphead+20;
    if (iphead[9] == 0x06) {
     printf("TCP Sequence Number: %x%x%x%x\n",
      tcphead[4], tcphead[5], tcphead[6], tcphead[7]);
     printf("TCP Acknowledgement Number: %x%x%x%x\n",
      tcphead[8], tcphead[9], tcphead[10], tcphead[11]);
     printf("TCP Header Length: %d\n",
      tcphead[12]>>4);
     printf("TCP Control Bits: %02x (UAPRSF)\n",
      tcphead[13]);
     printf("TCP Window Size: %d\n",
      (tcphead[14]<<8)+tcphead[15]);
     for(i=4*(tcphead[12]>>4);i<n-14-20;i++) {
      printf("%c", tcphead[i]);
     }
     printf("\n");
    }
  }

}

Ref:
http://www.linuxjournal.com/article/4659

Posted in 技術, C, Linux, Network | 1 意見

[技術] Linux下的Timer

Written on 10:36 上午 by Yu Lai

其實之前就有用到Timer，只是最近又再一次用到，所以把相關的部份整理一下。
在Linux下實做定時器有兩種方法，分別是alarm()和setitimer()，以下分別介紹：

1. alarm()
alarm()可以用來設定信號SIGALRM在指定的秒數後傳到目前的process。
使用起來比起setitimer較為簡單，但由於使用的單位是秒數，
所以如果不要求很精確的話，用alarm()配合signal()就夠了。

unsigned int alarm(unsigned int seconds)

alarm()用來設置信號SIGALRM在經過參數seconds指定的秒數後傳送給目前的process。
如果參數seconds為0，則之前設置的鬧鐘會被取消，並將剩下的時間返回，
如果之前未設鬧鐘則返回0。

void sigalrm_fn(int sig) {

  printf("alarm!\n");
  alarm(2);

  return;

}

int main(void) {

  signal(SIGALRM, sigalrm_fn);
  alarm(1);
  while(1) pause();

}

2. setitimer()
setitimer()比alarm功能強大，支持3種類型的Timer：
ITIMER_REAL : 以系統真實的時間來計算，它送出SIGALRM信號。
ITIMER_VIRTUAL : 以Process在User-Mode下花費的時間來計算，它送出SIGVTALRM信號。
ITIMER_PROF : 以Process在User-Mode下和Kernel-Mode下所費的時間來計算，它送出SIGPROF信號。

int setitimer(int which, const struct itimerval *value, struct itimerval *ovalue));

setitimer()第一個參數which指定定時器類型（上面三種之一）；
第二個參數是struct itimerval的一個instance；第三個參數可不做處理。
setitimer()調用成功返回0，否則返回-1。

struct itimerval {
struct timeval it_interval; /* timer interval */
struct timeval it_value; /* current value */
};

itimerval結構中的it_value是減少的時間，當這個值為0的時候就發出相應的信號。
然後再將it_value設置為it_interval值。也就是說如果itimerval.it_interval不為0，
則該定時器將持續有效(每隔一段時間就會發送一個信號)。

下面是關於setitimer的一個簡單示範，在該例子中，
每隔一秒發出一個SIGALRM，每隔0.5秒發出一個SIGVTALRM信號:

int sec;

void sigroutine(int signo) {

  switch (signo){
    case SIGALRM:
      printf("Catch a signal -- SIGALRM \n");
      signal(SIGALRM, sigroutine);
      break;
    case SIGVTALRM:
      printf("Catch a signal -- SIGVTALRM \n");
      signal(SIGVTALRM, sigroutine);
      break;
  }
  return;

}

int main() {

  struct itimerval value, ovalue, value2;
  sec = 5;

  printf("process id is %d\n", getpid());
  signal(SIGALRM, sigroutine);
  signal(SIGVTALRM, sigroutine);

  value.it_value.tv_sec = 1;
  value.it_value.tv_usec = 0;
  value.it_interval.tv_sec = 1;
  value.it_interval.tv_usec = 0;
  setitimer(ITIMER_REAL, &value, &ovalue);

  value2.it_value.tv_sec = 0;
  value2.it_value.tv_usec = 500000;
  value2.it_interval.tv_sec = 0;
  value2.it_interval.tv_usec = 500000;
  setitimer(ITIMER_VIRTUAL, &value2, &ovalue);

  for(;;) ;

}

PS：
Linux信號機制基本上是從Unix系統中繼承過來的。
早期Unix系統中的信號機制比較簡單和原始，後來在實踐中暴露出一些問題，
因此，把那些建立在早期機制上的信號叫做"不可靠信號"，
信號值小於SIGRTMIN(SIGRTMIN=32，SIGRTMAX=63)的信號都是不可靠信號。
這就是"不可靠信號"的來源。它的主要問題是：Process每次處理信號後，
就將對信號的響應設置為Default動作。在某些情況下，將導致對信號的錯誤處理；
因此，User如果不希望這樣的操作，那麼就要在信號處理函數結尾再一次使用signal()，重新安裝該信號。

Posted in C, Linux, Signal | 2 意見

[技術] 在C中列出目錄與檔案

Written on 8:50 上午 by Yu Lai

一般在C中，我們可以使用opendir()與readdir()來列出目錄下所有的檔案。
以下是範例程式：

#include <sys/types.h>
#include <dirent.h>
#include <unistd.h>

main() {
    DIR * dir;
    struct dirent * ptr;
    int i;
    dir =opendir(“/etc/rc.d”);
    while((ptr = readdir(dir))!=NULL) {
        printf(“d_name: %s\n”,ptr->d_name);
    }
    closedir(dir);
}

配合struct dirent，定義如下：

struct dirent {
    ino_t d_ino;
    off_t d_off;
    unsigned short int d_reclen;
    unsigned char d_type;
    char d_name[256];
};

d_ino 此目錄進入點的inode
d_off 目錄文件開頭至此目錄進入點的位移
d_reclen d_name的長度，不包含NULL字符
d_type d_name所指的檔案類型
d_name 檔名
其中unsigned cahr d_type;可以來判斷是子目錄或是一般的檔案。
但不知是我使用的uClibC的問題，沒實作到還怎樣，使用上一直有問題。

後來還是找到解決方法，方法有2種，分別如下：
1. 再使用一次readdir()來判斷回傳值，若回傳為NULL，即為檔案。

#include <sys/types.h>
#include <dirent.h>
#include <unistd.h>

main() {
    DIR * dir;
    DIR * dir2;
    struct dirent * ptr;
    int i;
    dir =opendir(“/etc/rc.d”);
    while((ptr = readdir(dir))!=NULL) {
        char pathname[100];
        sprintf(pathname,"/etc/rc.d/%s", ptr->d_name);
        if((dir2 = opendir(pathname))==NULL) {
            printf("%s: file\n", ptr->d_name);
        } else {
            printf("%s: directory\n", ptr->d_name);
            closedir(dir2);
        }
    }
    closedir(dir);
}

2. 使用int stat(const char *file_name, struct stat *buf)，
在struct stat其中的 st_mode 可以用來判斷是哪種檔案(也就是上面 d_type的 功用)。
為了方便，POSIX另外有定義幾個MACRO：
S_ISLNK(st_mode) : 是symbolic link
S_ISREG(st_mode) 一般檔案(regular file)
S_ISDIR(st_mode) 目錄(directory)
S_ISCHR(st_mode) 字元設備檔(char device)
S_ISBLK(st_mode) 區塊設備檔(block device)
S_ISSOCK(st_mode) local-domain socket

#include <sys/types.h>
#include <dirent.h>
#include <unistd.h>

main() {
    DIR * dir;
    struct dirent * ptr;
    int i;
    dir =opendir(“/etc/rc.d”);
    while((ptr = readdir(dir))!=NULL) {
        char pathname[100];
        struct stat buf;
        sprintf(pathname,"/etc/rc.d/%s", ptr->d_name);
        stat(pathname, &buf);
        if(S_ISREG(buf.st_mode))
            printf("%s: file\n", ptr->d_name);
        else
            printf("%s: directory\n", ptr->d_name);
    }
    closedir(dir);
}

Posted in 技術, C, File System, Linux | 0 意見

[技術] 用GPIO實做I2C介面(Bit-Banging)

Written on 12:00 上午 by Yu Lai

最近工作上需要去讀寫I2C介面的IC，
是顆用來量測環境溫度的IC－LM75。
I2C是由2支腳－SDA和SCL所組成的並聯介面，
所有I2C的IC都接在這2支腳上，
I2C相關資訊可以自行到Google或wiki找找。

而我們的板子的CPU本身沒有I2C的介面，
它是透過2支GPIO腳來連接LM75，
所以就必須以軟體的方式來控制GPIO來模擬I2C的Signal，
以上的實做也被稱做Bit-Banging。

照著LM75的Datasheet和網路上相關的資料，
還蠻順利的完成整個Bit-Banging的實做。

以下就是相關實做的source code。

#define SCL_PORT  6
#define SDA_PORT  23

#define ADDR_LM75  0x94 /* 1001 010 x */
#define I2C_DELAY_TIME  10 /* us */

#define ACK   1
#define NO_ACK   0

首先是會用到的#define。
SCL腳位是使用GPIO6，SDA是使用GPIO23。
而LM75使用的Address則是固定的1001配上
板子上A2,A1,A0腳位所接的電位的010當前7個bit。
另外，由於I2C算是比較慢的介面，所以要有個delay time。

void i2c_init(void) {

 /* Enable SDA & SCL gpio port */
 gpio_enable(SDA_PORT);
 gpio_enable(SCL_PORT);

 /* Set SDA & SCL to High */
 gpio_set(SDA_PORT, __HIGH__);
 gpio_set(SCL_PORT, __HIGH__);
 
}

這裡是將GPIO腳位設定啟動，並將SDA和SCL電位設成HIGH，
完成Initial的動作。

void i2c_start(void) {

 /* I2C start sequence is defined as 
  * a High to Low Transition on the data
  * line as the CLK pin is high */
  
 gpio_set(SDA_PORT, __HIGH__);  /* SDA: High */
 gpio_set(SCL_PORT, __HIGH__);  /* SCL: High */
 HAL_DELAY_US(I2C_DELAY_TIME);
 
 gpio_set(SDA_PORT, __LOW__);  /* SDA: Low */
 gpio_set(SCL_PORT, __LOW__);  /* SCL: Low */
 HAL_DELAY_US(I2C_DELAY_TIME);
 
}

void i2c_stop(void) {
  
 /* I2C stop sequence is defined as 
  * data pin is low, then CLK pin is high,
  * finally data pin is high. */

 gpio_set(SDA_PORT, __LOW__);  /* SDA: Low */
 gpio_set(SCL_PORT, __HIGH__);  /* SCL: High */
 gpio_set(SDA_PORT, __HIGH__);  /* SDA: High */
 
}

如source code裡我comment所寫的，
I2C介面溝通的start就是SDA和SCL都是由本來保持的High變成Low所開始。
而stop就是SDA和SCL由High-Low傳遞資料之間變為High持續下去。

void i2c_write(unsigned char data) {
  
 /* An I2C output byte is bits 7-0
   * (MSB to LSB).  Shift one bit at a time
  * to the MDO output, and then clock the
  * data to the I2C Slave */

 unsigned char i;

 /* Write to slave */
 for(i = 0; i < 8; i++) {
  gpio_set(SDA_PORT, (data&0x80)?1:0); /* Send data bit */
  data <<= 1;   /* Shift one bit */
  gpio_set(SCL_PORT, __HIGH__); /* SCL: High */
  HAL_DELAY_US(I2C_DELAY_TIME);
  gpio_set(SCL_PORT, __LOW__); /* SCL: Low */
  HAL_DELAY_US(I2C_DELAY_TIME);
 }

 /* Read ACK bit from slave */
 gpio_get(SDA_PORT);
 gpio_set(SCL_PORT, __HIGH__);  /* SCL: High */
 HAL_DELAY_US(I2C_DELAY_TIME);
 gpio_set(SCL_PORT, __LOW__);  /* SCL: Low */
 HAL_DELAY_US(I2C_DELAY_TIME);
 
}

unsigned char i2c_read(unsigned char send_ack) {
  
 unsigned char i, data;

 data = 0x00;

 /* Read from slave */
 for(i = 0; i < 8; i++) {
  data <<= 1;   /* Shift one bit */
  data |= gpio_get(SDA_PORT); /* Read data bit */
  gpio_set(SCL_PORT, __HIGH__); /* SCL: High */
  HAL_DELAY_US(I2C_DELAY_TIME);
  gpio_set(SCL_PORT, __LOW__); /* SCL: Low */
  HAL_DELAY_US(I2C_DELAY_TIME);
 }

 /* Send ACK bit to slave */
 if(send_ack)
  gpio_set(SDA_PORT, __LOW__); /* SDA: Low */
 else
  gpio_set(SDA_PORT, __HIGH__); /* SDA: High */
 gpio_set(SCL_PORT, __HIGH__);  /* SCL: High */
 HAL_DELAY_US(I2C_DELAY_TIME);
 gpio_set(SCL_PORT, __LOW__);  /* SCL: Low */
 HAL_DELAY_US(I2C_DELAY_TIME);

 return data;
 
}

接著就是傳送的過程了，
一般I2C都是由高位先寫入(這個不一定，要看Datasheet)。
在寫入時，Master(指CPU)先把SDA設成寫入的bit，
再把SCL依照我們delay的時間來做clock signal的產生(low->high->low->...)。
接著重複上面的動作依序把整個byte都寫入。
寫完整個byte後要讀取一下Slave(指LM75)所回傳的ACK bit。

而在讀取時，一樣先讀入SDA的電位當成data的bit，
再把SCL產生clock signal給Slave，
Slave在收到clock signal後會在SDA上變動電位把資料依序傳出來。
所以同樣的重複上面的動作就可以把組合出整個byte的資料。
當Master讀完byte後也要有回傳ACK的動作來告知是否繼續有下一個byte要讀取。

int get_lm75_temp(void) {

 unsigned char msb = 0x00, lsb = 0x00;

 i2c_start();
 i2c_write(ADDR_LM75);  /* Ask LM75 write */
 i2c_write(0x00);
 
 i2c_start();

 i2c_write(ADDR_LM75+1); /* Ask LM75 read */
 msb = i2c_read(ACK);
 lsb = i2c_read(NO_ACK);
 i2c_stop();
 
 return (msb << 8) | lsb;
 
}

最後，照著LM75的Datasheet，
Master先傳送address byte給Slave，
Slave在收到address後會先比對自己A2,A1,A0，
若符合再依照address byte的最後一個bit來回應之後的動作，
若為0則是write動作，若為1則是read動作。

所以我們要讀取現在溫度資料時，
CPU先把address byte+0給寫到LM75，告知接下來要寫入register設定，
接著把0x00寫入表示要讀取第0個register，也就是現在的溫度。
再來就是重新開始先寫入address byte+1給LM75，告知要讀取資料。
接著就把溫度資料讀出，共2個byte，所以讀了2次囉。
最後就是把資料組合起來return出去囉。

Posted in 技術, C, Embedded | 6 意見

[技術] C的function call與stack frame心得

Written on 12:00 上午 by Yu Lai

從大二的Program Language中學到stack對於C的function call的實做與功用的概念，
以及各個register的功用，但從未實際地深入了解其中register的變化．
剛好最近T40灌了Ubuntu Linux (x86)，就直接寫了些C code，
配合objdump與gdb來trace其中register的變化，於是有了這篇的心得．

首先是複習一下register：
%eip：instruction pointer，用來指到下一個instruction的位置．
%esp：stack pointer，用來指到目前stack的top．
%ebp：Frame pointer，用來指到目前stack frame的開頭．

這次所使用的source code：

#include <stdio.h>
void hi(int a, int b) {
        int i = 3;
        return;
}
int main(int argc, char *argv[]) {
        hi(1, 2);
        return 0;
}

我們先透過$ gcc -o test test.c編出test，
然後再透過objdump -d test來觀察disassemble出來的部份：

 08048344 <hi>:
 8048344: 55                    push   %ebp
 8048345: 89 e5                 mov    %esp,%ebp
 8048347: 83 ec 10              sub    $0x10,%esp
 804834a: c7 45 fc 03 00 00 00  movl   $0x3,-0x4(%ebp)
 8048351: c9                    leave  
 8048352: c3                    ret    

 08048353 <main>:
 8048353: 8d 4c 24 04           lea    0x4(%esp),%ecx
 8048357: 83 e4 f0              and    $0xfffffff0,%esp
 804835a: ff 71 fc              pushl  -0x4(%ecx)
 804835d: 55                    push   %ebp
 804835e: 89 e5                 mov    %esp,%ebp
 8048360: 51                    push   %ecx
 8048361: 83 ec 08              sub    $0x8,%esp
 8048364: c7 44 24 04 02 00 00  movl   $0x2,0x4(%esp)
 804836b: 00 
 804836c: c7 04 24 01 00 00 00  movl   $0x1,(%esp)
 8048373: e8 cc ff ff ff        call   8048344 <hi>
 8048378: b8 00 00 00 00        mov    $0x0,%eax
 804837d: 83 c4 08              add    $0x8,%esp
 8048380: 59                    pop    %ecx
 8048381: 5d                    pop    %ebp
 8048382: 8d 61 fc              lea    -0x4(%ecx),%esp
 8048385: c3                    ret    
 8048386: 90                    nop    

從0x0804835d開始，我們可以看到main()在呼叫hi()時的步驟，
首先先把ebp的值塞進stack中，然後把esp的值塞到ebp裡．
接著把esp減8(因為stack是由高位往低位)，再分別把0x2和0x1塞入stack中，
這2個其實就是把hi()所需的變數放入stack中，最後就是call 8048344 <hi>．
接著透過gdb設好breakpoint把stack中的值給印出來．

$ gdb -q test
(gdb) b hi
Breakpoint 1 at 0x804834a
(gdb) r
Starting program: /home/lazyf/test 

Breakpoint 1, 0x0804834a in hi ()
Current language:  auto; currently asm
(gdb) x/32xw $esp
0xbfb9a074: 0x0804953c 0xbfb9a088 0x08048280 0xb7f95ff4
0xbfb9a084: 0xbfb9a098 0x08048378 0x00000001 0x00000002
0xbfb9a094: 0xbfb9a0b0 0xbfb9a108 0xb7e61450 0xb7fc8ce0
0xbfb9a0a4: 0x080483a0 0xbfb9a108 0xb7e61450 0x00000001
0xbfb9a0b4: 0xbfb9a134 0xbfb9a13c 0xb7facb38 0x00000000
0xbfb9a0c4: 0x00000001 0x00000000 0x080481f5 0xb7f95ff4
0xbfb9a0d4: 0xb7fc8ce0 0x00000000 0xbfb9a108 0x67416081
0xbfb9a0e4: 0xd8282a91 0x00000000 0x00000000 0x00000000
(gdb)

從stack內的值我們可以觀察到，其實call指令所做的動作就是把下一筆instruction的
address(eip)給push進stack裡(0x08048378被放入0xbfb9a088中)，接著再把call的address
塞到eip再執行它．

接著到了hi()中，和main()一樣的先把ebp塞入stack中，然後把把esp的值塞到ebp裡．
從這裡我們可以知道，一個function開始時，會先把上一個function的ebp放入stack中，
接著馬上設定自己的ebp．從這裡可以用來確保目前所在function的ebp的值的正確性，
以及保存之後要return時上一個function的ebp的值．

在hi()中把ebp設定好後，它先在stack中allocate了16個byte來使用，接著我們看到了
在ebp-4的位置上被填入了0x3的值，也就是我們在程式中宣告的變數int i = 3;的實做．

最後是leave指令和ret指令所實做出來的return;．在這裡leave指令的操作相當於
把ebp的值放到esp中，然後從stack中pop出值來放到ebp裡，而ret指令的操作則相當於從
stack中pop出值來放到eip裡．也就是說除了eip外，esp和ebp都回到呼叫hi()之前的狀況．
完成hi()的呼叫．

另外，如果hi()有值需要被return時，通常會透過eax register來傳遞．
也就是說在$lt;hi>中的leave指令前會加入mov xxx,%eax指令，
在<main>中call <hi>指令的下一個指令會是mov %eax,yyy指令讀出eax放入yyy中
和mov $0x0,%eax指令把eax清空．

以上就是我從gdb與objdump中所觀察到的一個C的function被呼叫的過程．
如內容有所錯誤，煩請有看到的人不吝賜教．Thanks.

Posted in 技術, C | 0 意見

[技術] 使用Linux的mmap心得

Written on 11:40 上午 by Yu Lai

最近的工作有遇到一個用mmap解決的issue,
讓我了解到mmap原來也可以這樣使用.
以下是使用的心得, 寫下來分享一下.

一般我們在Linux中使用mmap不外乎是用來做IPC的實做,
或是配合driver的file node來操控外部的device,
或者是特殊的需求-加速存取or動態載入.

但我這次遇到的問題居然是空間的需求. 在採用Linux來實做
Embedded System時, 往往會使用Ramdisk或ramfs等技術
來implement出file system來. 而這類的file system有個特點-
它佔memory. 所以在存取較大的檔案時, e.g. image raw file.
若採用傳統malloc出空間再讀進此空間進行操作時, e.g. MD5
checksum, 勢必會遇到記憶不夠的情況.
(PS. 還意外知道原來Linux有oom-killer這東東 XD)

此時我採用了mmap來將原本就在memory裡的file另外對映到
其他記憶體空間中, 把這個當成pointer來操作, 而不用額外花費
真實的memory空間. 以下是相關的source code:

int fd;
struct stat fstat;

fd = open(TMPMD5, O_RDONLY);
stat(TMPMD5, &fstat);
image = mmap(NULL, fstat.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
if(image == MAP_FAILED) {
  printf("Error.\n");
  close(fd);
  return -1;
}

Posted in 技術, C, Linux | 2 意見

[技術] 在C中動態配置2維陣列

Written on 5:04 下午 by Yu Lai

在網路上找到的，就記錄下來筆記一下囉。

在C中動態配置一[m][n]的二維陣列
有下列幾種作法

(ㄧ)

int **Array, *pData;
int m,n,i;
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，free只要free Array和Array[0]就可以了

(二)

int i;
int **Array;
Array = (int **)malloc(m*sizeof(void *));
for (i = 0; i < m; i++)
Array[i] = (int *)malloc(n*sizeof(int *));

這樣子的配置方式要做很多次的malloc,，並容易造成記憶體碎片化(memory fragment)

(三)

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;

這樣是最簡便的寫法 只要mallocㄧ次完成，free只要free Array即可

Posted in 技術, C | 0 意見

[技術] Interrupted system calls

Written on 2:41 下午 by Yu Lai

這是最近寫程式遇到的，沒想到使用好好的UNIX Socket API居然會有爆走的時候。
在Survey了老半天，總算知道問題點所在。以下是看完The Linux GCC HOWTO的心得。

會發生Interrupted system calls主要是POSIX的系統檢查信號的次數，比起一些舊版的Unix是要多那麼一點。依照此規範，在Linux裡會在下列系統呼叫(system calls)的執行期間執行signal handlers: select(), pause(), connect(),accept(), read() on terminals, sockets, pipes or files in /proc, write() on terminals, sockets, pipes or the line printer, open() on FIFOs, PTYs or serial lines,ioctl() on terminals, fcntl() with command F_SETLKW, wait4(), syslog(), any TCP or NFS operations。而就其它的作業系統而言，你需要注意的可能就是下面這些系統呼叫(system calls)了: creat(), close(), getmsg(), putmsg(), msgrcv(), msgsnd(), recv(), send(), wait(), waitpid(), wait3(), tcdrain(), sigpause(), semop() to this list.

而問題點在於在系統呼叫(system calls)期間，若有一信號(那支程式本身應準備好handler因應了)產生，handler就會被呼叫。當handler將控制權轉移回系統呼叫時，它會偵測出它已經產生中斷，而且傳回值會立刻設定成-1，errno設定成EINTR。程式並沒有想到會發生這種事，所以就會bottles out了。

有兩種修正的方法可以選擇:

(1) 對每個你自行安裝(install)的signal handler，都須在sigaction旗號加上SA_RESTART。例如，把下列的程式，

     signal (sig_nr, my_signal_handler);

改成

     signal (sig_nr, my_signal_handler);
     { struct sigaction sa;
       sigaction (sig_nr, (struct sigaction *)0, &sa);
   #ifdef SA_RESTART
       sa.sa_flags |= SA_RESTART;
   #endif
   #ifdef SA_INTERRUPT
       sa.sa_flags &= ~ SA_INTERRUPT;
   #endif
       sigaction (sig_nr, &sa, (struct sigaction *)0);
     }

要注意的是，當這部份的變更大量應用到系統呼叫之後，呼叫read(), write(),ioctl(), select(), pause() 與 connect()時，你仍然得自行檢查(check for)EINTR。如方法二所示。

(2) 你自己得很明確地(explicitly)檢查EINTR:

這裡有兩個針對read()與ioctl()的例子。

原始的程式片段，使用read()。

   int result;
   while (len > 0) {
     result = read(fd,buffer,len);
     if (result <> 0) {
     result = read(fd,buffer,len);
     if (result < 0) { if (errno != EINTR) break; }
     else { buffer += result; len -= result; }
   }

原始的程式片段，使用ioctl()。

   int result;
   result = ioctl(fd,cmd,addr);

修改成

   int result;
   do { result = ioctl(fd,cmd,addr); }
   while ((result == -1) && (errno == EINTR));

注意一點，有些版本的BSD Unix，其內定的行為(default behaviour)是重新執行系統呼叫。若要讓系統呼叫中斷，得使用SV_INTERRUPT或SA_INTERRUPT旗號。

另外補充一個由Richard Steven所提供給connect()的修改法。

   /* Start with fd just returned by socket(), blocking, SOCK_STREAM... */
   while ( connect (fd, &name, namelen) == -1 && errno != EISCONN ) 
   if ( errno != EINTR ) {
       perror ("connect");
       exit (EXIT_FAILURE);
   }

Posted in 技術, C, Linux, socket | 0 意見

[技術] malloc的效能

Written on 9:54 上午 by Yu Lai

轉載自強者學弟yuwen的個人板P_yuwen @ cd.twbbs.org

最近因為某些特殊需求，所以必須要使用rainbowtable來輔助，在FreeBSD的ports中有rainbowcrack可以使用，於是就裝了起來，順道測試一下之前抓到的幾個rainbowtable的效率。沒想到一執行rcrack就噴了 = =

只好苦命的來trace code，才發現一個白爛的問題，做這個ports的人在某個function內，因為找不到從linux對應的code，就直接把那段code拔掉 = = 所以return 值亂七八糟的，當然會噴segmentation fault！所以就自己補上那一小段code，本來以為這世界就會再度快樂的運轉。

當然事情不是那麼的簡單，跑沒多久又改噴bus error = = 經過再苦命的trace才找到bug，因為每個rainbowtable去跑一次需要allocate 1G的記憶體，而我拿來測的機器的記憶體只有1G，不過SWAP也有1.5G，不知道為啥就是不會成功。(謎! 板上有長輩知道嗎)，所以又找了台有2G RAM的機器來測，發現一樣跑步起來，後來寫了個test code才發現似乎是FreeBSD的malloc的問題。同樣的code，在一樣只有1G的linux上面卻是可以成功。(FreeBSD的libc中的malloc是jemalloc，而linux上面的是ptmalloc2)

My test code:
unsigned char* a = (unsigned char *)malloc(sizeof(unsigned char)*1G);
if(a == NULL) printf("Damn\n");
else printf("Thanks God!\n");
Result:
FreeBSD 6.2-Stable + 1G RAM => Damn
FreeBSD 6.2-Stable + 3G RAM => Damn
Debian etch => Thanks God!

所以就開始尋找替代方案啦，幾個有名的malloc都拿來測試看看，包含下列幾種:
libumem(Sun的)，libdlmalloc(FreeBSD開發者弄得)，libtcmalloc (google出品)
結果不管換上哪一套，在本來的機器上都可以跑了！！！看來真的是malloc的問題。

解決問題後，就開始想測測看上面這幾套的效能，測試的code如下：
char a[65535];
跑 10 次
random填滿 a[65535], 每個malloc 1~64K
跑 1000000 次
random選一個a[x]，如果不是null就free，如果null就
random malloc一塊 1~64K
end 跑
end 跑

結果: tcmalloc > dlmalloc >>>>>>>>>>>>>>>>>>> libumem ~= jemallo ~= ptmalloc
結論: 如果需要大量頻繁的malloc/free，每次都是small allocation的話，應該可以先試試看tcmalloc or dlmalloc

這又帶出一個想法，築夢每次晚間的load都非常重，看了一下code發現其實bbs會頻繁的malloc/free。也許cd.twbbs.org可以改用tcmalloc or dlmalloc看看，也許可以增加一點效率~(ptt是改用dietlibc的malloc)

--
可惜手邊沒有bbs的機器來測, 手好癢阿~ Orz

PS: 最後補一個相關的ref: http://plog.longwin.com.tw/news-unix/2007/03/29/mysql_tcmalloc_2007

Posted in 技術, C, FreeBSD, malloc | 0 意見

[技術] 嵌入式系統入學測驗

Written on 10:19 上午 by Yu Lai

原文出處 A 'C' Test: The 0x10 Best Questions for Would-be Embedded Programmers: http://www.embedded.com/2000/0005/0005feat2.htm

以下是網路上找到中文版，作者不詳。

C語言測試是徵選嵌入式系統程式員過程中必須而且有效的方法。這些年我既參加也組織了許多這種測試，在這過程中我意識到這些測試能為面試者和被面試者提供許多有用訊息，此外，撇開面試的壓力不談，這種測試也是相當有趣的。

從被面試者的角度來講，你能了解許多關於出題者或監考者的情況。這個測試只是出題者為顯示其對ANSI標準細節的知識而不是技術技巧而設計嗎？這個愚蠢的問題嗎？如要你答出某個字符的ASCII值。這些問題著重考察你的系統調用(invoke)和記憶體分發策略方面的能力嗎？這反映出出題者也許花時間在微處理機上而不在嵌入式系統上。

如果上述任何問題的答案是“是”的話，那麼我知道我得認真考慮我是否應該去做這份工作。

從面試者的角度來講，一個測試也許能從多方面揭示應試者的素質。最基本的，你能了解應試者C語言的水準。不管怎麼樣，看一下這人如何回答他不會的問題也是滿有趣。應試者是以好的直覺做出明智的選擇，還是只是瞎蒙呢？當應試者在某個問題上卡住時是找藉口呢，還是表現出對問題的真正的好奇心，把這看成學習的機會呢？我發現這些訊息與他們的測試成績一樣有用。

有了這些想法，我決定出一些真正針對嵌入式系統的考題，希望這些令人頭痛的考題能給正在謀職的人一點幫住。這些問題都是我這些年實際碰到的。其中有些題很難，但它們應該都能給你一點啟發。

這個測試適用於不同水準的應試者，大多數初級水準的應試者的成績會很差，經驗豐富的程式員應該有很好的成績。為了讓你能自己決定某些問題的偏好，每個問題沒有分發分數，如果選擇這些考題為你所用，請自行按你的意思分發分數。

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

預處理器 (Preprocessor)

1.用預處理指令#define 聲明一個常數，用以表示1年中有多少秒 (忽略閏年問題)

#define SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL

我在這想看到幾件事情︰

a.#define 語法的基本知識 (例如︰不能以分號結束，括號的使用，等等)
b.懂得預處理器將為你計算常數表達式的值，因此，直接寫出你是如何計算一年中有多少秒會比直接計算出實際的值更清晰。
c.意識到這個表達式將使一個16位元的機器產生整數型溢位 - 因此要用到長整型符號L，告訴編譯器這個常數是的長整型數。
d.如果你在你的表達式中用到UL (表示無符號長整型) ，那麼你有了一個好的起點。記住，第一印象很重要。

2.寫一個“標準”巨集MIN ，這個巨集輸入兩個參數並返回較小的一個。

#define MIN(A, B) ((A) <= (B) ? (A) : (B))

這個測試是為下面的目的而設的︰

a.標識#define在巨集中應用的基本知識。這是很重要的，因為在行內(inline)運算子變為標準C的一部分之前，巨集是方便產生行內程式碼的唯一方法，對於嵌入式系統來說，為了能達到要求的性能，行內程式碼經常是必須的方法。
b.三元運算子的知識。這個運算子存在C語言中的原因是它使得編譯器能產生比if-then-else更優化的程式碼，了解這個用法是很重要的。
c.懂得在巨集中小心地把參數用括號括起來。我也用這個問題開始討論巨集的副作用，例如︰當你寫下面的程式碼時會發生什麼事？

least = MIN(*p++, b);

3.預處理器標識#error的目的是什麼？

如果你不知道答案，請看參考文獻1。這問題對區分一個正常的伙計和一個書呆子是很有用的。只有書呆子才會讀C語言課本的附錄去找出象這種問題的答案。當然如果你不是在找一個書呆子，那麼應試者最好希望自己不要知道答案。

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

無窮迴圈 (Infinite loops)

4.嵌入式系統中經常要用到無窮迴圈，你怎麼樣用C編寫無窮迴圈呢？

這個問題用幾個解決方案。我首選的方案是︰

while(1)
{
  ...
}

一些程式員更喜歡如下方案︰

for(;;)
{
  ...
}

這個實作方式讓我為難，因為這個語法沒有確切表達到底怎麼回事。如果一個應試者給出這個作為方案，我將用這個作為一個機會去探究他們這樣做的基本原理。如果他們的基本答案是︰“我被教著這樣做，但從沒有想到過為什麼。”這會給我留下一個壞印象。
第三個方案是用 goto︰

Loop:
  ...
goto Loop;

應試者如給出上面的方案，這說明或者他是一個組合語言程式員 (這也許是好事) 或者他是一個想進入新領域的BASIC/FORTRAN程式員。

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

數據宣告 (Data declarations)

5.用變數a給出下面的定義：
a)一個整型數 (An integer)
b)一個指向整數的指標 (A pointer to an integer)
c)一個指向指標的指標，它指向的指標是指向一個整型數 (A pointer to a pointer to an integer)
d)一個有10個整數型的陣列 (An array of 10 integers)
e)一個有10個指標的陣列，該指標是指向一個整數型的 (An array of 10 pointers to integers)
f)一個指向有10個整數型陣列的指標 (A pointer to an array of 10 integers)
g)一個指向函數的指標，該函數有一個整數型參數並返回一個整數 (A pointer to a function that takes an integer as an argument and returns an integer)
h)一個有10個指標的陣列，該指標指向一個函數，該函數有一個整數型參數並返回一個整數 (An array of ten pointers to functions that take an integer argument and return an integer)

答案是︰

a) int a; // An integer
b) int *a; // A pointer to an integer
c) int **a; // A pointer to a pointer to an integer
d) int a[10]; // An array of 10 integers
e) int *a[10]; // An array of 10 pointers to integers
f) int (*a)[10]; // A pointer to an array of 10 integers
g) int (*a)(int); // A pointer to a function a that takes an integer argument and returns an integer
h) int (*a[10])(int); // An array of 10 pointers to functions that take an integer argument and return an integer

人們經常聲稱這裡有幾個問題是那種要翻一下書才能回答的問題，我同意這種說法。當我寫這篇文章時，為了確定語法的正確性，我的確查了一下書。但是當我被面試的時候，我期望被問到這個問題(或者相近的問題)。因為在被面試的這段時間裡，我確定我知道這個問題的答案。應試者如果不知道所有的答案(或至少大部分答案)，那麼也就沒有為這次面試做準備，如果該面試者沒有為這次面試做準備，那麼他又能為什麼出準備呢？

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

Static

6.關鍵字static的作用是什麼？

這個簡單的問題很少有人能回答完全。在C語言中，關鍵字static有三個明顯的作用︰
a.在函數本體內(in Function Block)，一個被宣告為靜態的變數，在這一函數被呼叫過程中維持其值不變。
b.在一個Block(ie. {...} )內 (但在函數體外)，一個被宣告為靜態的變數可以被Block內所有的函數存取， 但不能被Block外的其它函數存取。它是一個本地的全局變量。
c.在Block內，一個被聲明為靜態的函數，只可被這一Block內的其它函數呼叫。也就是這個函數被限制在宣告它的Block的本地範圍內使用。大多數應試者能正確回答第一部分，一部分能正確回答第二部分，同是很少的人能懂得第三部分。這是一個應試者的嚴重的缺點，因為他顯然不懂得本地化資料和程式碼範圍的好處和重要性。

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

Const(常量)

7.關鍵字const有什麼含意？

我只要一聽到被面試者說︰“const意味著常數”，我就知道我正在和一個業餘者打交道。去年Dan Saks已經在他的文章裡完全概括了const的所有用法，因此ESP(譯者︰Embedded Systems Programming)的每一位讀者應該非常熟悉const能做什麼和不能做什麼。如果你從沒有讀到那篇文章，只要能說出const意味著“只讀”就可以了。儘管這個答案不是完全的答案，但我接受它作為一個正確的答案。(如果你想知道更詳細的答案，仔細讀一下Saks的文章吧。)如果應試者能正確回答這個問題，我將問他一個附加的問題︰下面的聲明都是什麼意思？

const int a;
int const a;
const int *a;
int * const a;
int const * a const;

前兩個的作用是一樣，a是一個常數型整數。
第三個意味著a是一個指向常數型整數的指標(也就是，整型數是不可修改的，但指標可以)。
第四個意思a是一個指向整數的常數型指標(也就是說，指標指向的整數是可以修改的，但指標是不可修改的)。
最後一個意味著a是一個指向常數型整數的常數型指標(也就是說，指標指向的整數是不可修改的，同時指標也是不可修改的)。
如果應試者能正確回答這些問題，那麼他就給我留下了一個好印象。順帶提一句，也許你可能會問，即使不用關鍵字 const，也還是能很容易寫出功能正確的程式，那麼我為什麼還要如此看重關鍵字const呢 ?我有以下的幾個理由︰
a。關鍵字const的作用是給讀你程式碼的人傳達非常有用的訊息，實際上，宣告一個參數為常量是為了告訴了程式員這個參數的應用目的。如果你曾花很多時間清理其它人留下的垃圾(記憶體回收)，你就會很快學會感謝這點多餘的訊息。(當然，懂得用const的程式員很少會留下的垃圾讓別人來清理的)
b。透過給優化器一些附加的訊息，使用關鍵字const也許能產生更緊湊的程式碼。
c。合理地使用關鍵字const可以使編譯器很自然地保護那些不希望被改變的參數，防止其被無意的程式碼修改。簡而言之，這樣可以減少bug的出現。

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

Volatile(易變的)

8. 關鍵字volatile有什麼含意？並給出三個不同的例子。

一個定義為volatile的變量是說這變量可能會被意想不到地改變，這樣，編譯器就不會去假設這個變量的值了。精確地說就是，優化器在用到這個變量時必須每次都小心地重新讀取這個變量的值，而不是使用保存在暫存器裡的備份。下面是volatile變量的幾個例子︰
a.並行設備的硬體暫存器 (如︰狀態暫存器)
b.一個中斷服務次程序中會訪問到的非自動變數(Non-automatic variables)
c.多執行緒應用中被幾個任務(task)共享的變數
回答不出這個問題的人是不會被僱佣的。(os:還好我不是讓這個人面試.....)我認為這是區分C程式員和嵌入式系統程式員的最基本的問題。搞嵌入式的家伙們經常同硬體、中斷、RTOS等等打交道，所有這些都要求用到volatile變量。不懂得volatile的內容將會帶來災難。
假設被面試者正確地回答了這是問題 (嗯，懷疑是否會是這樣)，我將稍微深究一下，看一下這家伙是不是直正懂得volatile完全的重要性。
Q 一個參數可以同時是const也是volatile嗎？解釋為什麼。
Q 一個指標可以是volatile 嗎？解釋為什麼。
Q 下面的函數有什麼錯誤︰

int square(volatile int *ptr)
{
  return *ptr * *ptr;
}

下面是答案︰
A 是的。舉的例子是"只讀的狀態暫存器"。它是volatile因為它可能被意想不到地改變。它是const因為程式不應該試圖去修改它。
A 是的。儘管這並不很常見。舉的例子是當一個執行中的次程序修該一個指向一個buffer 的指標時。
A 這段程式碼有點變態。這段程式碼的目的是用來返指標*ptr指向值的平方，但是，由於*ptr指向一個volatile型參數，編譯器將產生類似下面的程式碼︰

int square(volatile int *ptr)
{
  int a, b;
  a = *ptr;
  b = *ptr;
  return a * b;
}

由於*ptr的值可能被意想不到地該變，因此a和b可能是不同的。結果，這段程式碼可能返回不是你所期望的平方值！正確的程式碼如下︰

long square(volatile int *ptr)
{
  int a;
  a = *ptr;
  return a * a;
}

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

位元操作 (Bit Manipulation)

9.嵌入式系統總是要用戶對變量或暫存器進行位操作。給定一個整型變量a，寫兩段程式碼，第一個設置a的bit 3，第二個清除a 的bit 3。在以上兩個操作中，要保持其它位不變。

對這個問題有三種基本的回應
- 不知道如何下手。該被面者從沒做過任何嵌入式系統的工作。
- 用bit fields。Bit fields是被扔到C語言死角的東西，它保證你的程式碼在不同編譯器之間是不可移植的，同時也保證了的你的程式碼是不可重新使用的。我最近不幸看到Infineon為其較複雜的通信晶片寫的驅動程式，它用到了bit fields因此完全對我無用，因為我的編譯器採用其它的模式來實現bit fields。從道德講︰永遠不要讓一個非嵌入式的家伙沾到實際硬體的邊。
- 用 #defines 和 bit masks 操作。這是一個有極高可移植性的方法， 是應該被用到的方法。
最佳的解決方案如下︰

#define BIT3 (0x1 << 3)
static int a;
void set_bit3(void) {
  a = BIT3;
}
void clear_bit3(void) {
  a &= ~BIT3;
}

一些人喜歡為設定和清除值而定義一個掩碼同時定義一些說明常數，這也是可以接受的。我希望看到幾個要點︰說明常數、= 和 &=~ 操作。

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

存取固定的記憶體位置 (Accessing fixed memory locations)

10.嵌入式系統經常具有要求程式員去存取某特定的記憶體位置的特點。在某工程中，要求設定一個絕對位址為0x67a9的整數型變數的值為0xaa55。編譯器是一個純粹的ANSI編譯器。寫程式碼去完成這一任務。

這一問題測試你是否知道為了存取一絕對位址把一個整數型強製轉型 (typecast) 為一指標是合法的。這一問題的實作模式隨著個人風格不同而不同。 典型的類似程式碼如下︰

int *ptr;
ptr = (int *)0x67a9;
*ptr = 0xaa55;

一個較艱澀的方法是︰

*(int * const)(0x67a9) = 0xaa55;

即使你的品味更接近第二種方案，但我建議你在面試時使用第一種方案。

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

中斷 (Interrupts)

11.中斷是嵌入式系統中重要的組成部分，這導致了很多編譯開發商提供一種擴展－讓標準C支持中斷。具代表的事實是，產生了一個新的關鍵字 __interrupt。下面的程式碼就使用了__interrupt關鍵字去定義了一個中斷服務次程序(ISR)，請評論一下這段程式碼的。

__interrupt double compute_area(double radius)
{
  double area = PI * radius * radius;
  printf("\nArea = %f"， area);
  return area;
}

這個函數有太多的錯誤了，以至讓人不知從何說起了︰
- ISR 不能返回一個值。如果你不懂這個，那麼你不會被雇用的。(os : 囧)
- ISR 不能傳遞參數。如果你沒有看到這一點，你被雇用的機會等同第一項。
- 在許多的處理器/編譯器中，浮點一般都是不可重入的。有些處理器/編譯器需要讓多餘的暫存器入棧(PUSH入堆疊)，有些處理器/編譯器就是不允許在ISR中做浮點運算。此外，ISR應該是短而有效率的，在ISR中做浮點運算是不明智的。
- 與第三點一脈相承，printf()經常有重入和性能上的問題。 如果你丟掉了第三和第四點，我不會太為難你的。但如果你能得到後兩點，那麼你的被雇用前景越來越光明了。

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

程式碼例子 (Code examples)

12.下面的程式碼輸出是什麼，為什麼？

void foo(void)
{
  unsigned int a = 6;
  int b = -20;
  (a+b > 6) ? puts("> 6") : puts("<= 6");
}

這個問題測試你是否懂得C語言中的整數自動轉型原則，我發現極少有開發者懂得這些東西。不管如何，這unsigned int的答案是輸出是 "> 6"。原因是當表達式中存在有符號類型和無符號類型時所有的操作數都自動轉換為無符號類型(unsigned)。因此-20變成了一個非常大的正整數，所以該表達式計算出的結果大于6。這一點對於應當頻繁用到無符號數據類型的嵌入式系統來說是非常重要的。如果你答錯了這個問題，你也就到了得不到這份工作的邊緣。

13.評價下面的程式碼片斷︰

unsigned int zero = 0;
unsigned int compzero = 0xFFFF; /*1's complement of zero */

對于一個int型不是16位的處理器為說，上面的程式碼是不正確的。應編寫如下︰

unsigned int compzero = ~0;

這一問題真正能揭露出應試者是否懂得處理器字長的重要性。在我的經驗裡，好的嵌入式程式員非常準確地明白硬體的細節和它的限制，然而PC機程式往往把硬體作為一個無法避免的煩惱。
到了這個階段，應試者可能完全垂頭喪氣了或者信心滿滿志在必得。如果顯然應試者不是很好，那麼這個測試就在這裡結束了。但如果顯然應試者做得不錯，那麼我就扔出下面的追加問題，這些問題是比較難的，我想僅僅非常優秀的應試者能做得不錯。提出這些問題，我希望更多看到應試者應付問題的方法，而不是答案。不管如何，你就當是這個娛樂吧…

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

動態記憶體分發 (Dynamic memory allocation)

14.儘管不像非嵌入式計算機那麼常見，嵌入式系統還是有從堆積(heap)中動態分發內存的過程的。那麼嵌入式系統中，動態分發記憶體可能發生的問題是什麼？
這裡，我期望應試者能提到記憶體碎片，碎片收集的問題，變量的生命週期等等。這個主題已經在ESP雜誌中被廣泛地討論過了(主要是 P.J. Plauger，他的解釋遠遠超過我這裡能提到的任何解釋)。我拿出這麼一個小題目給應試者︰
下面的程式碼片段的輸出是什麼，為什麼？

char *ptr;
if ((ptr = (char *)malloc(0)) == NULL)
  puts("Got a null pointer");
else
  puts("Got a valid pointer");

這是一個有趣的問題。最近在我的一個同事不經意把0值傳給了函數malloc，得到了一個合法的指標之後，我才想到這個問題。這就是上面的程式碼，該程式碼的輸出是"Got a valid pointer"。我用這個問題來開始討論，看看被面試者是否想到怎樣做才是正確的。得到正確的答案固然重要，但解決問題的方法和你做決定的基本原理更重要些。

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

Typedef

15.Typedef 在C語言中頻繁用以宣告一個已經存在的資料型態的同義字。也可以用預處理器做類似的事。例如，思考一下下面的例子︰

#define dPS struct s *
typedef struct s * tPS;

以上兩種情況的意圖都是要定義dPS 和 tPS 作為一個指向結構s指標。哪種方法更好呢？ (如果有的話)為什麼？ 這是一個非常微妙的問題，任何人答對這個問題 (正當的原因) 是應當被恭喜的。
答案是︰typedef更好。思考下面的例子︰

dPS p1, p2;
tPS p3, p4;

第一個擴展為

struct s * p1, p2;

上面的程式碼定義p1為一個指向結構的指標，p2為一個實際的結構，這也許不是你想要的。
第二個例子正確地定義了p3 和p4 兩個指標。

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

艱澀的語法

16.C語言允許一些令人震驚的結構，下面的結構是合法的嗎，如果是，它做些什麼？

int a = 5, b = 7, c;
c = a+++b;

這個問題將做為這個測驗的一個愉快的結尾。不管你相不相信，上面的例子是完全合法的。問題是編譯器如何處理它？水準不高的編譯作者實際上會爭論這個問題，根據最處理原則，編譯器應當能處理儘可能所有合法的用法。因此，上面的程式碼被處理成︰

c = a++ + b;

因此，這段程式碼執行後

a = 6, b = 7, c = 12

如果你知道答案，或猜出正確答案，做得好。如果你不知道答案，我也不把這個當作問題。我發現這個問題的最大好處是這是一個關於程式碼編寫風格，程式碼的可讀性，程式碼的可修改性的好的話題。

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

好了，伙計們，你現下已經做完所有的測試了。這就是我出的C語言測試題，我懷著愉快的心情寫完它，希望你以同樣的心情讀完它。如果是認為這是一個好的測試，那麼盡量都用到你的謀職的過程中去吧。天知道也許過個一兩年，我就不做現下的工作，也需要找一個。
Nigel Jones 是一個顧問，現下住在Maryland。他很高興能收到讀者的來信，他的email位址是: NAJones@compuserve.com 。

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

Posted in 技術, C, Embedded | 0 意見