Joe's Blog----TECH

新Blog

2015-09-04T22:42:00.002+08:00

最近覺得blogger編輯畫面真的很難寫含有程式碼的文章，因此花了點時間 survey octopress. 接下來文章應該都會放在那邊了。連結是 http://clhjoe.github.io/blog/

Docker on Ubuntu 14.04

2014-11-04T11:43:00.000+08:00

Install Docker
# echo deb https://get.docker.io/ubuntu docker main > /etc/apt/sources.list.d/docker.list

# apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 36A1D7869245C8950F966E92D8576A8BA88D21E9
# apt-get update
# apt-get install -y lxc-docker

Pull Ubuntu image
[with proxy]
# service docker stop
# HTTP_PROXY=[proxy] docker -d&
# docker pull ubuntu
[without proxy]
# docker pull ubuntu

Run a Docker Container
# docker run -i -t ubuntu /bin/bash

Frequently used commands
1.列出所有image
# docker images

2.列出所有運作中的container
# docker ps

3.列出所有container 包含暫停中或已結束的container
# docker ps -a

4.刪除container
# docker rm [container id]

5.刪除image
# docker rmi [image id]
note:如果image正在被某個container使用的話，就必須先刪除使用的container才能刪除image

6.build image
# docker build .
note:此指令必須跟Dockerfile同一層

6-1. build image時加入tag
# docker build -t [tag] .

6-2. build image不使用cache
# docker build --no-cache .
note:假設上一次build的時候發生錯誤(either Dockerfile寫錯或是環境出錯等等),如果仍使用cache則會停留在出錯的狀態。另一個避免錯誤的方式是如6-3 不保留過程產生的container

6-3. build image但不保留過程中產生的container
# docker build --rm .

7. 啟動container
# docker run [image id or tag]

7-1. 啟動container with (I)nteractive and (T)ty
# docker run -t -i [image id or tag] /bin/bash
#note 啟動container並進入bash shell

7-2. 啟動container 並在背景執行
# docker run -i -t -d [image id or tag]
#note 要返回container 則執行 docker attach [container id] 回去

7-3. 啟動container 並掛載local 資料夾
# docker run -v /local/dir:/docker/dir [image id or tag]

7-4. 啟動container 並forward port
# docker run -p host_port:container_port -p host_port:container_port/udp [image id or tag]
#note -p 後面接一組 host_port:container_port，如果是udp則在後面加上/udp

7-5. 啟動container並與host時間同步
# docker run -v /etc/localtime:/etc/localtime:ro [image id or tag]

7-6. 啟動container並傳入環境變數
# docker run --env var_name=var_value [image id or tag]

7-7. 啟動container並給予tag
# docker run --name [tag] [image id or tag]

8. 跳出container
當進入container後，想要回到host的shell但不想結束container
ctrl+ p + q

9. 跳回container
# docker attach [container id]

10. 啟動container
# docker start [container id]
#note 當container是在exit狀態時，在attach必須先start container

11. Commit 變更
# docker commit -m "commit msg" -a "author" [container id] [repository]
#note -a和 repository非必要

12. 列出image/container 資訊
# docker inspect [image or container id]
#note 可以利用執行完docker inspect後檢查$?來判斷image or container是否已經存在

13. 匯出container
# docker export [container id] >image_name
#note 如果要順便壓縮的話docker export [container id] |gzip -c >image_name

14. 匯入container
# cat [image path] |docker import - [tag]
#note 匯入壓縮的image # gzip -dc [image path] | docker import - tag

#15 限制container的memory 使用量
# docker run -m [memory size ex. -m 2g]
#note:如果有出現"WARNING: Your kernel does not support swap limit capabilities. Limitation discarded."
則必須修改/etc/default/grub
將
GRUB_CMDLINE_LINUX="
更改成
GRUB_CMDLINE_LINUX="cgroup_enable=memory swapaccount=1"
執行sudo update-grub 並重新開機

Illegal instruction 追蹤

2014-10-30T21:45:00.001+08:00

某天執行程式的時候遇到Illegal instruction，這時候如果執行
# dmesg
應該會看到類似如下的訊息
XXXX[4444] trap invalid opcode rip:42a016 rsp:415104b8 error:0

這個問題通常是因為程式使用了CPU不支援的instruction set(也有例外)，那我們要怎麼知道是使用到哪個instruction(opcode)呢？

1. 開啟core dump
Ubuntu預設是不會產生core dump file的，要讓系統產生必須執行下面的指令
# ulimit -c unlimited

在執行後，當遇到Illegal instruction的錯誤時，在執行的資料夾應該會出現core.XXX的檔案及為core dump file了

2. 使用gdb追蹤
使用gdb 可以讓我們知道在哪邊發生了錯誤
# gdb [程式] [core dump file]

以我遇到的例子如下：
Program terminated with signal 4, Illegal instruction.
#0 0x000000000042a016 in FUNCTION_NAME ()
我們就可以發現錯誤是在 0x000000000042a016的地方

3. 檢視assembly code
同樣在gdb裡面執行
(gdb) disassemble FUNCTION_NAME

0x000000000042a00d <blake2b_init_param_avx+45>: cmp %rax,%rdx
0x000000000042a010 <blake2b_init_param_avx+48>: jbe 0x42a0c0 <blake2b_init_param_avx+224>
0x000000000042a016 <blake2b_init_param_avx+54>: vmovdqu (%rsi),%xmm1

就可以發現到底是什麼instruction造成錯誤了。

OpenStack High Availability I-MySQL, RabbitMQ HA

2014-05-27T21:15:00.000+08:00

OpenStack HA的方式主要分為兩種，一是Master-Master另外一種是Master-Slave的架構。顧名思義，Master-Master就是同時有兩組Control/Network Node提供服務。在這裡要介紹的是Master-Slave的佈署方式。

對於MySQL的HA, 我們必須佈署DRBD, corosync和pacemaker來達成。DRBD就像是軟體的RAID I，同步兩台電腦間的partition。而corosync則是用來在cluster間傳遞訊息和heartbeat，最後pacemaker則是負責管理應用程式的切換(例如MySQL要開在哪一台，另外一台standby)。

DRBD安裝

安裝DRBD只需要安裝drbd8-utils

# apt-get install drbd8-utils

DRBD設定

假設我們要新增一個resource給mysql/rabbitmq使用，在master 分別新增檔案 /etc/drbd.d/mysql.res 和

/etc/drbd.d/rabbitmq.res

resource mysql {

on master {

device /dev/drbd0;

disk /dev/mapper/master-mysql; #master要拿來同步的partition

address 10.109.36.58:7788;#master的IP

meta-disk internal;

}

on slave {

device /dev/drbd0;

disk /dev/mapper/master-mysql; #slave要拿來同步的partition

address 10.109.36.59:7788; #slave的IP

meta-disk internal;

}

resource rabbitmq{

on master {

device /dev/drbd1;

disk /dev/mapper/master-rabbitmq; #master要拿來同步的partition

address 10.109.36.58:7789;#master的IP

meta-disk internal;

}

on slave {

device /dev/drbd1;

disk /dev/mapper/master-rabbitmq; #slave要拿來同步的partition

address 10.109.36.59:7789; #slave的IP

meta-disk internal;

}

#將設定檔從master copy到slave

# scp /etc/drbd.d/mysql.res slave:/etc/drbd.d/

# scp /etc/drbd.d/rabbitmq.res slave:/etc/drbd.d/

#在master及slave 啟動DRBD

# /etc/init.d/drbd start

#初始化metadata storage

master:

# drbdadm create-md mysql

# drbdadm create-md rabbitmq

#將master設定為primary

master:

# drbdadm -- --overwrite-data-of-peer primary mysql

# drbdadm -- --overwrite-data-of-peer primary rabbitmq

#確認安裝狀態

執行# service drbd status應該可以看到

master:

drbd driver loaded OK; device status:

version: 8.3.13 (api:88/proto:86-96)

srcversion: 697DE8B1973B1D8914F04DB

m:res cs ro ds p mounted fstype

0:mysql Connected Primary/Secondary UpToDate/UpToDate C

1:rabbitmq Connected Primary/Secondary UpToDate/UpToDate C

slave:

drbd driver loaded OK; device status:

version: 8.3.11 (api:88/proto:86-96)

srcversion: 2931F0123213F7DB1364EA7

m:res cs ro ds p mounted fstype

0:mysql Connected Secondary/Primary UpToDate/UpToDate C

1:rabbitmq Connected Primary/Secondary UpToDate/UpToDate C

DRBD問題排除

執行service drbd status出現 '0:mysql StandAlone Secondary/Unknown UpToDate/DUnknown r-----’

如果執行dmesg 有看到

kernel: block drbd0: Split-Brain detected, dropping connection!

代表遇到split-brain的問題,解決的方法如下:

Disconnect resource(on secondary node)

# drbdadm disconnect mysql

將node轉為secondary(on secondary node)

# drbdadm secondary mysql

強至取消所有修改(on secondary node)

# drbdadm -- --discard-my-data connect mysql

重新連線(on primary node)

# drbdadm connect mysql

Reference

Corosync Installation

Corosync安裝

Corosync安裝只需要安裝corosync套件

both master & master-1

# apt-get install corosync

Corosync設定

#編輯/etc/corosync/corosync.conf

both master & master-1

# Please read the openais.conf.5 manual page

totem {

version: 2

# How long before declaring a token lost (ms)

token: 3000

# How many token retransmits before forming a new configuration

token_retransmits_before_loss_const: 10

# How long to wait for join messages in the membership protocol (ms)

join: 60

# How long to wait for consensus to be achieved before starting a new round of membership configuration (ms)

consensus: 3600

# Turn off the virtual synchrony filter

vsftype: none

# Number of messages that may be sent by one processor on receipt of the token

max_messages: 20

# Limit generated nodeids to 31-bits (positive signed integers)

clear_node_high_bit: yes

# Disable encryption

secauth: off

# How many threads to use for encryption/decryption

threads: 0

# Optionally assign a fixed node id (integer)

# nodeid: 1234

# This specifies the mode of redundant ring, which may be none, active, or passive.

rrp_mode: none

interface {

# The following values need to be set based on your environment

ringnumber: 0

bindnetaddr: 10.109.36.0

mcastaddr: 226.94.1.1

mcastport: 5405

}

amf {

mode: disabled

}

service {

# Load the Pacemaker Cluster Resource Manager

ver: 0

name: pacemaker

}

aisexec {

user: root

group: root

}

logging {

fileline: off

to_stderr: yes

to_logfile: no

to_syslog: yes

syslog_facility: daemon

debug: off

timestamp: on

logger_subsys {

subsys: AMF

debug: off

}

#將設定檔複製到Slave

# scp -r /etc/corosync master-1:/etc/

設定開機自動啟動

編輯 /etc/default/corosync 將內容的'no’ 改成’yes’

確認安裝狀態

在Master執行 # corosync-objctl runtime.totem.pg.mrp.srp.members 應該可以看到如下畫面

runtime.totem.pg.mrp.srp.1763994890.ip=r(0) ip(10.109.36.105)

runtime.totem.pg.mrp.srp.1763994890.join_count=1

runtime.totem.pg.mrp.srp.1763994890.status=joined

runtime.totem.pg.mrp.srp.1797549322.ip=r(0) ip(10.109.36.107)

runtime.totem.pg.mrp.srp.1797549322.join_count=1

runtime.totem.pg.mrp.srp.1797549322.status=joined

Reference

OpenStack HA

Pacemaker Installation

驗證系統

在重新啟動Master及Slave之後在兩台執行 # crm_mon應該可以看到

Master

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

Last updated: Wed Jun 19 16:52:11 2013

Last change: Wed Jun 19 13:14:15 2013 via crmd on master-1

Stack: openais

Current DC: master - partition with quorum

Version: 1.1.6-9971ebba4494012a93c03b40a2c58ec0eb60f50c

2 Nodes configured, 2 expected votes

0 Resources configured.

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

Online: [ master master-1 ]

Slave

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

Last updated: Wed Jun 19 16:52:11 2013

Last change: Wed Jun 19 13:14:15 2013 via crmd on master-1

Stack: openais

Current DC: master - partition with quorum

Version: 1.1.6-9971ebba4494012a93c03b40a2c58ec0eb60f50c

2 Nodes configured, 2 expected votes

0 Resources configured.

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

Online: [ master master-1 ]

基本設定

#在master執行 # crm configure 接著輸入

crm(live)configure# property no-quorum-policy="ignore" \

pe-warn-series-max="1000" \

pe-input-series-max="1000" \

pe-error-series-max="1000" \

cluster-recheck-interval="5min" \

crm(live)configure# commit

HA for MySQL

#編輯pacemaker

執行 # crm configure

crm(live)configure# edit

接著輸入

primitive p_drbd_mysql ocf:linbit:drbd \

params drbd_resource="mysql" \

op start interval="0" timeout="90s" \

op stop interval="0" timeout="180s" \

op promote interval="0" timeout="180s" \

op demote interval="0" timeout="180s" \

op monitor interval="30s" role="Slave" \

op monitor interval="29s" role="Master"

primitive p_drbd_rabbitmq ocf:linbit:drbd \

params drbd_resource="rabbitmq" \

op start interval="0" timeout="90s" \

op stop interval="0" timeout="180s" \

op promote interval="0" timeout="180s" \

op demote interval="0" timeout="180s" \

op monitor interval="30s" role="Slave" \

op monitor interval="29s" role="Master"

primitive p_fs_mysql ocf:heartbeat:Filesystem \

params device="/dev/drbd/by-res/mysql" directory="/var/lib/mysql" fstype="xfs" options="relatime" \

op start interval="0" timeout="60s" \

op stop interval="0" timeout="180s" \

op monitor interval="60s" timeout="60s"

primitive p_fs_rabbitmq ocf:heartbeat:Filesystem \

params device="/dev/drbd/by-res/rabbitmq" \

directory="/var/lib/rabbitmq" fstype="xfs"

primitive p_ip_mysql ocf:heartbeat:IPaddr2 \

params ip="10.109.36.198" cidr_netmask="24" \

op monitor interval="30s"

primitive p_ip_rabbitmq ocf:heartbeat:IPaddr2 \

params ip="10.109.36.198" cidr_netmask="24" \

op monitor interval="10s"

primitive p_rabbitmq ocf:rabbitmq:rabbitmq-server \

params nodename="rabbit@localhost" mnesia_base="/var/lib/rabbitmq" \

op monitor interval="20s" timeout="10s"

primitive p_mysql ocf:heartbeat:mysql \

params additional_parameters="--bind-address=0.0.0.0 config=/etc/mysql/my.cnf" pid="/var/run/mysqld/mysqld.pid" socket="/var/run/mysqld/mysqld.sock" log="/var/log/mysql/mysqld.log" \

op monitor interval="20s" timeout="10s" \

op start interval="0" timeout="120s" \

op stop interval="0" timeout="120s"

roup g_rabbitmq p_ip_rabbitmq p_fs_rabbitmq p_rabbitmq \

meta target-role="Started"

group g_mysql p_ip_mysql p_fs_mysql p_mysql

ms ms_drbd_mysql p_drbd_mysql \

meta notify="true" clone-max="2"

ms ms_drbd_rabbitmq p_drbd_rabbitmq \

meta notify="true" master-max="1" clone-max="2" target-role="Started"

colocation c_mysql_on_drbd inf: g_mysql ms_drbd_mysql:Master

colocation c_rabbitmq_on_drbd inf: g_rabbitmq ms_drbd_rabbitmq:Master

order o_drbd_before_rabbitmq inf: ms_drbd_rabbitmq:promote g_rabbitmq:start

order o_drbd_before_mysql inf: ms_drbd_mysql:promote g_mysql:start

order order1 inf: g_rabbitmq:start g_mysql

property $id="cib-bootstrap-options" \

dc-version="1.1.6-9971ebba4494012a93c03b40a2c58ec0eb60f50c" \

cluster-infrastructure="openais" \

expected-quorum-votes="3" \

no-quorum-policy="ignore" \

pe-warn-series-max="1000" \

pe-input-series-max="1000" \

pe-error-series-max="1000" \

cluster-recheck-interval="5min" \

stonith-enabled="false"

crm(live)configure# commit

接著再執行 # crm_mon 應該就可以看到MySQL和RabbitMQ開起來了。

GlusterFS Performance Tuning

2014-04-21T20:17:00.001+08:00

前言

GlusterFS 是一套OpenSource的Distributed File System. 簡單來說，他可以把多台多個儲存資源串連起來變成一個或多個Pool。每一個Pool支援Global Namespace/Common Namespace的特性，也就是說，在不同地方掛載同一個Pool看到的會是相同的東西。

有使用過GlusterFS的人都會發現，以Default的Configuration來跑GlusterFS將會得到慘不忍睹的笑能。因此在這邊分享及驗證透過修改GlusterFS不同的參數對於效能的幫助

Configurations

修改的參數我把他分為三類，分別是IO，Cache和Network的參數修改。

I/O

io-thread-count (16-> 64)

最多同時IO的Thread個數。數字越大就允許越多同時的R/W。特別是當你有RAID的時候可以調高這參數。Default值是16

write-behind-window-size(1MB-> 1GB)

per-file的write behind buffer. Default值是1MB。

Cache

cache-size (32MB-> 2GB)

read cache的Size。Default值是32MB

cache-max-file-size (-> 16384PB)

設定最多file cached的大小。

cache-min-file-size (-> 0)

cached file最小的大小。

Network

auto tuning(-> disable)

OS會根據網路的throughput來動態調整TCP的window size。但是如果是在穩定的Lan環境這功能是用不到的，因此關閉他來避免奇怪的問題。

Performance Testing

上述列了幾個Tuning的參數，接下來實際針對每個參數的調整來驗證改善的成效。

Experiment Environment and Method

實驗的環境是兩台Server串成一個GlusterFS cluster。然後在一台Server mount起來，利用iozone來驗證效能。三台的規格都一樣如下圖。

Experiment Configuration

重新歸納一下調整個參數並且給每一個case做編號。

Experiment Result

Write

從寫入的結果來看，在調整了write-behind-buffer後效能有得到非常大的改善。而理所當然的，record size會影響整個throughput。在record=1024KB的時候有較好的結果。

ReWrite

在rewrite的實驗和write有相近的結果。一樣是透過調整write-behind-buffer 來得到效能的改善。

Read

在Read測試當中，可以發現在record size比較小的時候，關閉tso, gro和gso會有較快的效能。不過這個結果應該與網卡及driver有關。

Re-read

Reread與read有相近的結果。在大record size時一樣能得到較好的throughput。

Conclusion

write-behind-buffer很明顯的改善了寫入的速度。我想這就跟在NFS sync/async的差別一樣吧。

在這次的實驗中，沒有RAID 卡也沒有做multi-IO的測試。猜想應該是這個原因才看不出io-thread-count的效果。

Delete Symantec Netbackup Disk Pool

2014-04-18T11:12:00.004+08:00

The process is :

Expire all backup image
Delete all image fragment
Delete Disk Pool

So fist, issue bpimmedia to get backup_id
# bpimmedia -L -client [client name]

and then expire the image
# bpexpdate -backupid [backupid] -d 0

Second, delete all image fragment by issue nbdelete
# nbdelete --allvolumes -force

Finally, delete disk pool from Administration console or Administrator JAVA console

No Dropbox icon in Ubuntu 13.10

2014-04-11T15:46:00.004+08:00

1. Install package
# sudo apt-get install libappindicator1
2. Log out, and then log back in (or issue dropbox stop && dropbox start at the command line)

REF

Linux Kernel Performance Tuning and Hardening

2014-04-11T15:18:00.001+08:00

[Security]Deactivates automatic answers to ICMP broadcasts and protects against smurf attacks.

net.ipv4.icmp_echo_ignore_broadcasts=1

[Security]Enable source validation by reversed path, as specified in RFC1812

/*
0 - No source validation.
1 - Strict mode as defined in RFC3704 Strict Reverse Path. 
    Each incoming packet is tested against the FIB and if the interface
    is not the best reverse path the packet check will fail. 
    By default failed packets are discarded.
2 - Loose mode as defined in RFC3704 Loose Reverse Path. 
    Each incoming packet's source address is also tested against the FIB
    and if the source address is not reachable via any interface the packet check will fail.
*/
net.ipv4.conf.all.rp_filter = 1

[Performance]The number of possible inotify(7) watches

fs.inotify.max_user_watches = 65536

[Tuning]Avoid deleting secondary IPs on deleting the primary IP.

/*
If you remove the primary IP address, all secondary addresses are purged by default as well. 
*/
net.ipv4.conf.default.promote_secondaries = 1
net.ipv4.conf.all.promote_secondaries = 1"

[Security]Not allow source route

net.ipv4.conf.default.accept_source_route = 0

[Tuning]Disable listen for router advertisements in order to choose an IPV6 address and router

net.ipv6.conf.all.autoconf = 0
net.ipv6.conf.all.accept_ra = 0

[Security]Do not allow redirect

net.ipv4.conf.all.accept_redirects = 0
net.ipv4.conf.default.accept_redirects = 0
net.ipv4.conf.all.secure_redirects = 0
net.ipv4.conf.default.secure_redirects = 0

[Tuning]Avoid tcp timeout

net.ipv4.tcp_timestamps = 0

[Performance]Maximum amount for the receive socket memory

net.core.rmem_max = 33554432
net.core.wmem_max = 33554432
net.core.rmem_default = 262144
net.core.wmem_default = 262144
net.ipv4.tcp_rmem = 32768 262144 33554432
net.ipv4.tcp_wmem = 32768 262144 33554432

[Performance]Max open file

fs.file-max = 200000

[Performance]The number of IPC message queue resources allowed

kernel.msgmni = 1024

[Performance]How many semaphore arrays, semaphores can be allocate and how many semaphores can be in a single semaphore array

kernel.sem = 400 307200 128 1024

[Performance]Keepalive time

net.ipv4.tcp_keepalive_time = 900
net.ipv4.tcp_keepalive_probes = 5
net.ipv4.tcp_keepalive_intvl = 10

[Performance] Page cache limit.

/*Some app use large amounts of memory for accelerated access to business data
Parts of this memory are seldom accessed. When a user request then needs to
access paged out memory, the response time is poor. It is even worse, when an
SAP solution running on Java incurs a Java garbage collection. The system
starts heavy page-in (disc I/O) activity and has a poor response time for an
extended period of time.*/
vm.pagecache_limit_mb = 41000

Max number of open file

* hard nofile 32768
* soft nofile 32768

Setup git server

2014-04-09T13:20:00.001+08:00

以前在使用git的時候都是同事幫忙架設，這次剛好有機會順便紀錄一下

Git Server

1. 安裝必要套件

# apt-get install git-core

2. 建立repository

假設所有的project都欲放置/opt/git 並且建立名為project1的git
a. # mkdir /opt/git
b. # mkdir /opt/git/project1
# cd /opt/git/project1
# git --bare init

Git Client

在使用者端，假設project的位置是~/projectA

# mkdir ~/projectA

# cd ~/projectA

# git init

# echo "project init">>init

# git add .

# git commit -m "init project"

# git remote add origin user@[IP]:/opt/git/project1

# git push origin master

iSCSI Target and Initiator

2014-04-08T16:50:00.002+08:00

iSCSI Target是Server端，提供iSCSI 空間。
iSCSI Initiator是Client端，連接既有的iSCSI空間來使用。

iSCSI Target

在Ubuntu上安裝

1. 選擇要提供空間的裝置

提供服務的空間可以是一個硬碟、一個partition、一個LVM的LV或是使用DD產生一個空間。
使用以下的方法可以在/media下產生一個20G名稱為volume0的空間。

# dd if=/dev/zero of=/media/volume0 count=0 obs=1 seek=20G

2. 安裝必要套件

使用APT來安裝必要套件

# apt-get install iscsitarget iscsitarget-dkms

3. 設定iSCSI

a. 設定開機自動啟動

Edit /etc/default/iscsitarget

change

ISCSITARGET_ENABLE=false

ISCSITARGET_ENABLE=true

b. 設定iSCSI Target

Edit /etc/iet/ietd.conf

加入

Target iqn.2010-12.nl.ytec.arbiter:arbiter.blabla.lun1

Lun 0 Path=/media/volume0,Type=fileio,ScsiId=lun0,ScsiSN=lun0

其中，需要修改的參數是:

I. Target 後面接的名字，可自訂。

II. Lun一定要從0開始。

III. PATH後面接的參數是空間的位置，如果是剛剛使用dd 產生出來的則為/media/volume0否則更改為實際的空間例如/dev/sdb1 etc.

4. 重新啟動iSCSI Target

# /etc/init.d/iscsitarget restart

iSCSI Initiator

以OpenSuse為例

1. 安裝必要套件

# yast -i open-iscsi

2. 搜尋可用iSCSI Lun

使用iscsiadm來搜尋可用的裝置

# iscsiadm -m discovery --type=st --portal=[iscsi target的IP]

sample output:

192.168.1.101:3260,1 iqn.2010-12.nl.ytec.arbiter:arbiter.blabla.lun1

3. 連接裝置

確定找的到裝置之後就可以連接iSCSI裝置

# iscsiadm -m node -T iqn.2010-12.nl.ytec.arbiter:arbiter.blabla.lun1 --login

使用lsscsi來檢查是否有連接成功

# lsscsi

Sample output:

[0:2:0:0] disk Intel MegaSR 1.0 /dev/sda

[1:2:0:0] disk Intel RMS25CB080 3.22 /dev/sdb

[18:0:0:0] disk IET VIRTUAL-DISK 0 /dev/sdc

4. 掛載裝置

假設我們欲將裝置format成XFS並掛載到/opt/iscsi

# mkfs.xfs /dev/sdc

# mkdir /opt/iscsi

# mount -t xfs /dev/sdc /opt/iscsi

大資料資料庫儲存-NoSQL比較及效能差異(VII)

2014-04-04T21:06:00.000+08:00

在大資料資料庫儲存的最終篇將比較各NoSQL的差異和效能的比較。

NoSQL 比較

Experiment Environment

Hardware and Network Topology

Software Version

MySQL VS Big Data

Insert Data

Update Data

Look-up Data

Delete Data

大資料資料庫儲存-Memcache和Redis介紹(VI)

2014-04-04T20:54:00.001+08:00

Memcahce和Redis都是大多數被拿來當Cache system用途的NoSQL。他們的共通點是都是以Key-Value的形式將資料存在記憶體中。因此R/W的IO非常的快。

而兩個比較大的差別是，Redis可以將資料儲存在Local Drive中，而Memcache只能存在memory。另外一點則是，Memcache的value沒有型別而Redis則支援多種型別ex. map, set, list etc.

Memcahce

Memcache Use Scenario

REDIS

REDIS Data Type

大資料資料庫儲存--MongoDB介紹(V)

2014-04-04T20:40:00.001+08:00

前一篇介紹了HBase，接著將繼續介紹MongoDB

MongoDB

MongoDB是由10gen這一家公司開發的，與Cassandra和Hbase不同的是，MongoDB是一個document base的一個NoSQL。他支援Auto-sharding的功能另外一個比較特別的是，它內建了以javascript來利用map-reduce的概念搜尋資料。

Data Structure

MongoDB既然說是一個Document base的資料庫，那麼舉個最簡單應用的例子來說明他的優點。假設我們有一個database是紀錄post文章和每個文章的comment。以RDBMS最簡單的方式就是建立兩個table分別存放文章和comment。因此要撈出某一筆文章和其留言就必須要兩個query。

那麼MongoDB呢?既然他是Document base，那麼我們可以在一個document記錄了文章和留言，因此，撈出一篇文章和留言就只需要一個request！

Write Path

MongoDB有三個角色，分別是存放Data的mongod、Cmongod存放shard key和mongos負責做load balance和將使用者的request導到對的shard server。

When to use MongoDB?

MongoDB可以非常lightweight(有人想要取代sqlite)，當你沒有複雜的transaction ex. 不是banking的系統就可以看看MongoDB。

大資料資料庫儲存--HBASE介紹(IV)

2014-04-04T20:18:00.002+08:00

前一篇介紹了Cassandra，而在這裡將繼續介紹Cassandra。

HBase

Hbase是一個Apache top-level的project。他強調的是CAP理論中的CP也就是consistency 和Partition tolerance。

HBase Data Model

既然前一篇介紹了Cassandra，那麼在這裡就以Cassandra的範例來比較Hbase和Cassandra的不同。

Hbase最大的不同是，他的每一個CF(Column family)即為一個map，而每一筆資料的CF的ket set可以是不同的。而另外一點是，在hbase裡，所有的data都為byte array。

HBase Data Path

Hbase有一張很嚇人的圖，它的特點是箭頭特別多。但是我們可以很簡單的理解這張圖

以下圖為例，Hadoop的Data node其實就是很多台可以存放data 的node。以上圖為例，負責回應request的Hbase 節點有兩個。
P.S. Hbase是可以把資料存放在local disk而非HDFS不可的。

使用者(client)會先留到zookeeper，zookeper會將使用者導到其中一台hbase server。使用者Insert依資料時，hbase會先存成hlog(在損毀時可以roll back)然後存到memstore(可以想像成memory 的小database)接著把資料存到HDFS中稱作Hfile。

NoSQL DON'Ts

在NoSQL風靡了幾年之後，開始有人反思：到底NoSQL真的有比傳統的RDBMS好嗎?或者說，我們真的需要NoSQL嗎?

在選擇之前，必須要先了解NoSQL 做不到的事:

另外一個迷思是，很多人認為在大資料的時代下，傳統的RDBMS是無法應付的?真的是如此嗎? 以Facebook為例，他們是使用sharding來存放使用者的post。你的資料有比他多嗎?

大資料資料庫儲存--Cassandra 介紹(III)

2014-04-04T19:44:00.000+08:00

上一篇我們介紹了什麼是NoSQL，在這裡，我們即將慢慢地介紹常見的NoSQL。

Cassandra

Cassandra是Apache Software foundation的top-level project。他是key-value的結構，比較不一樣的是它是tunable的consistency。什麼意思呢?就是說他可以選擇consistency的程度，例如確保2個data node的資料都被更新了才return 成功或是全部都更新了才回傳成功。

Cassandra Data Model

Cassandra的Data model主要有Keyspace對應RDBMS的database、Column family對應Table、Row key對應Primary key和Column name/key對應Column name。

我們可以簡單地把Keyspace裡面的column family(RDBMS的Table)看成是一個map of a sorted map。一個column family是一個sorted map，他的key就是每個row的row key，而value是一個map，存放每一個column 的value e.g. map<column name, column value>。

Cassandra的Column family有兩種分別是Static column Family和Dynamic column family。Static column Family和RDBMS很像，在create column family(table)的時候就定義好schema。而Dynamic column family則是在Insert data的時候，data的你仍舊可以插入未定義的column。舉例來說，假設我們的schema定義了name, email, address，你仍舊可以插入一個叫state的column的data。

另外一個不一樣的是，在RDBMS插入一個空的內容仍舊會佔去空間的。舉例來說，假設插入了一筆資料，其中一個定義4 byte char的欄位是空的，仍舊會佔去4 byte。Cassandra則沒有這個問題。

Cassandra write path

Cassandra Tunable Consistency

Cassandra分了6個consistency level如下表:

大資料資料庫儲存--What is NoSQL(II)

2014-04-04T19:24:00.003+08:00

在上一篇大資料資料庫儲存--傳統的解決方案(I)介紹了在傳統在大資料量的解決方法，而前幾年開始熱門的NoSQL又是什麼東西?對於大資料量又有什麼不一樣的解決方式呢?

The CAP Theorem

在聊NoSQL之前有必要先介紹有名的CAP理論。Wiki是這樣說的:

In theoretical computer science, the CAP theorem, also known as Brewer's theorem, states that it is impossible for a distributed computer system to simultaneously provide all three of the following guarantees:^[1]^[2]

Consistency (all nodes see the same data at the same time)

Availability (a guarantee that every request receives a response about whether it was successful or failed)

Partition tolerance (the system continues to operate despite arbitrary message loss or failure of part of the system)

簡單來說就是在一個分散式的系統裡面只可能同時間滿足consistency, availability和partition tolerance中的其二。

What is NoSQL?

較早之前有人會以為NoSQL就是字面上的意思e.g. 不要SQL。事實上，NoSQL應該被解釋為not only relational database。意思是說有別於關聯式資料庫的資料庫。

NoSQL要解決的是傳統的Relational Database比較難解決(非不能解決)的scalability-尤其是scale-out的方式。當資料量及Request一多的時候怎麼存放這麼多的資料及應付龐大的資料存取問題。而另外一個很大的差別則是schemaless，也就是不像Relational Database在Insert data之前一定要有定義好的schema。

下一篇我們將開始介紹常見的NoSQL

大資料資料庫儲存--傳統的解決方案(I)

2014-04-04T17:41:00.000+08:00

The problem

以MySQL為例，在一個table裡面存放10,000筆資料絕對不是問題。但是，當我們的資料上升到十萬筆、一百萬筆甚至一千萬筆，這個時候對資料庫的影響是什麼?當使用者數量一多，資料庫是否依舊能夠在一定的時間內回覆使用者的要求呢?

Traditional Solution

傳統的解決方法不代表是個落伍的、被淘汰的方法。相對的，是一個被證明可以有效解決是個能夠在Production中實作的一些方法。而事實上，大多數的網站仍舊使用這些方法來解決既有大資料量的問題。

Partition和Sharing最大的差別在-Partition是將一個table的資料切割放置到多個table；而sharing則是將一個table的資料放置到多個database中(通常是多台資料庫實體)。

Pros and Cons

那麼，partition和sharing各有什麼優缺點呢?

Partition

大多數的資料庫其實都已經支援了Partition。Partition的設定方式主要是告訴資料庫要以哪一個column為依據，設定切割的條件。例如int的欄位，可以設定成1~1000為一個table、2000~3000一個table、剩下的一個table。

Partition相對於sharding最大的好處是不需要重寫SQL Logic。資料庫會根據搜尋的條件至相對應的table做query。

但最大的缺點是，儘管是切割成多個table但仍舊是放在同一個database。通常，隨著資料量增加也代表使用者變多了，當然request也變多了。資料庫的效能仍舊受限於該台資料庫所能提供的throughput。

Sharding

Sharding顧名思義的就是將一個table的資料切割放置到多台資料庫中。在實作上，我們可以自己改寫SQL Logic根據我們切割的條件來決定該request要發送到哪一台database。或者，我們也可以看到有許多framework來幫助你完成這件事。例如，MySQL Fabric, Vitess, Gizzard, Jetpants等等。

Sharding好處是資料庫的throughput可以隨著資料庫實體的增加而提升也就是scale out的solution。但最大的壞處是，因為資料散落在不同的資料庫，因此你可能做不到join沒有ACID transaction而且因為所有的查尋會因為資料切割的條件變得更複雜。

How about Big Requests?

前面有提到，資料量的提升通常也代表使用量變多隨之而來的request也變多了。假設我們已經把資料shard到不同資料庫了，我們要怎麼分散流量呢? Open Source的Load balancer solution是 HAProxy, Nginx或是MySQL Proxy(beta)，當然也可以購買貴鬆鬆Hardware load balancer。

另外，MySQL也有MySQL Cluster可以做到load balancer、auto sharding等等。不過就不在本篇的討論中了。

Design Pattern: Singleton in JAVA, C#, C++

2012-07-27T15:47:00.001+08:00

定義:
保證一個class只有一個實體(Instance),並為它提供一個全域的訪問點(global access point)。

有的時候我們希望某個Class只會有一個Instance被產生。例如，Android中如果多個thread去access同一個DB就會產生錯誤。因此我們可能會希望透過一個Instance統一由他去Access 同一個DB。

在JAVA中實作的方式如下:

public class Singleton {
    private volatile Singleton instance = null;
        public Singleton getInstance() {
            if (instance == null) {
                synchronized(this) {
                    if (instance == null)
                        instance = new Singleton();
                }
            }
            return instance;
        }
    }

深入探討:
為了避免multi-thread 的race condition發生及效率，這裡使用double check locking。避免race condtion的發生所以使用synchronized()。但是synchronized()可能造成performance的低落。因此在外層先判斷如果真的是null才進入critical section否則直接return。

在JDK 4（包含）以下的版本不支援volatile。volatile保證再每次取此變數的值時會去memory抓取而非從cache讀取。不加volatile有可能導致程式碼執行順序被 re-order。進而發生其他thread執行實可能看到非null的instance(但他這個時候明明是null)。

另外，上述的作法是lazy-Initialization的作法。也就是說當真正需要的時候才會被new出來。但是如果我們很確定程式中一定會去new這個物件，其實先把他new 出來也不會有什麼損失。

Singleton without Lazy-Initialization

public class Singleton {
    private volatile Singleton instance = new Singleton();
        public Singleton getInstance() {
            return instance;
        }
    }

這樣做的另外一個好處程式碼看起來也比較清爽。

_____________________________________________________________________________________________________________

在C#方式如下:

using System;

public sealed class Singleton
{
   private static volatile Singleton instance;
   private static object syncRoot = new Object();

   private Singleton() {}

   public static Singleton Instance
   {
      get 
      {
         if (instance == null) 
         {
            lock (syncRoot) 
            {
               if (instance == null) 
                  instance = new Singleton();
            }
         }

         return instance;
      }
   }
}

在上面的code中，使用sealed來避免被繼承進而發生可能產生多個instance。另外使用lock的方法來避免multi-thread的race condition。如同在JAVA說的，volatile可以避免out of order所造成的問題。另外，如果不需要lazy-initialization我們可以這樣寫:

public sealed class Singleton
{
   private static readonly Singleton instance = new Singleton();
   
   private Singleton(){}

   public static Singleton Instance
   {
      get 
      {
         return instance; 
      }
   }
}

使用readonly來保證instance只會在static initialization過程時或是在class constructor裡被建立。
_____________________________________________________________________________________________________________

在C++的實作就比較簡單了：

class Singleton {
public: 
    static Singleton* Instance(){
    if (_instance == 0) {
        _instance = new Singleton;
    }
    return _instance;
}
protected: 
    Singleton();
private:
    static Singleton* _instance=0;
}

然而這個作法不是thread safe的。在C++使用如上面提到的Double checked locking方法及使用volatile並不能保證out of order的問題。也就是說在C++上面使用volatile並無法像C#/JAVA上面來保證使用volatile的variable 不會被re-order。因此像下面的DCL的code還是無法保證Thread-Safe。

class  Singleton {  
public :  
    static  Singleton* Instance() {  
        Lock lock;  
        if  (_instance == 0) {  
            _instance =  new  Singleton;  
        }  
        return  _instance;  
    }  
private :  
    static  Singleton *  volatile  _instance;  
    Singleton(){  
    }  
};

最後看到Solstice使用pthread解決這問題，如下：

#include 
template<typename T>
class Singleton : boost::noncopyable
{
public:
    static T& instance()
    {
        pthread_once(&ponce_, &Singleton::init);
        return *value_;
    }
    static void init()
    {
        value_ = new T();
    }
private:
    static pthread_once_t ponce_;
    static T* value_;
};
template<typename T>
pthread_once_t Singleton<T>::ponce_ = PTHREAD_ONCE_INIT;
template<typename T>
T* Singleton<T>::value_ = NULL;

Reference:
Gossip@caterpillar Design Pattern: Simple Factory 模式
The "Double-Checked Locking is Broken" Declaration
MSDN:Implementing Singleton in C#
多线程服务器的常用编程模型

i2c 設備模型

2012-07-20T13:40:00.000+08:00

在http://chxxxyg.blog.163.com/blog/static/150281193201082623428605/看到下面這兩張畫的真好

I2C簡介(二)

2012-07-18T17:43:00.002+08:00

前一篇簡單說明了如果寫I2C device的driver。這篇主要要介紹I2C adapter(controller的Driver)。在這裡我們直接以Tegra3的I2C Controller為例來說明。要注意的是，一個板子可能會有很多controller，而一個controller可能會有多條bus。每一個bus會對應一個adapter。

Board-Specific Code

Tegra3的board-specific code在arch/arm/mach-tegra/device.c 及arch/arm/mach-tegra/board-cardhu.c中。從source code我們可以看出Tegra 3有五組I2C controller。我們先看device.c的部份，在這裡主要是填寫platform_device的資料如下：

//arch/arm/mach-tegra/device.c
static struct resource i2c_resource1[] = {
 [0] = {
  .start = INT_I2C,
  .end = INT_I2C,
  .flags = IORESOURCE_IRQ,
 },
 [1] = {
  .start = TEGRA_I2C_BASE,
  .end = TEGRA_I2C_BASE + TEGRA_I2C_SIZE-1,
  .flags = IORESOURCE_MEM,
 },
};
                               .
                               .
                               .

static struct resource i2c_resource5[] = {
 [0] = {
  .start  = INT_I2C5,
  .end    = INT_I2C5,
  .flags  = IORESOURCE_IRQ,
 },
 [1] = {
  .start = TEGRA_I2C5_BASE,
  .end = TEGRA_I2C5_BASE + TEGRA_I2C5_SIZE-1,
  .flags = IORESOURCE_MEM,
 },
};
#endif

static struct tegra_i2c_platform_data tegra_i2c1_platform_data = {
 .bus_clk_rate   = { 400000 },
};
                               .
                               .
                               .

static struct tegra_i2c_platform_data tegra_dvc_platform_data = {
 .bus_clk_rate   = { 400000 },
};

struct platform_device tegra_i2c_device1 = {
 .name  = "tegra-i2c",
 .id  = 0,
 .resource = i2c_resource1,
 .num_resources = ARRAY_SIZE(i2c_resource1),
 .dev = {
  .platform_data = &tegra_i2c1_platform_data,
 },
};
                               .
                               .
                               .

struct platform_device tegra_i2c_device5 = {
 .name  = "tegra-i2c",
 .id  = 4,
 .resource = i2c_resource5,
 .num_resources = ARRAY_SIZE(i2c_resource5),
 .dev = {
  .platform_data = 0,
 },
};

接著我們繼續看board-cardhu.c。不知道為什麼，在這邊又把platform_data蓋掉＠＠。

static struct tegra_i2c_platform_data cardhu_i2c1_platform_data = {
 .adapter_nr = 0,
        //設定這個controller有幾個bus
 .bus_count = 1,
 .bus_clk_rate = { 100000, 0 },
 .scl_gpio  = {TEGRA_GPIO_PC4, 0},
 .sda_gpio  = {TEGRA_GPIO_PC5, 0},
 .arb_recovery = arb_lost_recovery,
};

                               .
                               .
                               .

static struct tegra_i2c_platform_data cardhu_i2c5_platform_data = {
 .adapter_nr = 4,
 .bus_count = 1,
 .bus_clk_rate = { 400000, 0 },
 .scl_gpio  = {TEGRA_GPIO_PZ6, 0},
 .sda_gpio  = {TEGRA_GPIO_PZ7, 0},
 .arb_recovery = arb_lost_recovery,
};

static struct i2c_board_info __initdata cardhu_codec_wm8903_info = {
 I2C_BOARD_INFO("wm8903", 0x1a),
 .irq = TEGRA_GPIO_TO_IRQ(TEGRA_GPIO_CDC_IRQ),
 .platform_data = &cardhu_wm8903_pdata,
};

static struct i2c_board_info __initdata cardhu_codec_aic326x_info = {
 I2C_BOARD_INFO("aic3262-codec", 0x18),
 .irq = TEGRA_GPIO_TO_IRQ(TEGRA_GPIO_CDC_IRQ),
};

static struct i2c_board_info __initdata cardhu_codec_max98095_info = {
 I2C_BOARD_INFO("max98095", 0x10),
 .irq = TEGRA_GPIO_TO_IRQ(TEGRA_GPIO_CDC_IRQ),
 .platform_data = &cardhu_max98095_pdata,
};

static void cardhu_i2c_init(void)
{
 tegra_i2c_device1.dev.platform_data = &cardhu_i2c1_platform_data;
                        .
                               .
                               .

 tegra_i2c_device5.dev.platform_data = &cardhu_i2c5_platform_data;

 platform_device_register(&tegra_i2c_device5);
                        .
                               .
                               .

 platform_device_register(&tegra_i2c_device1);

        
}

I2C Controller Driver

看完了platform_device的宣告後，我們理所當然的去看platform_driver的地方。實作的位置在driver/i2c/busses/i2c-tegra.c。這裡我們從tegra_i2c_init_driver（）看起。

static int tegra_i2c_probe(struct platform_device *pdev)
{
 struct tegra_i2c_dev *i2c_dev;
 struct tegra_i2c_platform_data *plat = pdev->dev.platform_data;
 struct resource *res;
 struct resource *iomem;
 struct clk *div_clk;
 struct clk *fast_clk = NULL;
 const unsigned int *prop;
 void *base;
 int irq;
 int nbus;
 int i = 0;
 int ret = 0;

        //取得定義在device.c的platform_device 的resource且flag為IORESOURCE_MEM 的資料
 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 
        //檢查從res->start~res->start+ resource_size(res)是否可用
        iomem = request_mem_region(res->start, resource_size(res), pdev->name);
 
        //mapping到kernel虛擬空間
 base = ioremap(iomem->start, resource_size(iomem));
 
 div_clk = clk_get(&pdev->dev, "i2c-div");
 
 fast_clk = clk_get(&pdev->dev, "i2c-fast");
 
        i2c_dev = kzalloc(sizeof(struct tegra_i2c_dev) +
     (nbus-1) * sizeof(struct tegra_i2c_bus), GFP_KERNEL);
 

 i2c_dev->base = base;
 i2c_dev->div_clk = div_clk;
 i2c_dev->fast_clk = fast_clk;
 i2c_dev->iomem = iomem;
 i2c_dev->irq = irq;
 i2c_dev->cont_id = pdev->id;
 i2c_dev->dev = &pdev->dev;
 i2c_dev->is_clkon_always = plat->is_clkon_always;

 i2c_dev->last_bus_clk_rate = 100000; /* default clock rate */
 i2c_dev->last_bus_clk_rate = plat->bus_clk_rate[0];
        i2c_dev->is_high_speed_enable = plat->is_high_speed_enable;
 i2c_dev->last_bus_clk_rate = plat->bus_clk_rate[0] ?: 100000;
 i2c_dev->msgs = NULL;
 i2c_dev->msgs_num = 0;
 rt_mutex_init(&i2c_dev->dev_lock);
 spin_lock_init(&i2c_dev->fifo_lock);

 i2c_dev->slave_addr = plat->slave_addr;
 i2c_dev->hs_master_code = plat->hs_master_code;
 i2c_dev->is_dvc = plat->is_dvc;
 i2c_dev->arb_recovery = plat->arb_recovery;
 init_completion(&i2c_dev->msg_complete);

 if (irq == INT_I2C || irq == INT_I2C2 || irq == INT_I2C3)
  i2c_dev->is_slave = true;

 platform_set_drvdata(pdev, i2c_dev);

 if (i2c_dev->is_clkon_always)
  tegra_i2c_clock_enable(i2c_dev);

 ret = tegra_i2c_init(i2c_dev);
 if (ret) {
  dev_err(&pdev->dev, "Failed to initialize i2c controller");
  goto err_free;
 }

 

 for (i = 0; i < nbus; i++) {
  struct tegra_i2c_bus *i2c_bus = &i2c_dev->busses[i];

  i2c_bus->dev = i2c_dev;
  i2c_bus->mux = plat->bus_mux[i];
  i2c_bus->mux_len = plat->bus_mux_len[i];
  i2c_bus->bus_clk_rate = plat->bus_clk_rate[i] ?: 100000;

  i2c_bus->scl_gpio = plat->scl_gpio[i];
  i2c_bus->sda_gpio = plat->sda_gpio[i];

  i2c_bus->adapter.dev.of_node = pdev->dev.of_node;
  i2c_bus->adapter.algo = &tegra_i2c_algo;
  i2c_set_adapdata(&i2c_bus->adapter, i2c_bus);
  i2c_bus->adapter.owner = THIS_MODULE;
  i2c_bus->adapter.class = I2C_CLASS_HWMON;
  strlcpy(i2c_bus->adapter.name, "Tegra I2C adapter",
   sizeof(i2c_bus->adapter.name));
  i2c_bus->adapter.dev.parent = &pdev->dev;
  i2c_bus->adapter.nr = plat->adapter_nr + i;

                //!!將此bus註冊進kernel中
  ret = i2c_add_numbered_adapter(&i2c_bus->adapter);
                //註冊此bus的adapter
  of_i2c_register_devices(&i2c_bus->adapter);

  i2c_dev->bus_count++;
 }

 return 0;
        ...
}

static struct platform_driver tegra_i2c_driver = {
 .probe   = tegra_i2c_probe,
 .remove  = tegra_i2c_remove,
 .driver  = {
  .name  = "tegra-i2c",
  .owner = THIS_MODULE,
  .of_match_table = tegra_i2c_of_match,
  .pm    = TEGRA_I2C_DEV_PM_OPS,
 },
};

static int __init tegra_i2c_init_driver(void)
{
        //註冊tegra_i2c_driver，跳到tegra_i2c_probe繼續看
 return platform_driver_register(&tegra_i2c_driver);
}
subsys_initcall(tegra_i2c_init_driver);

Reference

I2C簡介(一)

2012-07-18T15:07:00.001+08:00

I2C簡介

I2C 全名是Inter IC，原先是Phillips發展的一個two-wire 的serial bus protocol。他是一種半雙工同步多組設備匯流排。只需要兩條線:串列資料線(SDA)與串列時脈線(SCL or SCK)。I2C 提供兩種定址模式與三種傳輸模式。定址方面分成10-bit（允許連接1024個裝置）與 7-bit （允許連接128個裝置）。傳輸方面則有10kbps 的低速模式、100kbps 的標準模式、及 400kbps 的快速模式。

I2C連接的裝置都是Open Drain的接腳，也就是說導通的時候電位是low，而不導通時為high。I2C通常用在嵌入式系統與不同的裝置溝通。在PC，I2C通常用來與不同的sensor 連結例如取得系統風扇的轉速、CPU的溫度等等。

I2C in Linux

I2C 在kernel 2.x的時候開始支援。在Linux Kernel中，I2C的code拆成四個部份: I2C core、I2C bus drivers、I2C algorithm drivers 和 I2C chip drivers。

舉一個例子，一個PMU(power management unit)利用I2C與SOC連結。要使PMU能夠正確運作我們必須先撰寫I2C adapter(controller)的driver，讓I2C bus可以正常運作。I2C adapter(controller)可能是外接的chip也可能是在SOC裡頭例如Tegra3擁有五組I2C controller。再來，我們必須撰寫PMU的driver，註冊進正確的I2C bus中。透過adapter(controller)與device溝通。

這一篇的介紹是在於如何撰寫下圖的i2c client driver來控制(R/W)i2c device。
一個板子可能會有很多controller，而一個controller可能會有多條bus。每一個bus會對應一個adapter。

撰寫I2C Device Driver

在這裡我們直接以TI的PMU tps6591為例子說明。原始碼一樣可以透過下面 reference中抓取。
我們首先先看看tps6591 board-specific code的地方。我們看cardhu_regulator_init()。

//arch/arm/mach-tegra/board-cardhu-power.c
static struct tps6591x_platform_data tps_platform = {
        //pmu的irq起始編號
 .irq_base = TPS6591X_IRQ_BASE,
        //gpio的起始編號
 .gpio_base = TPS6591X_GPIO_BASE,
 .dev_slp_en = true,
 .slp_keepon = &tps_slp_keepon,
 .use_power_off = true,
};

static struct i2c_board_info __initdata cardhu_regulators[] = {
    {
        //設定pmu的i2c device number
        I2C_BOARD_INFO("tps6591x", 0x2D),
        .irq    = INT_EXTERNAL_PMU,
        .platform_data = &tps_platform,
    },
};

int __init cardhu_regulator_init(void){
    ...
    /**註冊i2c device進list: __i2c_board_list
      *bus number=4  
      *device info=cardhu_regulators
      *#device=1 
    */
    i2c_register_board_info(4, cardhu_regulators, 1);
    ...
}

接著在tps6591的driver中，我們從tps6591x_init()看起。

//driver/mfd/tps6591x.c

static int __devinit tps6591x_i2c_probe(struct i2c_client *client,
     const struct i2c_device_id *id)
{
 struct tps6591x_platform_data *pdata = client->dev.platform_data;
 struct tps6591x *tps6591x;
 int ret;

 if (!pdata) {
  dev_err(&client->dev, "tps6591x requires platform data\n");
  return -ENOTSUPP;
 }

 ret = i2c_smbus_read_byte_data(client, TPS6591X_VERNUM);
 if (ret < 0) {
  dev_err(&client->dev, "Silicon version number read"
    " failed: %d\n", ret);
  return -EIO;
 }

 dev_info(&client->dev, "VERNUM is %02x\n", ret);

 
        //same as dev_set_drvdata(&dev->dev, data);
 i2c_set_clientdata(client, tps6591x);

 mutex_init(&tps6591x->lock);

 ...

 tps6591x_i2c_client = client;

 return 0;

err_add_devs:
 if (client->irq)
  free_irq(client->irq, tps6591x);
err_irq_init:
 kfree(tps6591x);
 return ret;
}

static struct i2c_driver tps6591x_driver = {
 .driver = {
  .name = "tps6591x",
  .owner = THIS_MODULE,
 },
 .probe  = tps6591x_i2c_probe,
 .remove  = __devexit_p(tps6591x_i2c_remove),
#ifdef CONFIG_PM
 .suspend = tps6591x_i2c_suspend,
 .resume  = tps6591x_i2c_resume,
#endif
 .id_table = tps6591x_id_table,
};

static int __init tps6591x_init(void)
{
        /**註冊I2C device driver
         *將這個driver與bus做配對並呼叫probe
        */
 return i2c_add_driver(&tps6591x_driver);
}

R/W VIA I2C

如何從I2C device讀取資料呢？我們以 tps6591x_read為例：

static inline int __tps6591x_read(struct i2c_client *client,
      int reg, uint8_t *val)
{
 int ret;
        //read data from address:reg
 ret = i2c_smbus_read_byte_data(client, reg);
 if (ret < 0) {
  dev_err(&client->dev, "failed reading at 0x%02x\n", reg);
  return ret;
 }

 *val = (uint8_t)ret;

 return 0;
}

讀取資料呢？我們以 tps6591x_write為例：

static inline int __tps6591x_write(struct i2c_client *client,
     int reg, uint8_t val)
{
 int ret;
        //write value:val to address:reg
 ret = i2c_smbus_write_byte_data(client, reg, val);
 if (ret < 0) {
  dev_err(&client->dev, "failed writing 0x%02x to 0x%02x\n",
    val, reg);
  return ret;
 }

 return 0;
}

其他的 read/write可以參考driver/i2c/i2c-core.c

Reference

下一篇:I2C簡介(二)

Linux Kernel Portability-Data type & Data Structure in Linux kernel (二)

2012-07-11T15:09:00.002+08:00

在上一篇著重於Linux Kernel 的Portability。這一篇將著重於Linux Kernel的Data Structure。這裡要介紹的Data Structure包括了Linked lists、Queues、Maps、及Binary trees。

Linked List

這裡直接講用法。Linux Kernel的Linked List是Double Linked List，而且List裡面的元素必須是list_head的structure。舉個例好了，我們要做到如下圖(A B C都是struct sample好了):

struct sample{
    struct list_head link;
    vold *content;
}
struct sample *A,*B,*C;
現在我們要把ABC串起來。首先我們建立一個叫list_head的Linked list的變數，並初始化它。常見的方法有兩種，結果是一樣的。
/**
*1. LIST_HEAD(name)
*2. INIT_LIST_HEAD
*/
//method 1
static LIST_HEAD(list_head);

//method 2
struct list_head list_head;
INIT_LIST_HEAD(&list_head);
接著假設我們要先加入A和C，利用list_add()將A加入到list_head後面。然後在將C加入到A後面。
//Add A after list_head,list_head is the head of the list
//e.g list_head->A
list_add(&A->link,&list_head);

//Add C after A e.g list_head->A->C
list_add(&C->link,&A->link);
接著，我們要利用list_add_tail將B加在C之前
//Add B before C e.g list_head->A->B->C
list_add_tail(&B->link,&C->link);
加完了之後我們要怎麼列出List裡面的項目呢？可以利用list_for_each來達成。
//list_for_each(struct list_head *cursor, struct list_head *list)
list_for_each(&A->link,&list_head){

}
更多的用法可見<linux/list.h>

Queue

Linux Kernel的queue叫做kfifo實做在kernel/kfifo.c 宣告在<linux/kfifo.h>。與我們所知的queue相同，kfifo支援enqueue(函式命名成inqueue)跟dequeue。同樣的，kfifo有兩個offset分別是記錄下一個插入位置的enqueue offset跟下一個取出位置的dequeue offset。

接下來介紹kfifo的使用方式分為 1. Declare 2. Enqueue/Dequeue 3. Other operation。

Declare

a. 利用kfifo_alloc() 動態宣告
struct kfifo fifo;
int ret;
      //宣告一個大小為PAGE_SIZE的queue
ret = kfifo_alloc(&kifo, PAGE_SIZE, GFP_KERNEL);
if (ret)
return ret;
b. 利用DECLARE_KFIFO(name, size)建立 INIT_KFIFO(name)初始化。

Enqueue/Dequeue

kfifo_in(fifo, buf, n) 將n byte的buf讓入fifo裡。如果fifo free的大小<n 則只會copy free 的size的資料

kfifo_out(fifo, buf, n) copy n byte到buf中。如果fifo的大小<n 則只會copy fifo大小的data

kfifo_out_peek(fifo, buf, n) kfifo_out執行後data就會從fifo中刪除。如果想保留可以使用kfifo_out_peek

Other Operation

kfifo_size(fifo) 取得fifo大小

kfifo_len(fifo) 取得fifo已使用大小

kfifo_avail(fifo) 取得fifo可使用大小

kfifo_is_empty(fifo) 判斷fifo是否為空

kfifo_is_full(fifo) 判斷fifo是否已滿

kfifo_reset(fifo) 清空fifo。

kfifo_free(fifo) free掉fifo

實際的操作範例

struct kfifo fifo;
int ret;

//宣告一個大小為PAGE_SIZE的queue
ret = kfifo_alloc(&kifo, PAGE_SIZE, GFP_KERNEL);
if (ret)
    return ret;
int i;
//插入32個size為sizeof(int)的[0,31]到fifo中
for (i = 0; i < 32; i++)
    kfifo_in(fifo, &i; sizeof(i));

unsigned int val;
int ret;

//從fifo讀取一個integer到val 中。資料不會被刪除
ret = kfifo_out_peek(fifo, &val, sizeof(val));
if (ret != sizeof(val))
    return -EINVAL;

printk(KERN_INFO “%u\n”, val); /* should print 0 */


/* while there is data in the queue ... */
while (kfifo_avail(fifo)) {
    unsigned int val;
    int ret;
    /* ... read it, one integer at a time */
    ret = kfifo_out(fifo, &val, sizeof(val));
    if (ret != sizeof(val))
        return -EINVAL;

    printk(KERN_INFO “%u\n”, val);
}

Red-Black Tree

紅黑樹是一種semi-balanced binary tree(自平衡二元樹)。主要有以下六種性質：

節點不是紅色就是黑色。

根節點是黑色。

所有葉子都是黑色（葉子是NIL節點 e.g不包含資料）。

每個紅色節點的兩個子節點都是黑色。(從每個葉子到根的所有路徑上不能有兩個連續的紅色節點)

從任一節點到其每個葉子的所有最短路徑都包含相同數目的黑色節點。

紅黑樹在Linux Kernel實作的地方是lib/rbtree.c宣告的地方在<linux/rbtree.h>。這裡直接以 driver/media/video/tegra/avp/avp.c裡面的實作來解釋rbtree的使用。avp.c定義了一個tegra_avp_info的struct，以下擷取其實做。要使用rbtree必須要宣告一個rb_root的變數如下：
struct tegra_avp_info {
 ...
 struct rb_root  endpoints;
        ...
};
要開始使用endpoints這個rbtree之前必須給他初始的值"RB_ROOT"如下：
static int tegra_avp_probe(struct platform_device *pdev)
{
    struct   *avp;
    avp = kzalloc(sizeof(struct tegra_avp_info), GFP_KERNEL);
    ...
    avp->endpoints = RB_ROOT;
    ...
}
Linux Kernel的rbtree不包含插入及搜尋的函式，下面同樣以avp的"插入"來說明。
static struct remote_info *remote_find(struct tegra_avp_info *avp, u32 local_id)
{
 struct rb_node *n = avp->endpoints.rb_node;
 struct remote_info *rinfo;

 while (n) {
  rinfo = rb_entry(n, struct remote_info, rb_node);

  if (local_id < rinfo->loc_id)
   n = n->rb_left;
  else if (local_id > rinfo->loc_id)
   n = n->rb_right;
  else
   return rinfo;
 }
 return NULL;
}
以上例，remote_find()實作搜尋的功能。while loop會traverse整個tree 直到找到相同的id。
static int remote_insert(struct tegra_avp_info *avp, struct remote_info *rinfo)
{
 struct rb_node **p;
 struct rb_node *parent;
 struct remote_info *tmp;

 p = &avp->endpoints.rb_node;
 parent = NULL;
 while (*p) {
  parent = *p;
  tmp = rb_entry(parent, struct remote_info, rb_node);

  if (rinfo->loc_id < tmp->loc_id)
   p = &(*p)->rb_left;
  else if (rinfo->loc_id > tmp->loc_id)
   p = &(*p)->rb_right;
  else {
   pr_info("%s: avp endpoint id=%x (%s) already exists\n",
    __func__, rinfo->loc_id,
    trpc_name(rinfo->trpc_ep));
   return -EEXIST;
  }
 }
 rb_link_node(&rinfo->rb_node, parent, p);
 rb_insert_color(&rinfo->rb_node, &avp->endpoints);
 rinfo_get(rinfo);
 return 0;
}
以上例，while loop會traverse rbtree去尋找適合的頁節點，然後透過rb_link_node()去link parent。接著再透過rb_insert_color()上色。
static void remote_remove(struct tegra_avp_info *avp, struct remote_info *rinfo)
{
 rb_erase(&rinfo->rb_node, &avp->endpoints);
 rinfo_put(rinfo);
}
刪除節點很簡單，只要呼叫rb_erase（）即可。

Radix Tree

Radix Tree使用相對於Red Block Tree來說簡單許多。這裡以之前提過得irq實做為例看看Radix Tree怎麼使用。

Radix Tree實做在lib/radix- tree.c，下面以kernel/irqdesc.c來了解。

//Declare a radix tree called irq_desc_tree
static RADIX_TREE(irq_desc_tree, GFP_KERNEL);

static void irq_insert_desc(unsigned int irq, struct irq_desc *desc)
{
        //Insert  into irq_desc_tree
 radix_tree_insert(&irq_desc_tree, irq, desc);
}

struct irq_desc *irq_to_desc(unsigned int irq)
{
        //取得key為irq的value
 return radix_tree_lookup(&irq_desc_tree, irq);
}

static void delete_irq_desc(unsigned int irq)
{
        //刪除key為irq的pair
 radix_tree_delete(&irq_desc_tree, irq);
}

Reference

Linux Kernel Development Third Edition

Linux Device Drivers, Third Edition

Essential Linux Device Drivers

Writing Portable Device Driver

Trees I: Radix trees

Trees II: red-black trees

上一篇:Linux Kernel Portability-Data type & Data Structure in Linux kernel (一)

Linux Kernel Portability-Data type & Data Structure in Linux kernel (一)

2012-07-10T10:49:00.000+08:00

前言

Linux作為一個跨平台(處理器)的作業系統必須兼容許多不同的CPU 架構設計。也因此，Linux Kernel裡面有許多是為了Portability而產生的包含衍生的資料型態及提供的資料結構。

為了讓我們的Kernel 的module可以順利在我們的Target上或在各平台上順利執行，我們勢必就需要了解哪些方面會是Platform-Independent，Linux Kernel如何解決這個問題。

The Size of Data Types

在說明Kernel專有的資料型態前，我們先了解標準C資料型態在各平台的差異。以下圖為例，在常見的平台上，char、short、int、long long大小是一致的。但是long、ptr、word的大小則會因平台不同而有所差別。因此，如何在各平台確切的得到我們希望的變數大小就非常重要了。換句話說，假設我們希望某個變數他是8個bits，他就不會因為平台的不同而變成立如4個bits。

因此，Linux Kernel就定義了幾個標準大小的資料型態在include/linux/types.h。在include/linux/types.h裡他include了asm/types.h。以ARM平台為例，arch/arm/include/asm/types.h include了asm-generic/int-ll64.h。在int-ll64.h就定義了:

u8    unsigned byte (8 bits)
u16   unsigned word (16 bits)
u32   unsigned 32-bit value
u64   unsigned 64-bit value
s8    signed byte (8 bits)
s16   signed word (16 bits)
s32   signed 32-bit value
s64   signed 64-bit value
u代表的是unsigned而s則是代表signed分別定義了8~64bits的標準大小型態。假設在user space的程式要使用固定長度的型別，記得前面要加上__例如"__u8"。

然而，C99規範了標準大小的資料型態uintN_t及intN_t對應著uN及sN定義在stdint.h。N代表8、16、 32、64。因此，不管是Kernel Module或是user space 的program特別是如果你的程式是想跨平台(OS)的，就盡量使用C99的資料型態而非Linux Kernel的資料型態。

Interface-Speciﬁc Types

Linux Kernel為了移植性也定義了許多_t結尾的變數在 <include/types.h>。舉例來說常見的size_t、ssize_t、pid_t、time_t等等根據特定意義的資料型態就稱為Interface-Specific Type。以process 的id pid_t為例，在x86來說是 int，但是假設我們直接將例如getpid()的回傳值用 int用接收，哪天另外一個平台的pid是long long的話勢必我們程式必須作修改才能正確運行。因此，Interface-Specific Type可以避免移植的問題。

Data Alignment

大多數的CPU都會要求變數擺在特定的記憶體上。例如Intel x86的CPU要求4 byte的integer是放置在4的倍數的記憶體位置。這個就叫做Memory Alignment。但假設不是擺在4的倍數上呢？那就必須要讀取兩次才能得到這個變數。大多數的CPU都可以自己處理這個狀況，但是有些CPU沒辦法處理這個問題，必須要產生exception靠exception handler來處理這個問題，但是這樣效率會非常的慢。有個方法是使用get_unaligned(ptr)取得資料及set_unaligned(val,ptr)寫入資料。例如，在driver/power/bq27x00_battery.c裡面
if (!single)
    ret = get_unaligned_le16(data);
else
    ret = data[0];
如果資料是1個byte就直接讀取否則用get_unaligned_le16()。le代表little-endian。

順帶一提，compiler在做最佳化的時候可能會自動做Memory Aligned的動作。但也許我們定義的資料結構變數間的位址是必須連續的(的動作可能會在變數間填補一些變數讓memory可以對齊)，這個時候我們可以利用__attribute__ ((packed))告訴編譯器不要亂動。
struct{
    u16 uid;
    u64 gid;
    u16 val0;
    u32 val1;
}__attribute__ ((packed))structA;

Byte Order

假設有一個4 byte的int不同的CPU可能會有不同的記憶體擺法，例如低位的值先放(Little-Endian)還是大的先放(Big-Endian)?舉例來說，假設有一個整數值是0x12345678 Little-Endian的擺法就會是:
address        value
0x00000001     0x78
0x00000002     0x56
0x00000003     0x34
0x00000004     0x12
而如果是Big-Endian的話則是:
address        value
0x00000001     0x12
0x00000002     0x34
0x00000003     0x56
0x00000004     0x78
如果我們要得到Little-Endian順序的值可以使用u32 cpu_to_le32(u32)，更多的轉換函式可以在找到。

Time

HZ定義了一秒鐘有幾次 Interrupt。他可以是100、250、300或是1000。預設的值可能會隨著 Kernel的版本或編譯Kernel 的設定而改變。因此，我們不可以假設HZ==1000(舊版的Kernel預設是1000)。
順帶一提，Tick是HZ的倒數，因此假設HZ=1000則一個tick就是1毫秒。
Jiffies是Linux Kernel用來紀錄系統自開機以來觸發了幾次Interrupt(開機時並非歸0)。Linux Kernelchewing每秒鐘會將jiffies加1HZ次。我們可以利用Linux Kernel定義的macro(timer_after、time_after_eq、time_before和time_before_eq)來判斷時間。因此，假設我們要判斷時間是否過了三秒可以:
//設定時間是現在的jiffies加上3秒的HZ次
unsigned long timeout = jiffies + (3*HZ);  
while (hwgroup->busy) {  
     ...
  /*如果迴圈超過三秒(也就是說現在的jiffies數超過三秒前的jiffies+3*HZ次)
   *則return -EBUSY
   */
  if (time_after(jiffies, timeout)) {  
    return -EBUSY;  
  }  
  ...  
}  
return SUCCESS; 

Page Size

不要假設Page Size是4KB。用Linux Kernel提供的PAGE_SIZE 來取得系統的page size及PAGE_SHIFT取得要左移的bits數達到其memory page的number。

Reference

Linux Kernel Development Third Edition

Linux Device Drivers, Third Edition

Essential Linux Device Drivers

Writing Portable Device Driver

下一篇:Linux Kernel Portability-Data type & Data Structure in Linux kernel (二)

Linux Interrupt 整理（一）

2012-07-05T16:35:00.003+08:00

前言

CPU的速度很快，假設每每都必須等待週邊的硬體動作完成CPU才能繼續工作的話，效率未免太低了。因此，我們的系統設計了中斷(Interrupt)，當有 event 發生(例如工作完成)就觸發一個Interrupt告訴CPU，這時候CPU就會"馬上"去處理。這麼一來就可以避免等待時間的浪費。

我們可以針對裝置的Interrupt建立Handler，讓不同的Device Interrupt發生後去執行相對應的"程序" ，這個程序就稱為 Interrupt Service Routine(ISR)。如果沒有相對應的ISR則僅會回覆ACK而不作任何事。

傳統電腦是利用兩個Programmable Interrupt Controller (PIC)提供15組Interrupt Line連接Device和CPU。Device 觸發中斷請求(Interrupt Request)給PIC然後在傳至CPU，也因為數量有限所以很寶貴。現代的設計是使用Advanced Programmable Interrupt Controller(APIC)

在Linux Kernel 中存在一個資料結構叫irq_desc 實作在kernel/irq用來鍊結IRQ及ISR，另外也建立Radix treer叫irq_desc_tree來存放irq_desc結構的變數。

建立IRQ

要使用IRQ必須要向核心註冊。註冊的方式則是利用request_irq長相如下:
//include/linux/interrupt.h
/**
 *第一個參數是IRQ的號碼
 *第二個參數是ISR的pointer
 *第三個參數
 *    IRQF_SHARED         Interrupt is shared
 *    IRQF_SAMPLE_RANDOM  代表這個interrupt可以作為系統random的依據(有固定週期的interrupt
 *                        不適合當成random依據)
 *    IRQF_TRIGGER_*      Specify active edge(s) or level
 *第四個參數是顯示在例如/proc/interrupts的名稱
 *第五個參數用途可以參考http://www.cnblogs.com/ITmelody/archive/2012/05/12/2497018.html
 *一般直接填NULL
*/
request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,
     const char *name, void *dev)
{
    //request_threaded_irq第三個參數是irq_handler_t thread_fn
    return request_threaded_irq(irq, handler, NULL, flags, name, dev);
}
從這裡我們也可以發現其實request_irq()會直接call request_threaded_irq()。因此我們也會看到有人就直接使用request_threaded_irq()。直接舉nVidia的mmc的例子。
//driver/mmc/host/sdhci-tegra.c
static irqreturn_t carddetect_irq(int irq, void *data)
{
 ...
}

static int __devinit sdhci_tegra_probe(struct platform_device *pdev)
{
    struct sdhci_host *host;
    ...
    rc = request_threaded_irq(gpio_to_irq(plat->cd_gpio), NULL,
     carddetect_irq,
     IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
     mmc_hostname(host->mmc), host);
    ...
}
上述的例子是利用GPIO的變化來當成Interrupt的條件。IRQ number是利用gpio_to_irq取得對應的IRQ;ISR是carddetect_irq（），觸發的條件是當此GPIO rising/falling都會觸發Interrupt。

當我們remove module的時候，我們可能需要free掉這個IRQ，這個時候就可以呼叫free_irq來達成。
static int __devexit sdhci_tegra_remove(struct platform_device *pdev)
{
    ...
    if (gpio_is_valid(plat->cd_gpio)) {
        free_irq(gpio_to_irq(plat->cd_gpio), host);
        ...
    }
    ...
}

ISR Top and Bottom Halves

Interrupt設計的目的就是不希望卡在攏長的處理。因此，收到中斷後，我們也會希望可以快速處理完要作的事情。然而，常常我們需要作的事情就是這麼多無法快速的做完造成系統的遲鈍。因此，Linux Kernel提出了將ISR拆成top half 跟bottom half。當Interrupt發生後一定要馬上作的事情就屬於Top half直接寫在原本的ISR，而可以晚點做的就屬於Bottom half。我們可以利用SoftIRQ、Tasklet或Workqueu來排程bottom half的部份。下表比較了三種的差異。

下面我們分別介紹Tasklet及Workqueue。

Tasklet

Tasklets 與Linux Kernel的timer類似，他們都在Interrupt time（Atomic time）執行而且會執行在schedule他的CPU上。不同於timer，我們無法要求tasklet的task在我們期望的時間執行。同樣的，我們使用nVidia的mmc driver為例來說明Tasklet。
首先，我們必須先註冊一個tasklet，指定這個tasklet的名字、func及data。
//mmc/host/sdhci.c
static void sdhci_tasklet_card(unsigned long param)
{
   ...
}

int sdhci_add_host(struct sdhci_host *host){
   ...
/*
 * Init tasklet.
 *void tasklet_init(struct tasklet_struct *t,
 *                  void (*func)(unsigned long), unsigned long data)
 *簡單來說就是tasklet_init(name, func,data)
*/
    tasklet_init(&host->card_tasklet,
                 sdhci_tasklet_card, (unsigned long)host);
 
   ...
}
接著，這個task必須要在呼叫schedule_tasklet之後才會被排程執行。理所當然，我們會在top half執行完之後去啟動bottom half的部份。因此我們回到top half(carddetect_irq())看看我們如何去啟動bottom half。
//driver/mmc/host/sdhci-tegra.c
static irqreturn_t carddetect_irq(int irq, void *data)
{
    ...
    tasklet_schedule(&sdhost->card_tasklet);
    
    return IRQ_HANDLED;
};
Workqueue
Workqueue的部份則利用omap的mmc driver來舉例。如同tasklet，我們必須利用INIT_WORK(name,func)先註冊一個workqueue。以下面的範例，利用schedule_work()將這個workqueue交給一個叫"event"的公用work thread來執行。
首先我們來看註冊 workqueue的部份。
//driver/mmc/omap_hsmmc.c
static void omap_hsmmc_detect(struct work_struct *work)
{
   ...
}

static int __init omap_hsmmc_probe(struct platform_device *pdev)
{
   ...
   INIT_WORK(&host->mmc_carddetect_work, omap_hsmmc_detect);
   ...
}
而去啟動他的部份則是在top half的omap_hsmmc_cd_handler（）則是...
//driver/mmc/omap_hsmmc.c

static irqreturn_t omap_hsmmc_cd_handler(int irq, void *dev_id)
{
 struct omap_hsmmc_host *host = (struct omap_hsmmc_host *)dev_id;

 if (host->suspended)
  return IRQ_HANDLED;
 //啟動Workqueue 
 schedule_work(&host->mmc_carddetect_work);

 return IRQ_HANDLED;
}

Reference

Linux Kernel Development Third Edition
Linux Device Drivers, Third Edition
Intel APIC Architecture
Interrupt_request
Essential Linux Device Drivers

GPIO整理-GPIOLIB (二)

2012-07-04T15:00:00.002+08:00

上一篇介紹了GPIO的基礎，在這篇將詳細介紹 GPIOLIB

前言

在以前，假設我們chip上面都有提供GPIO。假設我們今天要 call soc上面的GPIO我們可以使用gpio_direction_output()。但是如果要使用audio chip上面的GPIO以下圖為例，我們可能就得呼叫audio_gpio_direction_output() depends on chip 的driver實作。

為什麼呢？因為每個chip如何去控制他們的GPIO作法可能會不一樣，並且要填的memory位址也不一樣。這麼一來會造成什麼現象呢？如果chip一多，要分別控制上面的GPIO 我們可能就會看到一堆 audio_gpio_direction_output、 pmu_gpio_direction_output、 charger_gpio_direction_output。而且，以gpio_direction_output為例，可能每一個driver的實作都會有一些重複的code例如檢查是否valid等等。

因此，GPIOLIB的引入可以解決這個問題。每一個chip都使用gpio_chip結構來表示，每一個chip driver實作可以定義GPIO的個數、號碼及相關的callback function。

以gpio_direction_output為例。當我們呼叫gpio_direction_output(number)之後，gpio_direction_output實做在GPIOLIB中，它會去檢查這個number的GPIO是屬於哪個chip然後去call 該chip的driver的request實作。

GPIOLIB分析

註冊gpio_chip

我們從nVidia的git抓下來的kernel裡面隨便找driver/gpio/wm8994-gpio.c為例子trace一下。他的probe如下:

static struct gpio_chip template_chip = {
 .label   = "wm8994",
 .owner   = THIS_MODULE,
/**
 *如果執行gpio_direction_input的GPIO number屬於這個chip
 *則執行wm8994_gpio_direction_in這個callback function
 *以下同義
*/
 .direction_input = wm8994_gpio_direction_in,
 .get   = wm8994_gpio_get,
 .direction_output = wm8994_gpio_direction_out,
 .set   = wm8994_gpio_set,
 .dbg_show  = wm8994_gpio_dbg_show,
 .can_sleep  = 1,
};

static int __devinit wm8994_gpio_probe(struct platform_device *pdev)
{
    struct wm8994 *wm8994 = dev_get_drvdata(pdev->dev.parent);
    //取得platform_device定義的platform_data
    struct wm8994_pdata *pdata = wm8994->dev->platform_data;
    struct wm8994_gpio *wm8994_gpio;
    int ret;
    wm8994_gpio = kzalloc(sizeof(*wm8994_gpio), GFP_KERNEL);
    if (wm8994_gpio == NULL)
 return -ENOMEM;
    
    wm8994_gpio->wm8994 = wm8994;
    /**
     *我們剛剛有說每一個chip使用gpio_chip結構表示。
     *上面宣告了template_chip的gpio_chip結構。
    */
    wm8994_gpio->gpio_chip = template_chip;
    wm8994_gpio->gpio_chip.ngpio = WM8994_GPIO_MAX;
    wm8994_gpio->gpio_chip.dev = &pdev->dev;

    //取得gpio_base。意思是這個chip的GPIO number從多少開始編號 
    if (pdata && pdata->gpio_base)
 wm8994_gpio->gpio_chip.base = pdata->gpio_base;
    else
 wm8994_gpio->gpio_chip.base = -1;
    
    //將這個gpio_chip 註冊進去。待會將分析gpiochip_add
    ret = gpiochip_add(&wm8994_gpio->gpio_chip);
    if (ret < 0) {
 dev_err(&pdev->dev, "Could not register gpiochip, %d\n",
         ret);
 goto err;
    }

    platform_set_drvdata(pdev, wm8994_gpio);
    return ret;

err:
 kfree(wm8994_gpio);
 return ret;
}

接著我們看一下gpiochip_add() 做了什麼事。

//擷取gpio_desc的定義。gpio_desc定義了GPIO是屬於哪個chip，他的flag及label。
struct gpio_desc {
 struct gpio_chip *chip;
 unsigned long  flags;
#ifdef CONFIG_DEBUG_FS
 const char  *label;
#endif
};
//gpio_desc陣列存放著所有gpio的定義
static struct gpio_desc gpio_desc[ARCH_NR_GPIOS];
int gpiochip_add(struct gpio_chip *chip)
{
 unsigned long flags;
 int  status = 0;
 unsigned id;
 int  base = chip->base;

 if ((!gpio_is_valid(base) || !gpio_is_valid(base + chip->ngpio - 1))
   && base >= 0) {
  status = -EINVAL;
  goto fail;
 }

 spin_lock_irqsave(&gpio_lock, flags);

 if (base < 0) {
  base = gpiochip_find_base(chip->ngpio);
  if (base < 0) {
   status = base;
   goto unlock;
  }
  chip->base = base;
 }

 /**
          *these GPIO numbers must not be managed by another gpio_chip 
          *換句話說就是沒有重複到其他gpio_chip定義的號碼
        */
 for (id = base; id < base + chip->ngpio; id++) {
  if (gpio_desc[id].chip != NULL) {
   status = -EBUSY;
   break;
  }
 }
 if (status == 0) {
     for (id = base; id < base + chip->ngpio; id++) {
         //將這個chip上的所有GPIO的定義加入gpio_desc
                gpio_desc[id].chip = chip;

  /* REVISIT:  most hardware initializes GPIOs as
   * inputs (often with pullups enabled) so power
   * usage is minimized.  Linux code should set the
   * gpio direction first thing; but until it does,
   * we may expose the wrong direction in sysfs.
   */
  gpio_desc[id].flags = !chip->direction_input
   ? (1 << FLAG_IS_OUT)
   : 0;
     }
 }

 of_gpiochip_add(chip);

unlock:
 spin_unlock_irqrestore(&gpio_lock, flags);

 if (status)
  goto fail;

 status = gpiochip_export(chip);
 if (status)
  goto fail;

 return 0;
fail:
 /* failures here can mean systems won't boot... */
 pr_err("gpiochip_add: gpios %d..%d (%s) failed to register\n",
  chip->base, chip->base + chip->ngpio - 1,
  chip->label ? : "generic");
 return status;
}
EXPORT_SYMBOL_GPL(gpiochip_add);

到這裡，我們的kernel已經多了wm8994這個chip的GPIO可以使用了。但是從我們呼叫gpio_direction_input是怎麼跑到driver定義的wm8994_gpio_direction_in呢？

GPIOLIB與CHIP DRIVER結合

我們看一下gpio_direction_input() 的code。

int gpio_direction_input(unsigned gpio)
{
 unsigned long  flags;
 struct gpio_chip *chip;
 struct gpio_desc *desc = &gpio_desc[gpio];
 int   status = -EINVAL;

 spin_lock_irqsave(&gpio_lock, flags);
        //先檢查這個gpio是否valid
 if (!gpio_is_valid(gpio))
  goto fail;
        //找到這個gpio屬於哪個chip的
 chip = desc->chip;
        //如果chip不存在或這個gpio不能設為input則return fail
 if (!chip || !chip->get || !chip->direction_input)
  goto fail;
        
        //下面兩行檢查該GPIO的編號是否在該chip的範圍內
 gpio -= chip->base;
 if (gpio >= chip->ngpio)
  goto fail;
 status = gpio_ensure_requested(desc, gpio);
 if (status < 0)
  goto fail;

 /* now we know the gpio is valid and chip won't vanish */

 spin_unlock_irqrestore(&gpio_lock, flags);

 might_sleep_if(chip->can_sleep);

 if (status) {
                //呼叫chip定義的request檢查是否可用
  status = chip->request(chip, gpio);
  if (status < 0) {
   pr_debug("GPIO-%d: chip request fail, %d\n",
    chip->base + gpio, status);
   /* and it's not available to anyone else ...
    * gpio_request() is the fully clean solution.
    */
   goto lose;
  }
 }
        //如果是可用的，call chip的direction_input（）
 status = chip->direction_input(chip, gpio);
 if (status == 0)
  clear_bit(FLAG_IS_OUT, &desc->flags);

 trace_gpio_direction(chip->base + gpio, 1, status);
lose:
 return status;
fail:
 spin_unlock_irqrestore(&gpio_lock, flags);
 if (status)
  pr_debug("%s: gpio-%d status %d\n",
   __func__, gpio, status);
 return status;
}
EXPORT_SYMBOL_GPL(gpio_direction_input);

至此，應該就都串起來了吧！簡單來說就如下圖:

Reference

http://www.kernel.org/doc/Documentation/gpio.txt

http://nv-tegra.nvidia.com/gitweb/

driver/gpio/gpiolib.c

driver/gpio/gpio-wm8994.c

Joe's Blog----TECH

新Blog

Docker on Ubuntu 14.04

Illegal instruction 追蹤

OpenStack High Availability I-MySQL, RabbitMQ HA

DRBD安裝

DRBD設定

#將設定檔從master copy到slave

#在master及slave 啟動DRBD

#初始化metadata storage

#將master設定為primary

#確認安裝狀態

DRBD問題排除

Reference

Corosync Installation

Corosync安裝

Corosync設定

#編輯/etc/corosync/corosync.conf

設定開機自動啟動

確認安裝狀態

Reference

Pacemaker Installation

驗證系統

基本設定

HA for MySQL

GlusterFS Performance Tuning

前言

Configurations

I/O

io-thread-count (16-> 64)

Cache

cache-size (32MB-> 2GB)

cache-max-file-size (-> 16384PB)

cache-min-file-size (-> 0)

Network

auto tuning(-> disable)

Performance Testing

Experiment Environment and Method

Experiment Configuration

Experiment Result

Write

ReWrite

Read

Re-read

Conclusion

Delete Symantec Netbackup Disk Pool

No Dropbox icon in Ubuntu 13.10

Linux Kernel Performance Tuning and Hardening

Setup git server

Git Server

1. 安裝必要套件

2. 建立repository

Git Client

iSCSI Target and Initiator

iSCSI Target

1. 選擇要提供空間的裝置

提供服務的空間可以是一個硬碟、一個partition、一個LVM的LV或是使用DD產生一個空間。 使用以下的方法可以在/media下產生一個20G名稱為volume0的空間。 # dd if=/dev/zero of=/media/volume0 count=0 obs=1 seek=20G

2. 安裝必要套件

3. 設定iSCSI

4. 重新啟動iSCSI Target

iSCSI Initiator

1. 安裝必要套件

2. 搜尋可用iSCSI Lun

3. 連接裝置

4. 掛載裝置

大資料資料庫儲存-NoSQL比較及效能差異(VII)

NoSQL 比較

Experiment Environment

Hardware and Network Topology

Software Version

MySQL VS Big Data

Insert Data

Update Data

Look-up Data

Delete Data

大資料資料庫儲存-Memcache和Redis介紹(VI)

Memcahce

Memcache Use Scenario

REDIS

REDIS Data Type

提供服務的空間可以是一個硬碟、一個partition、一個LVM的LV或是使用DD產生一個空間。
使用以下的方法可以在/media下產生一個20G名稱為volume0的空間。

# dd if=/dev/zero of=/media/volume0 count=0 obs=1 seek=20G

Linux Interrupt 整理（一）