BlogJava-so true-随笔分类-Linux

http_server supports download/upload

so true — Sat, 20 Nov 2021 13:03:00 GMT

#!/usr/env python3
import http.server
import socketserver
import io
import cgi

#  Download a file from your attack device:
#curl -O http://:8000/

#  Upload a file back to your attack device:
#curl -F 'file=@' http://:8000/

#  Multiple file upload supported, just add more -F 'file=@'
#  parameters to the command line.
#curl -F 'file=@' -F 'file=@' http://:8000/

# Change this to serve on a different port
PORT = 8000

class CustomHTTPRequestHandler(http.server.SimpleHTTPRequestHandler):

    def do_POST(self):
        r, info = self.deal_post_data()
        print(r, info, "by: ", self.client_address)
        f = io.BytesIO()
        if r:
            f.write(b"Success\n")
        else:
            f.write(b"Failed\n")
        length = f.tell()
        f.seek(0)
        self.send_response(200)
        self.send_header("Content-type", "text/plain")
        self.send_header("Content-Length", str(length))
        self.end_headers()
        if f:
            self.copyfile(f, self.wfile)
            f.close()

    def deal_post_data(self):
        ctype, pdict = cgi.parse_header(self.headers['Content-Type'])
        pdict['boundary'] = bytes(pdict['boundary'], "utf-8")
        pdict['CONTENT-LENGTH'] = int(self.headers['Content-Length'])
        if ctype == 'multipart/form-data':
            form = cgi.FieldStorage( fp=self.rfile, headers=self.headers, environ={'REQUEST_METHOD':'POST', 'CONTENT_TYPE':self.headers['Content-Type'], })
            print (type(form))
            try:
                if isinstance(form["file"], list):
                    for record in form["file"]:
                        open("./%s"%record.filename, "wb").write(record.file.read())
                else:
                    open("./%s"%form["file"].filename, "wb").write(form["file"].file.read())
            except IOError:
                    return (False, "Can't create file to write, do you have permission to write?")
        return (True, "Files uploaded")

Handler = CustomHTTPRequestHandler
try:
    server = socketserver.TCPServer(("", PORT), Handler)
    # Activate the server; this will keep running until you
    # interrupt the program with Ctrl-C
    server.serve_forever()
except:
    pass
finally:
    server.close()

so true 2021-11-20 21:03 发表评论

Dell G3 Win10 SDD+HDD硬盘EFI引导不用U盘安装Ubuntu

so true — Mon, 19 Aug 2019 02:26:00 GMT

1. Win10关闭快速启动；

2. Win10关闭BitLocker；

3. Win10下压缩磁盘，留出一块未分配的区域X用于安装ubuntu，再搞出一个3GB的FAT32分区，把下载好的iso镜像释放到里面；

4. BIOS关闭Secure Boot；

5. BIOS关闭SATA的RAID，设置为AHCI；

6. 启动时F12，选择那个3GB的FAT32启动（默认会自动探测到，否则在BOOT SEQUENCE里手动增加一下）；

7. 选择try Ubuntu进去进行安装；

8. 安装前先sudo umount -l /dev/xxx, xxx是光盘镜像文件所在的盘，以避免安装过程卡在detecting file systems阶段不动；

9. 安装类型选择其他选项；

10. 在预留空间X上分50GB给/，分X-80给/home，分30给swap；

11. 安装启动引导器的设备，选择Windows Boot Manager所在的分区（分区类型是EFI）；

12. 如果出现"The 'grub-efi-amd64-signed' package failed to install into /target/."之类的错误，是因为缺包，重新安装，勾选开启网络并允许下载包的选项进行安装即可；

参考文章：

https://blog.csdn.net/github_37603222/article/details/70833565

so true 2019-08-19 10:26 发表评论

c++14 transducer

so true — Thu, 09 May 2019 10:53:00 GMT

摘要: Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/--> 1 /* 2 * transducer.cpp 3 * 4&... 阅读全文

so true 2019-05-09 18:53 发表评论

read-write lock

so true — Mon, 14 May 2018 04:07:00 GMT

（一）当前被读锁占着
    1。如果读优先(默认是PTHREAD_RWLOCK_PREFER_READER_NP，即读优先)，那么等着的读请求可以快速拿到锁，写一直被饿着（直到没有任何等待获取读锁的情况下，写才能拿到写锁）；
    2。如果写优先，那么读和写都等着，一但前面的读释放了锁，写立刻就会优先读来拿到锁；
（二）当前被写锁占着
    不论谁优先，都需要把所有等着的写都服务完，才会给读机会，所以写多读少的情况下，就应该用互斥锁了；

测试程序：
#include

#include

using namespace std;

long g_idx = 0;

class ThreadRwLock {

private:

pthread_rwlock_t m_rw_mutex;

public:

ThreadRwLock() {

pthread_rwlockattr_t attr;

// 设置写优先

pthread_rwlockattr_init(&attr);

//pthread_rwlockattr_setkind_np(&attr, PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP);

pthread_rwlock_init(&m_rw_mutex, &attr);

}

~ThreadRwLock() {

pthread_rwlock_destroy(&m_rw_mutex);

}

void rdlock() {

pthread_rwlock_rdlock(&m_rw_mutex);

}

void wrlock() {

pthread_rwlock_wrlock(&m_rw_mutex);

}

int tryrdlock() {

return pthread_rwlock_tryrdlock(&m_rw_mutex);

}

int trywrlock() {

return pthread_rwlock_trywrlock(&m_rw_mutex);

}

void unlock() {

pthread_rwlock_unlock(&m_rw_mutex);

}

};

ThreadRwLock g_lock;

void* thread_routine(void* arg) {

long is_write = (long)arg;

if (is_write) {

printf("%lu wait write lock\n", pthread_self()); fflush(stdout);

g_lock.wrlock();

long idx = __sync_add_and_fetch(&g_idx, 1);

printf("%lu get write lock, %ld\n", pthread_self(), idx); fflush(stdout);

sleep(5);

g_lock.unlock();

} else {

printf("%lu wait read lock\n", pthread_self()); fflush(stdout);

g_lock.rdlock();

long idx = __sync_add_and_fetch(&g_idx, 1);

printf("%lu get read lock, %ld\n", pthread_self(), idx); fflush(stdout);

sleep(5);

g_lock.unlock();

}

return NULL;

}

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

pthread_t tid = 0;

pthread_create(&tid, NULL, thread_routine, (void*)0);

pthread_create(&tid, NULL, thread_routine, (void*)1);

getchar(); //让程序暂停，等待键盘敲入一个字节后，接着走

pthread_create(&tid, NULL, thread_routine, (void*)1);

sleep(2); //确保写锁被优先拿到

pthread_create(&tid, NULL, thread_routine, (void*)0);

pthread_create(&tid, NULL, thread_routine, (void*)1);

pthread_create(&tid, NULL, thread_routine, (void*)0);

pthread_create(&tid, NULL, thread_routine, (void*)1);

pthread_create(&tid, NULL, thread_routine, (void*)0);

getchar();

return 0;

}

so true 2018-05-14 12:07 发表评论

daemonize

so true — Thu, 12 Apr 2018 10:36:00 GMT

#include

void daemonize() {

int pid = -1, fd = -1;

// 1.转变为后台进程

if ((pid = fork()) == -1) exit(1);

if (pid != 0) exit(0); // 父进程（前台进程）退出

// 2.离开原先的进程组，会话

if (setsid() == -1) exit(1); // 开启一个新会话

// 3.禁止再次打开控制终端

if ((pid = fork()) == -1) exit(1);

if (pid != 0) exit(0); // 父进程（会话领头进程）退出

// 4.关闭打开的文件描述符，避免浪费系统资源

for (int i = 0; i < NOFILE; i++)

close(i);

// 5.改变当前的工作目录，避免卸载不了文件系统

if (chdir("/") == -1) exit(1);

// 6.重设文件掩码，防止某些属性被父进程屏蔽，也有设置为0027的（守护进程创建的临时文件不希望被其他用户查看）

umask(0);

// 7.重定向标准输入，输出，错误流，因为守护进程没有控制终端

// 如果只是把0、1、2都close了，那么守护进程里新创建的文件fd会用到0、1、2，如果用户的代码里有用到printf/cout之类的，那就会把数据打到新创建的文件中，这样就会产生混淆

if ((fd = open("/dev/null", O_RDWR)) == -1) exit(1); // 打开一个指向/dev/null的文件描述符

dup2(fd, STDIN_FILENO);

dup2(fd, STDOUT_FILENO);

dup2(fd, STDERR_FILENO);

close(fd);

// 8.本守护进程的子进程若不需要返回信息，那么交给init进程回收，避免产生僵尸进程，否则子进程退出后将成为僵尸进程

if (signal(SIGCHLD, SIG_IGN) == SIG_ERR) exit(1);

}

对setsid阐述较透彻：http://www.cnblogs.com/xuxm2007/archive/2011/07/29/2121280.html

对终端的事说了些：http://blog.51cto.com/10541559/1771212

对syslog的事说了些：https://www.linuxidc.com/Linux/2015-01/111933.htm

此外，man 3 daemon这个库函数只实现了部分阶段（例如没有屏蔽SIGCHLD以及对mask做任何处理）：https://github.com/lattera/glibc/blob/master/misc/daemon.c

so true 2018-04-12 18:36 发表评论

sudoku

so true — Fri, 03 Nov 2017 09:19:00 GMT

1 #include
  2 #include
  3 #include <string.h>
  4 #include
  5 #include
  6 #include <string>
  7 #include <set>
  8
  9 class Sudoku {
10 public:
11     Sudoku(const std::string& question, bool does_try_all_answers = false): m_does_try_all_answers(does_try_all_answers), m_data(9) {
12         for (int i = 0; i < 9; ++i) {
13             m_data[i].resize(9);
14             for (int j = 0; j < 9; ++j) {
15                 m_data[i][j] = question[i * 9 + j];
16             }
17         }
18     }
19
20     bool Solve() {
21         return Fill(0, 0);
22     }
23
24     const std::string GiveOneAnswer() const {
25         return m_all_answers.empty() ? "" : *m_all_answers.begin();
26     }
27
28     const std::setstring> GiveAllAnswers() const {
29         return m_all_answers;
30     }
31
32     static const std::string ProvideOneQuestionRandomly(int min_filled_num = 30) {
33         std::vectorchar> > ques(9, std::vector<char>(9, '.'));
34
35         struct timeval cur_tv;
36         gettimeofday(&cur_tv, NULL);
37         srand(cur_tv.tv_usec);
38
39         int valid_digit_num = 0;
40         for (int i = 0; i < 9; ++i) {
41             for (int j = 0; j < 9; ++j) {
42                 if (rand() % 81 <= min_filled_num + valid_digit_num / 6) {
43                     char c = rand() % 9 + '1';
44
45                     if (DoesConflict(ques, i, j, c)) {
46                         int k = 0;
47                         for (; k < 8; ++k) {
48                             if (c == '9') {
49                                 c = '1';
50                             }
51                             if (!DoesConflict(ques, i, j, ++c)) {
52                                 break;
53                             }
54                         }
55                         if (8 == k) {
56                             c = '.';
57                         }
58                     }
59
60                     valid_digit_num += ('.' != c);
61                     ques[i][j] = c;
62                 } else {
63                     ques[i][j] = '.';
64                 }
65             }
66         }
67
68         char buf[82];
69         buf[81] = '\0';
70         for (int i = 0; i < 9; ++i) {
71             for (int j = 0; j < 9; ++j) {
72                 buf[i * 9 + j] = ques[i][j];
73             }
74         }
75
76         Sudoku sudoku(buf);
77         sudoku.Solve();
78         if (81 == sudoku.GiveOneAnswer().size()) {
79             return buf;
80         } else {
81             return ProvideOneQuestionRandomly(min_filled_num);
82         }
83
84         return buf;
85     }
86
87     static void PrintSudoku(const std::string& sudoku) {
88         if (sudoku.size() < 81) {
89             return;
90         }
91
92         for (int i = 0; i < 9; ++i) {
93             for (int j = 0; j < 9; ++j) {
94                 if (0 != j) {
95                     std::cout << " ";
96                 }
97                 std::cout << sudoku[i * 9 + j];
98             }
99             std::cout << std::endl;
100         }
101     }
102
103     static bool ValidateOneAnswer(const std::string& answer) {
104         if (answer.size() != 81) {
105             return false;
106         }
107
108         for (int i = 0; i < 9; ++i) {
109             char hit_h[9] = { '\0' };
110             char hit_v[9] = { '\0' };
111             for (int j = 0; j < 9; ++j) {
112                 if ('.' == answer[i * 9 + j] || ++hit_h[answer[i * 9 + j] - '1'] != 1) { //row check
113                     return false;
114                 } else if ('.' == answer[j * 9 + i] || ++hit_v[answer[j * 9 + i] - '1'] != 1) { //column check
115                     return false;
116                 }
117                 if (0 == i % 3 && 0 == j % 3) { //3x3 square check
118                     char hit_m[9] = { '\0' };
119                     for (int i2 = i; i2 < i + 3; ++i2) {
120                         for (int j2 = j; j2 < j + 3; ++j2) {
121                             if ('.' == answer[i2 * 9 + j2] || ++hit_m[answer[i2 * 9 + j2] - '1'] != 1) {
122                                 return false;
123                             }
124                         }
125                     }
126                 }
127             }
128         }
129         return true;
130     }
131
132 private:
133     void AddOneAnswer() {
134         char buf[82];
135         buf[81] = '\0';
136
137         for (int i = 0; i < 9; ++i) {
138             for (int j = 0; j < 9; ++j) {
139                 buf[i * 9 + j] = m_data[i][j];
140             }
141         }
142
143         m_all_answers.insert(buf);
144     }
145
146     static bool DoesConflict(const std::vectorchar> >& data, int i, int j, char digit) {
147         for (int k = 0; k < 9; ++k) {
148             if (digit == data[i][k]) {
149                 return true;
150             }
151             if (digit == data[k][j]) {
152                 return true;
153             }
154         }
155
156         int i0 = i - i % 3;
157         int j0 = j - j % 3;
158         for (int i2 = i0; i2 < i0 + 3; ++i2) {
159             for (int j2 = j0; j2 < j0 + 3; ++j2) {
160                 if (digit == data[i2][j2]) {
161                     return true;
162                 }
163             }
164         }
165
166         return false;
167     }
168
169     bool Fill(int i, int j) {
170         for (; i < 9; ++i, j = 0) {
171             for (; j < 9; ++j) {
172                 if ('.' == m_data[i][j]) {
173                     for (int k = '1'; k <= '9'; ++k) {
174                         if (DoesConflict(m_data, i, j, k)) {
175                             continue;
176                         }
177
178                         m_data[i][j] = k;
179                         if (8 == j) {
180                             if (Fill(i + 1, 0)) {
181                                 AddOneAnswer();
182                                 if (!m_does_try_all_answers) {
183                                     return true;
184                                 }
185                             }
186                         } else {
187                             if (Fill(i, j + 1)) {
188                                 AddOneAnswer();
189                                 if (!m_does_try_all_answers) {
190                                     return true;
191                                 }
192                             }
193                         }
194                     }
195                     m_data[i][j] = '.';
196                     return false;
197                 }
198             }
199         }
200
201         AddOneAnswer();
202         return true;
203     }
204
205 private:
206     bool m_does_try_all_answers;
207     std::vectorchar> > m_data;
208     std::setstring> m_all_answers;
209 };
210
211 int main(int argc, char* argv[]) {
212     std::string question;
213     //with many answers
214     question = ".2..4836..5163887..63195..45.4.7.2.98..";
215
216     //with just one answer: https://baike.baidu.com/item/%E4%B8%96%E7%95%8C%E6%9C%80%E9%9A%BE%E6%95%B0%E7%8B%AC/13848819
217     question = "..53..82..7..1.5..4.531..76..328..6.5.9..4.397..";
218
219     bool find_all_answers = false;
220     if (argc > 1 && 81 == strlen(argv[1])) {
221         question = argv[1];
222     } else {
223         if (argc > 1) {
224             find_all_answers = true;
225         }
226         question = Sudoku::ProvideOneQuestionRandomly();
227     }
228
229     Sudoku::PrintSudoku(question);
230
231     Sudoku sudoku(question, find_all_answers);
232     sudoku.Solve();
233
234     const std::setstring>& all_answers = sudoku.GiveAllAnswers();
235     int idx = 0;
236     for (typeof(all_answers.begin()) iter = all_answers.begin(); all_answers.end() != iter; ++iter) {
237         std::cout << "answer " << ++idx << " for this sudoku is:" << std::endl;
238         Sudoku::PrintSudoku(*iter);
239         if (!Sudoku::ValidateOneAnswer(*iter)) {
240             std::cout << "answer is not correct: " << *iter << std::endl;
241         }
242         std::cout << "[" << *iter << "]" << std::endl;
243     }
244     return 0;
245 }
246

so true 2017-11-03 17:19 发表评论

bash实现线程池

so true — Tue, 25 Jul 2017 12:19:00 GMT

摘要: #!/bin/bashTHREAD_NUM=5tfile=$(mktemp /tmp/.foo.XXXXXXXX)rm -f $tfilemkfifo $tfileexec 9<>$tfilefor ((i=0;i<$THREAD_NUM;i++)); do echo 1>&9donewhile read line; do read -u 9... 阅读全文

so true 2017-07-25 20:19 发表评论

watchdog_pid.sh

so true — Thu, 06 Apr 2017 08:00:00 GMT

#!/bin/bash

#ulimit -c unlimited

export PS4='+{$LINENO($(date +"%F %T")):${FUNCNAME[0]}} '

full_path=$(readlink -f $0)

#cd $(dirname $full_path)

#exec 1>${full_path%.*}.log

exec 2>${full_path%.*}.err

set -x

usage() {

printf \

"Usage: %s \n\n \

pid|pid_file process pid or the pid file containing the pid of process to be supervised\n \

start_cmd|start_script start commands or start script if process dead\n \

\n" $1

exit 1

}

if [ $# -lt 2 ]; then

usage $0

pid_way=$1

if [ "" != "${pid_way//[0-9]}" -a -s "$pid_way" ]; then

pid_file=$(readlink -f $pid_way)

else

pid_id=$pid_way

pinfo=($(ps -eo uid,pid,args | awk -v pid=$pid_id '{if($2==pid)print $0}'))

puid=${pinfo[0]}

pname=${pinfo[2]}

if [ "" == "$puid" -o "" == "$pname" ]; then

echo "Couldn't find the process with the pid $pid_id"

exit 2

cmd=($2)

if [ -s "${cmd[0]}" ]; then

start_way=$(readlink -f ${cmd[0]})

for ((i=1; i<${#cmd[@]}; ++i)); do

start_way="$start_way ""${cmd[$i]}"

done

shift 2

start_way="$start_way ""$@"

else

shift 1

start_way="$@"

while true; do

if [ "" != "$pid_id" ]; then

pid=$pid_id

else

pid=$(cat $pid_file)

if [ "" != "$pid" ]; then

if ! kill -0 $pid; then

now=$(date +%s)

$start_way

#sleep 60

if [ "" != "$pid_id" ]; then

tm_fields_num=$(ps -eo lstart | tail -1 | awk '{print NF}')

find_new_process=0

pid_id_bak=()

while read line; do

pstarttime=$(date -d "${line#* }" +%s)

if [ "$pstarttime" -ge "$now" ]; then

pid_id_tmp=${line%% *}

pinfo_new=($(ps -eo uid,pid,args | awk -v pid=$pid_id_tmp '{if($2==pid)print $0}'))

if [ "0" == "${#pinfo_new[@]}" ]; then

continue

diff_fields_num=0

for ((i=3; i<(${#pinfo[@]} > ${#pinfo_new[@]} ? ${#pinfo[@]} : ${#pinfo_new[@]}); ++i)); do

if [ "${pinfo[$i]}" != "${pinfo_new[$i]}" ]; then

((++diff_fields_num))

done

if [ "0" -eq "$diff_fields_num" ]; then

pid_id=$pid_id_tmp

if [ "$((++find_new_process))" -gt "1" ]; then

exit 1

else

pid_id_bak[$diff_fields_num]=$pid_id_tmp

done < <(ps -eo uid,pid,lstart,args | awk -v puid=$puid -v pname=$pname -v tfn=$tm_fields_num '{if($1==puid && $(3+tfn)==pname){printf "%d ", $2; for(i=3;i<3+tfn;++i) printf "%s ", $i; printf "\n";}}')

if [ "0" == "$find_new_process" ]; then

pid_id=${pid_id_bak[@]}

pid_id=${pid_id%% *}

else

tm_new_pid_file=$(date -d "$(stat $pid_file | grep ^Modify: | sed 's#Modify:##')" +%s)

if [ "$tm_new_pid_file" -lt "$now" ]; then

exit 2

#sleep 1

if [ "$(ls -l ${full_path%.*}.err | awk '{print $5}')" -ge $((1024 * 1024 * 1024)) ]; then

set +x

exec 2>/dev/null

cp ${full_path%.*}.err ${full_path%.*}.err.last

rm -f ${full_path%.*}.err

exec 2>${full_path%.*}.err

set -x

done

so true 2017-04-06 16:00 发表评论

epoll example for test later

so true — Wed, 22 Jun 2016 09:23:00 GMT

curl https://banu.com/blog/2/how-to-use-epoll-a-complete-example-in-c/epoll-example.c

#include

#define MAXEVENTS 64

static int make_socket_non_blocking(int sfd) {

int flags, s;

flags = fcntl(sfd, F_GETFL, 0);

if (flags == -1) {

perror("fcntl");

return -1;

}

flags |= O_NONBLOCK;

s = fcntl(sfd, F_SETFL, flags);

if (s == -1) {

perror("fcntl");

return -1;

}

return 0;

}

static int create_and_bind(char *port) {

struct addrinfo hints;

struct addrinfo *result, *rp;

int s, sfd;

memset(&hints, 0, sizeof(struct addrinfo));

hints.ai_family = AF_UNSPEC; /* Return IPv4 and IPv6 choices */

hints.ai_socktype = SOCK_STREAM; /* We want a TCP socket */

hints.ai_flags = AI_PASSIVE; /* All interfaces */

s = getaddrinfo(NULL, port, &hints, &result);

if (s != 0) {

fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(s));

return -1;

}

for (rp = result; rp != NULL; rp = rp->ai_next) {

sfd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);

if (sfd == -1)

continue;

s = bind(sfd, rp->ai_addr, rp->ai_addrlen);

if (s == 0) {

/* We managed to bind successfully! */

break;

}

close(sfd);

}

if (rp == NULL) {

fprintf(stderr, "Could not bind\n");

return -1;

}

freeaddrinfo(result);

return sfd;

}

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

int sfd, s;

int efd;

struct epoll_event event;

struct epoll_event *events;

if (argc != 2) {

fprintf(stderr, "Usage: %s [port]\n", argv[0]);

exit(EXIT_FAILURE);

}

sfd = create_and_bind(argv[1]);

if (sfd == -1)

abort();

s = make_socket_non_blocking(sfd);

if (s == -1)

abort();

s = listen(sfd, SOMAXCONN);

if (s == -1) {

perror("listen");

abort();

}

efd = epoll_create1(0);

if (efd == -1) {

perror("epoll_create");

abort();

}

event.data.fd = sfd;

event.events = EPOLLIN | EPOLLET;

s = epoll_ctl(efd, EPOLL_CTL_ADD, sfd, &event);

if (s == -1) {

perror("epoll_ctl");

abort();

}

/* Buffer where events are returned */

events = calloc(MAXEVENTS, sizeof event);

/* The event loop */

while (1) {

int n, i;

n = epoll_wait(efd, events, MAXEVENTS, -1);

for (i = 0; i < n; i++) {

if ((events[i].events & EPOLLERR) || (events[i].events & EPOLLHUP) || (!(events[i].events & EPOLLIN))) {

/* An error has occured on this fd, or the socket is not

ready for reading (why were we notified then?) */

fprintf(stderr, "epoll error\n");

close(events[i].data.fd);

continue;

}

else if (sfd == events[i].data.fd) {

/* We have a notification on the listening socket, which

means one or more incoming connections. */

while (1) {

struct sockaddr in_addr;

socklen_t in_len;

int infd;

char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV];

in_len = sizeof in_addr;

infd = accept(sfd, &in_addr, &in_len);

if (infd == -1) {

if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) {

/* We have processed all incoming

connections. */

break;

} else {

perror("accept");

break;

}

s = getnameinfo(&in_addr, in_len, hbuf, sizeof hbuf, sbuf, sizeof sbuf, NI_NUMERICHOST | NI_NUMERICSERV);

if (s == 0) {

printf("Accepted connection on descriptor %d "

"(host=%s, port=%s)\n", infd, hbuf, sbuf);

}

/* Make the incoming socket non-blocking and add it to the

list of fds to monitor. */

s = make_socket_non_blocking(infd);

if (s == -1)

abort();

event.data.fd = infd;

event.events = EPOLLIN | EPOLLET;

s = epoll_ctl(efd, EPOLL_CTL_ADD, infd, &event);

if (s == -1) {

perror("epoll_ctl");

abort();

}

continue;

} else {

/* We have data on the fd waiting to be read. Read and

display it. We must read whatever data is available

completely, as we are running in edge-triggered mode

and won't get a notification again for the same

data. */

int done = 0;

while (1) {

ssize_t count;

char buf[512];

count = read(events[i].data.fd, buf, sizeof buf);

if (count == -1) {

/* If errno == EAGAIN, that means we have read all

data. So go back to the main loop. */

if (errno != EAGAIN) {

perror("read");

done = 1;

}

break;

} else if (count == 0) {

/* End of file. The remote has closed the

connection. */

done = 1;

break;

}

/* Write the buffer to standard output */

s = write(1, buf, count);

if (s == -1) {

perror("write");

abort();

}

if (done) {

printf("Closed connection on descriptor %d\n", events[i].data.fd);

/* Closing the descriptor will make epoll remove it

from the set of descriptors which are monitored. */

close(events[i].data.fd);

}

free(events);

close(sfd);

return EXIT_SUCCESS;

}

so true 2016-06-22 17:23 发表评论

how to determine the established time of one socket

so true — Wed, 15 Jun 2016 03:59:00 GMT

You can try the following:

1. get the PID (say $pid) of the program by adding the -p option to netstat.

2. identify the proper line in the /proc/net/tcp file by looking at the local_address and/or rem_address fields (note that they are in hex format, specifically the IP address is expressed in little-endian byte order), also make sure that the st is 01 (for ESTABLISHED);

3. note the associated inode field (say $inode);

4. search for that inode among the file descriptors in /proc/$pid/fd and finally query the file access time of the symbolic link: find /proc/$pid/fd -lname "socket:\[$inode\]" -printf %t

function suptime() {

local addr=${1:?Specify the remote IPv4 address}

local port=${2:?Specify the remote port number}

# convert the provided address to hex format

local hex_addr=$(python -c "import socket, struct; print(hex(struct.unpack('

local hex_port=$(python -c "print(hex($port)[2:].upper().zfill(4))")

# get the PID of the owner process

local pid=$(netstat -ntp 2>/dev/null | awk '$6 == "ESTABLISHED" && $5 == "'$addr:$port'"{sub("/.*", "", $7); print $7}')

[ -z "$pid" ] && { echo 'Address does not match' 2>&1; return 1; }

# get the inode of the socket

local inode=$(awk '$4 == "01" && $3 == "'$hex_addr:$hex_port'" {print $10}' /proc/net/tcp)

[ -z "$inode" ] && { echo 'Cannot lookup the socket' 2>&1; return 1; }

# query the inode status change time

local timestamp=$(find /proc/$pid/fd -lname "socket:\[$inode\]" -printf %T@)

[ -z "$timestamp" ] && { echo 'Cannot fetch the timestamp' 2>&1; return 1; }

# compute the time difference

LANG=C printf '%s (%.2fs ago)\n' "$(date -d @$timestamp)" $(bc <<<"$(date +%s.%N) - $timestamp")

}

#the function used to convert ip between hex and decimal style

ip_cvt() {

local addr=${1:?Please specify or as the args}

if [ $# -eq 2 ]; then

addr=$1:$2

local ip=${addr%%:*}

local port=${addr##*:}

if [ "$ip" == "${ip##*.}" ]; then

echo $(python -c "import socket, struct; print(socket.inet_ntoa(struct.pack('

else

echo $(python -c "import socket, struct; print(hex(struct.unpack('

}

$ head /proc/net/tcp

sl local_address rem_address st tx_queue rx_queue tr tm->when retrnsmt uid timeout inode
the meaning of st field is:

0 /* (Invalid) */ TCP_CLOSE,

1 /* TCP_ESTABLISHED */ TCP_FIN_WAIT1 | TCP_ACTION_FIN,

2 /* TCP_SYN_SENT */ TCP_CLOSE,

3 /* TCP_SYN_RECV */ TCP_FIN_WAIT1 | TCP_ACTION_FIN,

4 /* TCP_FIN_WAIT1 */ TCP_FIN_WAIT1,

5 /* TCP_FIN_WAIT2 */ TCP_FIN_WAIT2,

6 /* TCP_TIME_WAIT */ TCP_CLOSE,

7 /* TCP_CLOSE */ TCP_CLOSE,

8 /* TCP_CLOSE_WAIT */ TCP_LAST_ACK | TCP_ACTION_FIN,

9 /* TCP_LAST_ACK */ TCP_LAST_ACK,

A /* TCP_LISTEN */ TCP_CLOSE,

B /* TCP_CLOSING */ TCP_CLOSING,

so true 2016-06-15 11:59 发表评论

http代理的那些事

so true — Wed, 08 Jun 2016 08:31:00 GMT

正向、反向都是A要访问一些只有C才能访问到的东西，中间通过C来中介；

1。区别：

正向：A告诉C，我要明确访问B，C把B上的资源拽回来，返回给A；对B而言，访问我的是C，压根不知道A的存在；在A看来，我需要显示的配置代理服务器C，要明确告诉C我要访问的资源是B；

反向：A告诉C，我要请求一些资源，C知道资源在B上，从B上把资源拽回来返回给A；对B而言，直接访问我的是C但同时也知道真正的资源请求者是A；在A看来，压根不知道B的存在，一直以为资源就是在C上；

总结：正向非常简单理解，就是委托C帮我访问，出了事也都是C兜着，C这里仅仅是一个傻傻的替人干活和顶雷的工具，说白了就是A在本地wget拽B的资源不行，但在C上wget是可以拽下来B的资源的（当然这里C也得是一个server进程，因为要侦听端口等待A来访问，还要返回结果给A）；干反向代理的C不再是那么简单的一个工具了，而是一个真正意义上的service，可以综合考虑A的需求和B的服务能力来做智能转发，因此会具有负载均衡的能力（当然这里也可以使用最简化版的C，即：C也只是一股脑的单纯的把请求转发给B，在这种意义上，貌似感觉反向干的还是正向干的事，实则不然，关键在于B，对于正向而言B是一个特定的资源，例如B可以是https://www.zhihu.com/question/19761434，也可以是http://blog.csdn.net/physicsdandan/article/details/45667357；对于反向而言，B只能是一个或几个特定的服务地址，例如http://10.138.20.241:8834/，请求都是转给这一个或这几个特定服务地址的，当然这个特定服务地址也有可能又是proxy）

2。典型应用场景：

正向：翻到墙外去看片；

反向：把内网的资源暴露给外部访问；

3。能做代理的软件：

a. nginx：正反都可以，但不支持https；

b. 正向代理支持https的：http://www.oki-osk.jp/esc/python/proxy/TinyHTTPProxy-0.2.1.zip就一个python文件，最简单易用，已经测试过svn可以用它（配置下~/.subversion/servers里的[global]下的http-proxy-host和http-proxy-port就可以了），更多的参见https://www.zhihu.com/question/19871146；

4。一句话总结：

都是把http请求进行转发，调整几个header字段而已；反向代理主要干内网暴露和负载均衡这两件事；

最后附上nginx正反向代理的配置模板：

正向代理：

server {

resolver 8.8.8.8;

resolver_timeout 5s;

listen 8081;

location / {

proxy_pass $scheme://$http_host$request_uri;

proxy_set_header Host $http_host;

proxy_buffers 256 8k;

proxy_max_temp_file_size 0;

proxy_connect_timeout 30;

proxy_cache_valid 200 302 10m;

proxy_cache_valid 301 1h;

proxy_cache_valid any 1m;

}

反向代理：

upstream apachephp {

server ip:8080;

}

server {

listen 80;

server_name www.myblog.cn;

access_log logs/quancha.access.log main;

error_log logs/quancha.error.log;

root html;

index index.html index.htm index.php;

## send request back to apache ##

location / {

proxy_pass http://apachephp;

#Proxy Settings

proxy_redirect off;
proxy_set_header Host $host:$server_port;

proxy_set_header X-Real-IP $remote_addr;
proxy_set_header REMOTE-HOST $remote_addr;

proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

proxy_next_upstream error timeout invalid_header http_500 http_502 http_503 http_504;

proxy_max_temp_file_size 0;

proxy_connect_timeout 90;

proxy_send_timeout 90;

proxy_read_timeout 90;

proxy_buffer_size 4k;

proxy_buffers 4 32k;

proxy_busy_buffers_size 64k;

proxy_temp_file_write_size 64k;

}

so true 2016-06-08 16:31 发表评论

bash redirect re-study

so true — Wed, 30 Mar 2016 04:10:00 GMT

本质:先理解linux里的int dup2(int oldfd, int newfd)命令，dup2() makes newfd be the copy of oldfd。

理解:重定向这个概念其实不是很好理解，如果用编程里面的指针来说明，那就很容易了。举个例子，比如指针p1指向瓶子，指针p2指向抽屉，现在执行p1>&p2（相当于p1 = p2)，这样p1这个指针也指向抽屉了，也就是说我们把p1这个指针重定向到一个新的地方，这个地方是p2所指的地方，即抽屉；

简而言之，这个例子里重定向的含义是：把p1指向p2所指的地方（重定向就是指向的含义），而瓶子、抽屉这2个“实体”是不变的，重定向能调整的只是指针的指向。

$ ls -l /proc/$$/fd

lr-x------ 1 admin admin 64 2016-03-30 10:14 0 -> /dev/pts/413

lrwx------ 1 admin admin 64 2016-03-30 10:14 1 -> /dev/pts/413

lrwx------ 1 admin admin 64 2016-03-30 10:14 2 -> /dev/pts/413

lrwx------ 1 admin admin 64 2016-03-30 10:14 255 -> /dev/pts/413

我们说0代表stdin，1代表stdout，2代表stderr，这里stdin/stdout/stderr是实体（这里都是/dev/pts/413，即terminal这个设备），0/1/2只是一个fd，可以理解为指针或者标记；

(echo "I'm from stdout"; echo "I'm from stderr" 1>&2) 2>&1 >file1之所以file1里只会有1行，原因是：

我们首先把2指向了stdout（stdout正是1所指的东西），这个时候1和2都指向了stdout；

然后我们把1指向了file1，这个时候2依然还是指着stdout；

然后I'm from stdout这句话写到了1里面，其实也就是写到了file1里面，I'm from stderr这句话写到了2里面，其实也就是写到了stdout里面。

整体规则:

1. TO (<|>|<>) FROM;

2. (<|>)这两个东西后面可以跟&fd/&-/&fd-，也可以跟一个file名字；例外>&file1表示stdout和stderr都重定向到file1里面；<>后面只可以跟file1，例如<>file1表示从file1里既读入数据，也写入数据;

3. (<|>|<>)这三个东西前面不能有空格，后面跟的&不能有空格，除此之外无要求，例如：exec 1>& 2- #但2和-之间不能有空格；

操作:

1. 打开一个fd的方法：exec fd>&1 或者 exec fd<&0 或者 exec fd>file1 或者 exec fdfile1；

如果你不想指定fd（希望系统自动给你分配一个fd），那么有一种特殊的用法，例子是：

exec {NEW_STDOUT}>&1 #注意这个用法很特殊，你不能NEW_STDOUT=15; exec ${NEW_STDOUT}>&1

echo "hello" >&$NEW_STDOUT # echo "hello" >&${NEW_STDOUT}也可以

echo ${NEW_STDOUT} #从10开始分配

exec {NEW_STDOUT}>&-

2. 关闭一个fd的方法：exec fd>&- 或者 exec fd<&-

3. move fd的方法：new_fd>&old_fd-，move完之后，old_fd会被关掉；

实战:

(echo "I'm from stdout"; echo "I'm from stderr" 1>&2) 2>&1 >file1 #file1里将会有1行I'm from stdout，原因是stdout赋给了stderr，file1赋给了stdout，2句话里，打印到stdout的那句被写入file1，打印到stderr被写入到了stdout

(echo "I'm from stdout"; echo "I'm from stderr" 1>&2) >file1 2>&1 #file1里将会有2行，原因是file1赋给了stdout，stdout赋给了stderr（其实也就是file1赋给了stderr），这个时候，stdout和stderr都指向了file1

(echo "I'm from stdout"; echo "I'm from stderr" 1>&2) &> file1 #file1里将会有2行，file1前面的空格可以省略

(echo "I'm from stdout"; echo "I'm from stderr" 1>&2) >& file1 #file1里将会有2行，file1前面的空格可以省略

(echo "I'm from stdout"; echo "I'm from stderr" 1>&2) |& cat > file1 #file1里将会有2行，file1前面的空格可以省略

(echo "I'm from stdout"; echo "I'm from stderr" 1>&2) 2>&1 | cat > file1 #file1里将会有2行，file1前面的空格可以省略

(echo "I'm from stdout"; echo "I'm from stderr" 1>&2) >file1 | grep err #grep fail

(echo "I'm from stdout"; echo "I'm from stderr" 1>&2) 2>&1 >file1 | grep err #grep ok

(echo "I'm from stdout"; echo "I'm from stderr" 1>&2) 3>&1 1>&2 2>&3-| grep stderr #grep ok，这其实实现了stdout和stderr的交换，类似于通过c=a;a=b;b=c;来实现a和b的交换（先把a赋给c，紧接着找到b赋给a，然后用c再赋给b）

(echo "I'm from stdout"; echo "I'm from stderr" 1>&2) 1>&2- | grep stderr #grep ok

echo "hello world" | tee >(grep hello) >(grep world) >/dev/null #结合上tee的多路dispatch，功能会更强大

> file1 #create file1 or truncate file1 to zero size

2>&1 ls not_found_file | grep found #grep ok

cat < file1 > file2 #等同于cp file1 file2

<>高级用法:

1. 写到一个文件中指定的地方：

echo 1234567890 > file1 # 写字符串到"File".

exec 3<> file1 # 打开"File"并且给它分配fd 3.

read -n 4 <&3 # 只读4个字符.

echo -n . >&3 # 写一个小数点.

exec 3>&- # 关闭fd 3.

cat file1 # ==> 1234.67890

2. 用bash下载网页

$ exec 3<>/dev/tcp/www.baidu.com/80

$ echo -e "GET / HTTP/1.0\r\n\r\n" >&3

$ cat <&3

$ ls -l /proc/$$/fd

total 0

lr-x------ 1 admin admin 64 2016-03-30 10:14 0 -> /dev/pts/413

lrwx------ 1 admin admin 64 2016-03-30 10:14 1 -> /dev/pts/413

lrwx------ 1 admin admin 64 2016-03-30 10:14 2 -> /dev/pts/413

lrwx------ 1 admin admin 64 2016-03-30 10:14 255 -> /dev/pts/413

lrwx------ 1 admin admin 64 2016-03-30 10:14 3 -> socket:[173770096]

$ exec 3>&- # exec 3<&-也可以关闭

so true 2016-03-30 12:10 发表评论

signal process

so true — Wed, 17 Feb 2016 03:30:00 GMT

信号学习：

1。简单点用signal（主要就1个api，signal(SIGINT, SignalHandler)和signal(SIGINT, SIG_IGN)就是全部了）；

2。复杂点用sigaction（可以设置在handling期间，允许/不允许哪些信号打断自己）；

3。当前线程handling过程中，当前线程不会因为相同signal再次进入handler，但当前线程可以被别的signal打断重新进入handler，别的线程可以进入handler；

例如下面这个例子，只有一个主线程，先被SIGINT打断进入handler，虽然又被SIGTERM打断再次进入handler：

#0 0x00007f7cc55dc200 in __nanosleep_nocancel () at ../sysdeps/unix/syscall-template.S:82

#1 0x00007f7cc55dc090 in __sleep (seconds=) at ../sysdeps/unix/sysv/linux/sleep.c:138

#2 0x0000000000468300 in SignalHandler (sig=15) at src/dispatcher2_server.cpp:78

#4 0x00007f7cc55dc200 in __nanosleep_nocancel () at ../sysdeps/unix/syscall-template.S:82

#5 0x00007f7cc55dc090 in __sleep (seconds=) at ../sysdeps/unix/sysv/linux/sleep.c:138

#6 0x0000000000468300 in SignalHandler (sig=2) at src/dispatcher2_server.cpp:78

#8 0x00007f7cc55dc200 in __nanosleep_nocancel () at ../sysdeps/unix/syscall-template.S:82

#9 0x00007f7cc55dc090 in __sleep (seconds=) at ../sysdeps/unix/sysv/linux/sleep.c:138

#10 0x000000000046844a in main (argc=1, argv=0x7fff048454a8) at src/dispatcher2_server.cpp:102

demo：

static void SignalHandler(int sig) {

if (SIGTERM == sig || SIGINT == sig) {

struct sigaction sa;

memset(&sa, 0, sizeof(sa));

sa.sa_handler = SIG_IGN;

sigaction(SIGINT, &sa, NULL); // keep other threads from entering this handler

sigaction(SIGTERM, &sa, NULL); // keep other threads from entering this handler

//...

}

struct sigaction sa;

memset(&sa, 0, sizeof(sa));

sa.sa_handler = SignalHandler;

sigfillset(&sa.sa_mask); // block every signal during handling

sigaction(SIGINT, &sa, NULL);

sigaction(SIGTERM, &sa, NULL);

介绍：http://www.alexonlinux.com/signal-handling-in-linux
demo：http://aspyct.org/blog/2012/08/25/unix-signal-handling-example/

so true 2016-02-17 11:30 发表评论

tcp_server that is used to dump tcp datas

so true — Thu, 10 Dec 2015 13:15:00 GMT

#include
#include
#include
#include
#include in.h>
#include <string.h>
#include

void get_remote_ip_and_port(struct sockaddr_in* s_add, int* ip, int* port) {
    if (!s_add || !ip || !port) return;
    *port = ntohs(s_add->sin_port);
    *ip = s_add->sin_addr.s_addr;
}

void get_local_ip_and_port(int fd, int* ip, int* port) {
    if (fd <= 0 || !ip || !port) return;
    struct sockaddr_in s_add;
    int sin_size = sizeof(s_add);
    if(getsockname(fd, (struct sockaddr *)&s_add, &sin_size) == 0 && s_add.sin_family == AF_INET && sin_size == sizeof(s_add)) {
        *port = ntohs(s_add.sin_port);
        *ip = s_add.sin_addr.s_addr;
    }
}

char* get_ip_str(int ip, char* buf) {
    inet_ntop(AF_INET, &ip, buf, INET_ADDRSTRLEN);
    return buf;
}

void usage(char* argv0) {
    fprintf(stdout,
"Usage: %s [-p ] [-o output_file] [-h]\n\n"
" -p         local port used to listen, by default, 8888\n"
" -o  output file used to record the data received from client, by default, dump to ./x.in\n"
" -h               print this usage\n"
"\n", argv0);
}

int main(int argc, char* argv[]) {
    int sfp = 0;
    int nfp = 0;
    struct sockaddr_in s_add, c_add;
    int sin_size = 0;
    int server_port = 8888;
    int remote_port = 0;
    int remote_ip = 0;
    char remote_ip_str[INET_ADDRSTRLEN];
    int local_port = 0;
    int local_ip = 0;
    char local_ip_str[INET_ADDRSTRLEN];
    char output_file[256];
    sprintf(output_file, "%s", "./x.in");
    FILE* ofp = 0;

    char c = '\0';
    struct option long_options[] = {
        {"help", 0, 0, 'h'},
        {0,      0, 0, 0}
    };
    while (-1 != (c = getopt_long(argc, argv, ":p:o:h", long_options, NULL))) {
        switch (c) {
        case 'p':
            server_port = atoi(optarg);
            break;
        case 'o':
            sprintf(output_file, "%s", optarg);
            break;
        case 'h':
        case '?': //an option character that was not in optstring
        case ':': //an option with a missing argument
        default:
            usage(argv[0]);
            return -1;
        }
    }

    sfp = socket(AF_INET, SOCK_STREAM, 0);
    if (-1 == sfp) {
        printf("socket fail ! \n");
        return -1;
    }
    printf("socket ok !\n");

    bzero(&s_add, sizeof(struct sockaddr_in));
    s_add.sin_family = AF_INET;
    s_add.sin_addr.s_addr = htonl(INADDR_ANY);
    s_add.sin_port = htons(server_port);

    if (-1 == bind(sfp, (struct sockaddr *) (&s_add), sizeof(struct sockaddr))) {
        printf("bind fail !\n");
        return -1;
    }
    printf("bind to %d ok!\n", server_port);

    if (-1 == listen(sfp, 5)) {
        printf("listen fail !\n");
        return -1;
    }
    printf("listen ok\n\n");

    ofp = fopen(output_file, "wrb");
    while (1) {
        sin_size = sizeof(struct sockaddr_in);

        nfp = accept(sfp, (struct sockaddr *) (&c_add), &sin_size);
        if (-1 == nfp) {
            printf("accept fail !\n");
            return -1;
        }
        printf("accept ok!\n");

        get_remote_ip_and_port(&c_add, &remote_ip, &remote_port);
        get_local_ip_and_port(nfp, &local_ip, &local_port);
        printf("establish connect %s:%d -> %s:%d\n", get_ip_str(remote_ip, remote_ip_str), remote_port, get_ip_str(local_ip, local_ip_str), local_port);

        fprintf(ofp, "----------------- establish connect %s:%d -> %s:%d -----------------{\n", get_ip_str(remote_ip, remote_ip_str), remote_port, get_ip_str(local_ip, local_ip_str), local_port);
        char buffer[1024];
        int recbytes = 0;
        int total_bytes = 0;
        while ((recbytes = read(nfp, buffer, 1024)) > 0) {
            total_bytes += recbytes;
            fwrite(buffer, 1, recbytes, ofp);
        }
        fprintf(ofp, "\n}---------------- receive %d bytes ------------------\n\n", total_bytes);

        printf("receive over!\n\n");
        fflush(stdout);
        fflush(ofp);
        close(nfp);
    }

    fclose(ofp);
    close(sfp);

    return 0;
}

so true 2015-12-10 21:15 发表评论

一款非常不错的vim配色

so true — Tue, 15 Apr 2014 11:13:00 GMT

首先看看这款配色是否喜欢：

http://vimcolorschemetest.googlecode.com/svn/html/bensday-c.html

如果喜欢，现在教你如何在terminal下达到该效果（注意：不是在gvim下）：

1。add the following line in .bashrc：

export TERM=xterm-256color

2。install CSApprox：

http://www.vim.org/scripts/script.php?script_id=2390

3。install bensday.vim color scheme:

http://vimcolorschemetest.googlecode.com/svn/colors/bensday.vim

4。add following lines to .screenrc(refer: http://robotsrule.us/vim/):

#attrcolor b ".I"

#termcapinfo xterm 'Co#256:AB=\E[48;5;%dm:AF=\E38;5;%dm'

defbce "on"

5。modify the guibg value to grey15 of 37th line in bensday.vim as following:

hi NonText term=bold ctermfg=LightBlue gui=bold guifg=LightBlue guibg=grey15

这个页面下有大量的配色方案供你选择（注意：有些打不开，需要用国外代理打开）

http://vimcolorschemetest.googlecode.com/svn/html/index-c.html

这个页面也介绍了几款配色不错的方案：

http://www.oschina.net/news/32306/10-vim-color-schemes-you-need-to-

so true 2014-04-15 19:13 发表评论

PCRE Assertions

so true — Wed, 20 Nov 2013 12:27:00 GMT

首先明确几点概念：

1。断言是一个对当前匹配位置之前或之后的字符的测试；

2。断言不会实际消耗任何字符； #这一点至关重要

通常的用法： (?<=a)b(?=c) #b的前瞻是c，后瞻是a；

前瞻左置用法：(?=\d)\w+ #\w+需要以\d开始；

后瞻右置用法：\w+(?<=\d) #\w+需要以\d结束；

上面三种用法中，我们姑且把b和\w+称为修饰项。

对于后两种用法，要求前瞻/后瞻里用以约束修饰项的字符应当是修饰项的子集，否则就不太合适，例如：

a(?<=b)永远不可能成立，因为a!=b；

(?=a)b永远不可能成立，因为a!=b;

$ echo 'foobar' | grep -o -P '(?!foo)bar' #它不能用于查找之前出现所有不是 ”foo” 的 ”bar” 匹配，它会查找到任意的 ”bar” 出现的情况，因为 (?!foo) 这个断言在接下来三个字符时 ”bar” 的时候是永远都 TRUE 的(因为foo!=bar)。

bar

$ echo '!abcae20a' | grep -o -P '\w{4,}(?=.*\d)' #0用于支撑后面的前瞻断言

abcae2

$ echo '!abcae20a' | grep -o -P '\w{4,}(?<=\d)' #0不需要拿出来支撑断言

abcae20

$ echo '!abcae20' | grep -o -P '\w{4,}(?<=.*\d)' #后瞻断言必须定长

grep: lookbehind assertion is not fixed length

$ echo '!abcae20' | grep -o -P '(?=.*\d)\w{4,}' #这个前瞻左置断言不定长，而且前瞻过程中没有任何字符约束，也比较诡异，匹配不出结果，最好不要这样写

$ echo 'a2 abcae20a' | grep -o -P '(?=.*\d)\w+' #这个前瞻左置断言不定长，而且前瞻过程中没有任何字符约束，也比较诡异，只匹配出部分结果，最好不要这样写

$ echo '!abcae20' | grep -o -P '(?=\w+\d)\w{4,}' #这个前瞻断言虽然不定长，但是里面的字符都在修饰项的范畴内

abcae20

$ echo 'a2 ab!cae20a' | grep -o -P 'a(?=.*\d)\w+' #注意对于第2组结果'ab'，里面并不包含数字，但是其后面有数字20，因此前瞻断言成立

ae20a

$ echo '!abcae20' | grep -o -P '.*?(?=.*\d)\w{4,}' #可以用最开始的.*来吸收不属于\w的字符

!abcae20

$ echo '!a21ed0' | grep -o -P '(?=(?:\w*?\d){3,})\w{6,}' #实现了最终想要的功能：一个字符串至少有6个字符，而且至少有3个数字

a21ed0

总结：前瞻断言放在修饰项后面比较容易理解；放在修饰项前面时：主要用于概括性的规定修饰项里包含的内容，因此此时的前瞻断言里允许出现的字符应该都是修饰项里可接受的字符

更多详细介绍可以参见：http://www.php.net/manual/zh/reference.pcre.pattern.syntax.php

so true 2013-11-20 20:27 发表评论

vim必须的一些配置

so true — Mon, 26 Aug 2013 08:47:00 GMT

set nocompatible
set nu

set expandtab

set tabstop=4

set shiftwidth=4

set cursorline

set list
set hlsearch

syntax on

set listchars=tab:>-,trail:-

highlight WhitespaceEOL ctermbg=magenta guibg=magenta

match WhitespaceEOL /\s\+$\|\t/

autocmd BufReadPost * if line("'\"") > 0 && line("'\"") <= line("$") | exe "normal g'\"" | endif

inoremap

inoremap 0i

inoremap A

so true 2013-08-26 16:47 发表评论

关于trap的实验

so true — Wed, 14 Aug 2013 08:08:00 GMT

-------------------------------------

trap 'date' SIGUSR2

echo before

while true; do

sleep 0.01

done

echo after

kill -SIGUSR2 XXX #date立即被执行

--------------------------------------

trap 'date' SIGUSR2

echo before

sleep 10

echo after

kill -SIGUSR2 XXX #date未被执行，直到sleep 10结束后立即被执行，最后再打印出after

--------------------------------------

trap 'date' SIGUSR2

echo before

sleep 100 &

wait

echo after

kill -SIGUSR2 XXX #wait被立即中断（wait的返回码是一个大于128的值），date立即被执行，然后打印出after退出

--------------------------------------

shell在执行过程中，在一个命令执行过程中不会执行trap指定的命令，只有在命令执行完之后才会执行trap指定的命令；

Ctrl+c #给程序发送SIGINT信号

Ctrl+\ #给程序发送SIGTERM信号

bash shell会忽略SIGQUIT信号，即：1个shell进程run时发SIGQUIT不会退出；但你自己编译的程序run时收到SIGQUIT是会退出的

用EXIT来做清理：trap "{ rm -f $tmp_file ; exit 255; }" EXIT

用ERR来做警告，可以参见：http://blog.csdn.net/sosodream/article/details/5681893和http://blog.csdn.net/sosodream/article/details/5724650

用DEBUG来做调试，例如来跟踪变量的变化：

trap "echo tmp_value is being changed." DEBUG

bla bla bla

declare -t tmp_value=38

so true 2013-08-14 16:08 发表评论

使用gnuplot绘图

so true — Wed, 31 Jul 2013 08:55:00 GMT

摘要: 学习资料：http://www.ibm.com/developerworks/cn/linux/l-gnuplot/index.htmlhttps://www.bbsmax.com/A/Ae5R4pxNzQ/https://xijunlee.github.io/2016/12/24/2016-12-24-you-bi-ge-de-hua-tu-cong-gnuplotshuo-qi/$ cat t... 阅读全文

so true 2013-07-31 16:55 发表评论

bash使用getopt解析长短参数

so true — Thu, 11 Jul 2013 03:27:00 GMT

#!/bin/bash

# A small example program for using the new getopt(1) program.

# This program will only work with bash(1)

# An similar program using the tcsh(1) script language can be found

# as parse.tcsh

# Example input and output (from the bash prompt):

# ./option_test.sh -a par1 'another arg' --c-long 'wow!*\?' -cmore -b " very long "

# Option a

# Option c, no argument

# Option c, argument `more'

# Option b, argument ` very long '

# Remaining arguments:

# --> `par1'

# --> `another arg'

# --> `wow!*\?'

# Note that we use `"$@"' to let each command-line parameter expand to a

# separate word. The quotes around `$@' are essential!

# We need TEMP as the `eval set --' would nuke the return value of getopt.

#-o表示短选项，两个冒号表示该选项有一个可选参数，可选参数必须紧贴选项

#如-carg 而不能是-c arg

#--long表示长选项

#"$@"在上面解释过

# -n:出错时的信息

# -- ：举一个例子比较好理解：

#我们要创建一个名字为 "-f"的目录你会怎么办？

# mkdir -f #不成功，因为-f会被mkdir当作选项来解析，这时就可以使用

# mkdir -- -f 这样-f就不会被作为选项。

TEMP=`getopt -o ab:c:: -l a-long,b-long:,c-long:: -n 'option_test.sh' -- "$@"`

echo "TEMP:{$TEMP}"

if [ $? != 0 ] ; then echo "Terminating..." >&2 ; exit 1 ; fi

# Note the quotes around `$TEMP': they are essential!

#set 会重新排列参数的顺序，也就是改变$1,$2...$n的值，这些值在getopt中重新排列过了

eval set -- "$TEMP" #必须用eval

echo "\$#: $#"

for i in "$@"; do

echo "{$i}"

done

#经过getopt的处理，下面处理具体选项。

while true ; do

case "$1" in

-a|--a-long) echo "Option a" ; shift ;;

-b|--b-long) echo "Option b, argument \`$2'" ; shift 2 ;;

-c|--c-long)

# c has an optional argument. As we are in quoted mode,

# an empty parameter will be generated if its optional

# argument is not found.

case "$2" in

"") echo "Option c, no argument"; shift 2 ;;

*) echo "Option c, argument \`$2'" ; shift 2 ;;

esac ;;

--) shift ; break ;;

*) echo "Internal error!" ; exit 1 ;;

esac

done

echo "Remaining arguments:"

for arg do

echo '--> '"\`$arg'" ;

done

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

$ set -- a ' b '

$ echo $#

$ a="a ' b '"

$ set -- $a

$ echo $#

$ set -- "$a"

$ echo $#

so true 2013-07-11 11:27 发表评论

`纪念这种old-style的quotation'

so true — Thu, 11 Jul 2013 03:09:00 GMT

在linux的很多文档中都看到`something'这种quote的用法，一直不知道为何，今天终于搞懂了，所以在这里纪念＋记录一下。'something'这种quote是undirected quotation, ‘something’是directional quotation，在old X下，不能很好的支持directional quotation，因此借用`something'能够显示出directional quotation的效果，但new X下，已经支持directional quotation，因此这些老的quotation记法就闲得很丑陋了，不过很多linux/unix的老文档年代久远，就一直沿用下来了。

相关解释参见：http://www.cl.cam.ac.uk/~mgk25/ucs/quotes.html；

我是从http://www.trilithium.com/johan/2005/07/quotation-marks/找到上面那个解释的文章的；

我是通过google `bash grave accent apostrophe quote' 在第2页发现的上面那个博客的。

so true 2013-07-11 11:09 发表评论

epoll简单学习

so true — Thu, 04 Jul 2013 09:36:00 GMT

epoll的EPOLLIN和EPOLLOU为什么不能同时关联 http://laokaddk.blog.51cto.com/368606/791945

epoll使用总结 http://laokaddk.blog.51cto.com/368606/617497

epoll学习：思考一种高性能的服务器处理框架 http://laokaddk.blog.51cto.com/368606/607231

epoll学习笔记 http://laokaddk.blog.51cto.com/368606/607017

简单学习了一下epoll，之前也用过，这次又看了看，收获如下：

两种实现模式（在http://laokaddk.blog.51cto.com/368606/791945中都有提到）：同一个线程和不同线程；

顺便了解了一下惊群现象，如果用accept阻塞的方式就不存在惊群现象了，在不同线程中通过epoll_wait来出发accept行为的nginx的解决方法是通过进程里原子的修改寄存器a来做到进程间互斥的。

在不同线程模式下：listenfd需设置为非阻塞，注册EPOLLIN就可以了，触发时调用accept，有没有连接都会立刻返回；

在同一个线程模式下：listenfd为阻塞模式，不注册epoll，阻塞while调用accept即可；

ET触发只支持非阻塞模式，这里针对的fd是accept接收到的然后epoll_add了的那些fds，原因是：因为ET触发需要处理函数一直处理完所有in/out数据，比如read数据，如果read到的字节数小于预先准备读入的字节数，那么就可以认为读完了；如果是非阻塞模式，那么read会一直阻塞在那里。

epollfd不需要设置阻塞、非阻塞。

一般都用LT触发，不论哪种实现模式，EPOLLIN和EPOLLOUT都不同时设定，都是不断切换来做的。

客户端close掉socket时，会唤醒服务端epoll_wait;

对于epoll_wait而言，针对一个fd只存在唤醒与被唤醒，至于是EPOLLIN还是EPOLLOUT，取决于你当初epoll_add时的设定，因此如果你epoll_add时设定了EPOLLIN|EPOLLOUT，那么当EPOLLIN发生时（内核里当然是可以区分EPOLLIN和EPOLLOUT的），你收到的fd上的事件依然是EPOLLIN|EPOLLOUT。

http://my.oschina.net/costaxu/blog/127394

http://blog.csdn.net/guomsh/article/details/8484222

http://blog.csdn.net/guomsh/article/details/8478209

http://blog.csdn.net/ctthuangcheng/article/details/8596818

http://blog.yunn.io/archives/114/

so true 2013-07-04 17:36 发表评论

eth0 is not ready

so true — Tue, 22 Jan 2013 02:18:00 GMT

final solution:
http://ubuntuforums.org/showthread.php?t=1022411
This is guidance for those with integrated Realtek RTL8111 series gigabit Ethernet, built in to motherboards such as the ASRock G41M-LE.

Ubuntu 8.10 (and may other versions) have been reporting problems with connectivity. Here is the solution in a walk-through format. You must be root (sudo su -).

1) Check to see if the r8169 module is loaded
-> lsmod | grep r816
r8168 41104 0
-> lspci -v
01:00.0 Ethernet controller: Realtek Semiconductor Co., Ltd. RTL8111/8168B PCI Express Gigabit Ethernet controller (rev 03)
Subsystem: ASRock Incorporation Device 8168
Kernel driver in use: r8169
Kernel modules: r8169

2) Download the official Realtek driver
Realtek RTL8111/RTL8168

3) Remove the r8169 module
-> rmmod r8169
-> mv /lib/modules/`uname -r`/kernel/drivers/net/r8169.ko ~/r8169.ko.backup
( the ` is a backtick, it is not an apostrophe or single quote )

4) Build the new r8168 module for the kernel
-> bzip2 -d r8168-8.009.00.tar.bz2
-> tar -xf r8168-8.009.00.tar
-> cd r8168-8.009.00
-> make clean modules
-> make install

5) Rebuild the kernel module dependencies
-> depmod -a
-> insmod ./src/r8168.ko

6) Remove the r8169 module from initrd
-> mv /initrd.img ~/initrd.img.backup
-> mkinitramfs -o /boot/initrd.img-`uname -r` `uname -r`

7) Add r8168 module to /etc/modules
-> echo "r8168" >> /etc/modules

8) Reboot, You are done!

9) Examine that ONLY the r8168 module is loaded for the interface
-> lspci -v
01:00.0 Ethernet controller: Realtek Semiconductor Co., Ltd. RTL8111/8168B PCI Express Gigabit Ethernet controller (rev 03)
Subsystem: ASRock Incorporation Device 8168
Kernel driver in use: r8168
Kernel modules: r8168

Actions as needed in fact:
1. download driver;
2. untar and ./autorun.sh
Ok, it's all done.

sudo /etc/init.d/networking restart

sudo ifconfig eth0 down/up

nm-tool

cat /var/log/message

cat /var/log/syslog

dmesg

lspci

lsmod

lshw

dmidecode

biosdecode

cat /proc/cpu

vi /etc/network/interfaces

auto eth0

The solution

- Boot up Windows

- Right click on My Computer

- Click on Properties -> Hardware -> Device Manager

- Expand your network card section and double click on your Realtek network card

- Set "Wake-on-lan after shutdown" to enabled

i removed r8169 and installed r8168

this can be done by downloading it from the realtek-website.

the problem afterwards was that r8169 was coming back after a restart. The solution for this problem can be found here :

http://ubuntuforums.org/showthread.php?t=936379

thanx for the answer.

I had the same problem. I had to use Google for a long time, till i found a solution in a german forum (i am from germany; sorry for my english if it's too bad). Here are the instructions:

First, you need to rename the r8169 driver, because it won't work with this one.

> mv /lib/modules/`uname -r`/kernel/drivers/net/r8169.ko /lib/modules/`uname -r`/kernel/drivers/net/r8169.ko.old

> depmod -a

To save the current ramdiscimage and make a new one:

> mv /boot/initrd.img-`uname -r` /boot/initrd.img-`uname -r`.old

> mkinitramfs -o /boot/initrd.img-`uname -r`

Now you have to reboot. After this, it worked for me. To see weather the right module is loaded, you can use this:

> lsmod | grep r81*

There it showed me the right module, r8168.

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

The device eth0 is not ready!

记得我的电脑是在一次升级之后出现的这种情况，之前都使用得非常好，觉得可能是安装了一些中文汉化升级包，防火墙的一些英文参数发生了变化。不过还好，本人从网上找到了一些相关的帖子，解决了问题，本人验证过。

在终端中输入： sudo gedit /etc/firestarter/firestarter.sh

在 # External network interface data

这行注释的上面，添加一行：

LANG=en_US

保存后（不须重启），firestarter就可以顺利启动，正常工作了，再也没有那烦人的提示。

注意：在加入LANG=en_US之后，如果再运行firestarter的运行向导，则先前加入的LANG=en_US会消失，错误问题会和以前一样出现，防火墙不能用，你须要再一次加入LANG=en_US

eth0 Link encap:Ethernet HWaddr 00:24:E8:5F:EF:85

inet addr:192.168.1.88 Bcast:192.168.1.255 Mask:255.255.255.0

inet6 addr: fe80::224:e8ff:fe5f:ef85/64 Scope:Link

UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1

RX packets:2322 errors:0 dropped:906 overruns:0 frame:0

TX packets:1188 errors:0 dropped:0 overruns:0 carrier:0

collisions:0 txqueuelen:1000

RX bytes:215275 (210.2 KiB) TX bytes:518134 (505.9 KiB)

Interrupt:169 Memory:dfdf0000-dfe00000

========

sudo restart network-manager

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

Suspend causes eth0 to disconnect intermittently

Install WICD (System > Administration > Synaptic Package Manager; install wicd).

Uninstall network manager (mark for complete removal network-manager and network-manager-gnome). Reboot.

so true 2013-01-22 10:18 发表评论

如何修改进程的命令行

so true — Fri, 21 Dec 2012 07:18:00 GMT

下面这段代码摘自php/sapi/fpm/fpm/fpm_env.c
/*

* This piece of code has been inspirated from nginx and pureftpd code, whic

* are under BSD licence.

* To change the process title in Linux we have to set argv[1] to NULL

* and to copy the title to the same place where the argv[0] points to.

* However, argv[0] may be too small to hold a new title. Fortunately, Linux

* store argv[] and environ[] one after another. So we should ensure that is

* the continuous memory and then we allocate the new memory for environ[]

* and copy it. After this we could use the memory starting from argv[0] for

* our process title.

for (i = 0; i < fpm_globals.argc; i++) {

if (first == NULL) {

first = fpm_globals.argv[i];

}

if (last == NULL || fpm_globals.argv[i] == last + 1) {

last = fpm_globals.argv[i] + strlen(fpm_globals.argv[i]);

}

if (environ) {

for (i = 0; environ[i]; i++) {

if (first == NULL) {

first = environ[i];

}

if (last == NULL || environ[i] == last + 1) {

last = environ[i] + strlen(environ[i]);

}

if (first == NULL || last == NULL) {

return 0;

}

fpm_env_argv_len = last - first;

fpm_env_argv = fpm_globals.argv;

if (environ != NULL) {

char **new_environ;

unsigned int env_nb = 0U;

while (environ[env_nb]) {

env_nb++;

}

if ((new_environ = malloc((1U + env_nb) * sizeof (char *))) == NULL) {

return -1;

}

new_environ[env_nb] = NULL;

while (env_nb > 0U) {

env_nb--;

new_environ[env_nb] = strdup(environ[env_nb]);

}

environ = new_environ;

}

#endif

spprintf(&title, 0, "master process (%s)", fpm_globals.config);

fpm_env_setproctitle(title);

efree(title);

so true 2012-12-21 15:18 发表评论

玩转X

so true — Mon, 26 Nov 2012 13:05:00 GMT

下面的分析是在Ubuntu环境下进行的。

X分为Server和Client，我们可以通过X :1 vt9来启动一个X Server，然后DISPLAY=:1 gedit你会发现gedit这个client应用会出现在vt9上（通过Ctrl＋alt＋F9）来切换，当然你可以通过DISPLAY=:1 gnome-session在vt9上启动一个gnome-session，这样就相当于你在本地打开了两个桌面会话，其实这也可以通过startx -- :1 vt9这一个命令搞定。
如果出现了“X: user not authorized to run the X server, aborting.”这种错误，解决的方法是：修改/etc/X11/Xwrapper.config中的控制项：allowed_users=anybody。
如果期望在vt9上为另外一个用户打开一个X，需要先sudo login user2（使用su user2是不行的），然后再startx -- :1 vt9；或者先ssh user2@localhost，然后再startx -- :1 vt9，总之可以用w命令看一下，如果看不到user2就不行。

很多时候我们ssh到服务器，可以通过ssh -C -X server_ip来连接服务器，这样可以执行服务器上的任何窗口应用了。但这么做之前请确保：设置服务器端配置文件/etc/ssh/sshd_config中包含"X11Forwarding yes";客户端配置文件/etc/ssh/ssh_config包含"ForwardX11 yes"。这种情况下，从客户端ssh到服务器端后, 服务端会自动设置DISPLAY环境变量, 允许在服务器端执行的图形程序将图形显示在客户端上. 在服务器上查看环境变量显示如下:
DISPLAY=localhost:10.0
在服务器上用netstat -lnpt可以看到有程序监听了6010端口
tcp 0 0 127.0.0.1:6010 0.0.0.0:* LISTEN 4827/1
其实就是在服务器上启动了一个XServer，侦听6010端口，所以在服务器上运行窗口应用时（就是XClient）可以在在XServer上显示，而ssh server会进行X11Forwarding，这样窗口就通过ssh隧道来到了客户端，如果不希望在客户端当前vt上显示的话，可以在例如vt9上开一个X，然后执行DISPLAY=:1 ssh -C -X Server_ip

可以设置DISPLAY=host:NumA.NumB，现在的系统启动X时都不再侦听端口，所以一般都是在本地玩X，如果服务器的X启动时打开了端口，那么可以直接把客户端的XClient放到服务器上，关于DISPLAY的详细说明，大家可以参考：http://hi.baidu.com/twltnjbntobehiq/item/af145efbaa022a13d7ff8c88

下面再说说常用的一款软件vnc，一般我们用vncserver在服务器上启动一个daemon进程侦听端口，在客户机上用vncviewer来连接服务器上的vncserver，从而开启一个远程X桌面，最新的vnc（5.0.3）为例，在服务器上安装vncserver，别用/etc/vnc/下面的脚本启动vncserver，也别用vncserver-x11启动usermode的vncserver，这个server会让vncviewer看到和server完全一样的桌面，而且会同步控制server，用vncserver命令来启动，在5.0.3中这种模式被称作virtual模式，vncviewer连接这种vncserver后，相当于新开启一个X桌面投放到vncviewer上了，启动vncserver时可以通过添加-geometry和-depth来控制vncviewer看到的窗口大小和色深，这两个参数其实是Xvnc的参数，可以通过Xvnc --help来看到更多的参数。

再补充一点，如果X完全挂掉了，需要手动启动X，那么用sudo start gdm

so true 2012-11-26 21:05 发表评论

创建svn

so true — Wed, 14 Nov 2012 06:28:00 GMT

对一个已有目录建立svn的最最精简的步骤：
1. svnadmin create svn_root
2. 修改svn_root/conf/svnserve.conf中的下面这一行（注意，每行配置，要把前面的空格也删除掉）：

anon-access = write
3. svnserve -d -r svn_root #svnserve的根目录必须是通过svnadmin创建出来的目录，该目录下有conf/ db/ format hooks/ locks/等文件或文件夹
4. svn mkdir --parents svn://localhost/search/spider/trunk/ -m 'create the trunk dir for spider team of search group'
5. svn list svn://localhost/
6. svn list svn://localhost/search/
7. svn list svn://localhost/search/spider/
8. svn list svn://localhost/search/spider/trunk/
9. mkdir -p svn_spider_root/trunk/ #或许这个路径已经存在，更或许在svn_spider_root/trunk/目录下已经有很多内容了
10. cd svn_spider_root/trunk #可见，本地路径和svn server里的路径不一定一致，其实是压根没什么关系
11. svn co svn://localhost/search/spider/trunk . #此时，trunk目录已经在svn的control下了
12. svn info .
13. cp -r XXX .
14. svn add *
15. svn ci -m 'first version' .

其他的一些资料：

svnadmin create /home/admin/svn_root/

svn mkdir --parents file:///home/admin/svn_root/project1_repo/{trunk,tags,branches} -m "initial dir creation"

#下面这些配置文件在配置时，千万不能以空格开头

cat > /home/admin/svn_root/conf/svnserve.conf

[general]

password-db = passwd

cat > /home/admin/svn_root/conf/passwd

admin = admin

svnserve -d -r /home/admin/svn_root/ --listen-port 3389

#会把/home/admin/some_existed_stuffs/目录下的东西ci到trunk下，不会在trunk下创建some_existed_stuffs目录

svn import -m "Initial import" /home/admin/some_existed_stuffs svn://localhost:3389/svn_root/project1_repo/trunk/

svn co svn://localhost:3389/svn_root/project1_repo/ project1_repo

备注：
其实用file://和svn://的区别就在于是否通过svnserve启动了daemon进程侦听端口，所以svn mkdir和svn import都可以通过svn://来进行。
因此，如果不考虑打个http服务给别人使用，而只是在本地自己控制版本的话，完全可以用file://协议，例如：

$ svnadmin create svn_test

$ svn mkdir file:///home/admin/svn_test/trunk/ -m 'create trunk dir'

Committed revision 1.

$ svn import mk_test/ file:///home/admin/svn_test/trunk/ -m 'import basic files'

Adding (bin) mk_test/t3

Adding mk_test/t3.cpp

Adding mk_test/Makefile

Committed revision 2.

$ svn co file:///home/admin/svn_test/trunk/ test_trunk

A test_trunk/t3

A test_trunk/t3.cpp

A test_trunk/Makefile

Checked out revision 2.

$ cd test_trunk

$ svn st

$ svn info

Path: .

URL: file:///home/admin/svn_test/trunk

Repository Root: file:///home/admin/svn_test

Repository UUID: 873f7a52-8ee6-4740-958b-5e58c9997b03

Revision: 2

Node Kind: directory

Schedule: normal

Last Changed Author: admin

Last Changed Rev: 2

Last Changed Date: 2012-11-14 14:46:19 +0800 (Wed, 14 Nov 2012)

$ vi t4.cpp

$ svn st

? t4.cpp

M t3.cpp

$ svn add t4.cpp

A t4.cpp

$ svn st

M t3.cpp

A t4.cpp

$ svn ci -m 'add t4.cpp'

Sending t3.cpp

Adding t4.cpp

Transmitting file data ..

Committed revision 3.

$ svn log

------------------------------------------------------------------------

r2 | admin | 2012-11-14 14:46:19 +0800 (Wed, 14 Nov 2012) | 1 line

import basic files

------------------------------------------------------------------------

r1 | admin | 2012-11-14 14:45:54 +0800 (Wed, 14 Nov 2012) | 1 line

create trunk dir

------------------------------------------------------------------------

说到这里，有一个很有用的功能，例如你已经有一个目录，下面有一些文件，现在你想把这个目录受到版本控制，即把当前状态作为最开始的一个版本，在本地可以这么干：

cd /home/admin/project1

svn co file:///home/admin/svn_root/tmp_projects/project1 . #this only creates the ".svn" folder for version control，其实就是将当前目录分配到svn的某一个节点下，这个节点如果不存在，需要事先mkdir，注意最后一个参数一定得是'.'

svn add ./* #tell svn you want to version control all files in this dir

svn ci -m 'add /home/admin/project1 under version control' #check the files in

此外，如果需要http://协议，那需要搭建一个apache服务，参见相关链接[2]

相关链接：
[1] http://greatwqs.iteye.com/blog/1074448
[2] https://support.eapps.com/index.php?/Knowledgebase/Article/View/254/62/cloud-hosting-applications---subversion-svn

so true 2012-11-14 14:28 发表评论

.gdbinit文件

so true — Wed, 07 Nov 2012 09:51:00 GMT

# STL GDB evaluators/views/utilities - 1.03

# The new GDB commands:

# are entirely non instrumental

# do not depend on any "inline"(s) - e.g. size(), [], etc

# are extremely tolerant to debugger settings

# This file should be "included" in .gdbinit as following:

# source stl-views.gdb or just paste it into your .gdbinit file

# The following STL containers are currently supported:

# std::vector -- via pvector command

# std::list -- via plist or plist_member command

# std::map -- via pmap or pmap_member command

# std::multimap -- via pmap or pmap_member command

# std::set -- via pset command

# std::multiset -- via pset command

# std::deque -- via pdequeue command

# std::stack -- via pstack command

# std::queue -- via pqueue command

# std::priority_queue -- via ppqueue command

# std::bitset -- via pbitset command

# std::string -- via pstring command

# std::widestring -- via pwstring command

# The end of this file contains (optional) C++ beautifiers

# Make sure your debugger supports $argc

# Simple GDB Macros writen by Dan Marinescu (H-PhD) - License GPL

# Inspired by intial work of Tom Malnar,

# Tony Novac (PhD) / Cornell / Stanford,

# Gilad Mishne (PhD) and Many Many Others.

# Contact: dan_c_marinescu@yahoo.com (Subject: STL)

# Modified to work with g++ 4.3 by Anders Elton

# Also added _member functions, that instead of printing the entire class in map, prints a member.

# std::vector<>

define pvector

if $argc == 0

help pvector

else

set $size = $arg0._M_impl._M_finish - $arg0._M_impl._M_start

set $capacity = $arg0._M_impl._M_end_of_storage - $arg0._M_impl._M_start

set $size_max = $size - 1

end

if $argc == 1

set $i = 0

while $i < $size

printf "elem[%u]: ", $i

p *($arg0._M_impl._M_start + $i)

set $i++

end

if $argc == 2

set $idx = $arg1

if $idx < 0 || $idx > $size_max

printf "idx1, idx2 are not in acceptable range: [0..%u].\n", $size_max

else

printf "elem[%u]: ", $idx

p *($arg0._M_impl._M_start + $idx)

end

if $argc == 3

set $start_idx = $arg1

set $stop_idx = $arg2

if $start_idx > $stop_idx

set $tmp_idx = $start_idx

set $start_idx = $stop_idx

set $stop_idx = $tmp_idx

end

if $start_idx < 0 || $stop_idx < 0 || $start_idx > $size_max || $stop_idx > $size_max

printf "idx1, idx2 are not in acceptable range: [0..%u].\n", $size_max

else

set $i = $start_idx

while $i <= $stop_idx

printf "elem[%u]: ", $i

p *($arg0._M_impl._M_start + $i)

set $i++

end

if $argc > 0

printf "Vector size = %u\n", $size

printf "Vector capacity = %u\n", $capacity

printf "Element "

whatis $arg0._M_impl._M_start

end

document pvector

Prints std::vector information.

Syntax: pvector

Note: idx, idx1 and idx2 must be in acceptable range [0...size()-1].

Examples:

pvector v - Prints vector content, size, capacity and T typedef

pvector v 0 - Prints element[idx] from vector

pvector v 1 2 - Prints elements in range [idx1..idx2] from vector

end

# std::list<>

define plist

if $argc == 0

help plist

else

set $head = &$arg0._M_impl._M_node

set $current = $arg0._M_impl._M_node._M_next

set $size = 0

while $current != $head

if $argc == 2

printf "elem[%u]: ", $size

p *($arg1*)($current + 1)

end

if $argc == 3

if $size == $arg2

printf "elem[%u]: ", $size

p *($arg1*)($current + 1)

end

set $current = $current._M_next

set $size++

end

printf "List size = %u \n", $size

if $argc == 1

printf "List "

whatis $arg0

printf "Use plist to see the elements in the list.\n"

end

document plist

Prints std::list information.

Syntax: plist : Prints list size, if T defined all elements or just element at idx

Examples:

plist l - prints list size and definition

plist l int - prints all elements and list size

plist l int 2 - prints the third element in the list (if exists) and list size

end

define plist_member

if $argc == 0

help plist_member

else

set $head = &$arg0._M_impl._M_node

set $current = $arg0._M_impl._M_node._M_next

set $size = 0

while $current != $head

if $argc == 3

printf "elem[%u]: ", $size

p (*($arg1*)($current + 1)).$arg2

end

if $argc == 4

if $size == $arg3

printf "elem[%u]: ", $size

p (*($arg1*)($current + 1)).$arg2

end

set $current = $current._M_next

set $size++

end

printf "List size = %u \n", $size

if $argc == 1

printf "List "

whatis $arg0

printf "Use plist_member to see the elements in the list.\n"

end

document plist_member

Prints std::list information.

Syntax: plist : Prints list size, if T defined all elements or just element at idx

Examples:

plist_member l int member - prints all elements and list size

plist_member l int member 2 - prints the third element in the list (if exists) and list size

end

# std::map and std::multimap

define pmap

if $argc == 0

help pmap

else

set $tree = $arg0

set $i = 0

set $node = $tree._M_t._M_impl._M_header._M_left

set $end = $tree._M_t._M_impl._M_header

set $tree_size = $tree._M_t._M_impl._M_node_count

if $argc == 1

printf "Map "

whatis $tree

printf "Use pmap to see the elements in the map.\n"

end

if $argc == 3

while $i < $tree_size

set $value = (void *)($node + 1)

printf "elem[%u].left: ", $i

p *($arg1*)$value

set $value = $value + sizeof($arg1)

printf "elem[%u].right: ", $i

p *($arg2*)$value

if $node._M_right != 0

set $node = $node._M_right

while $node._M_left != 0

set $node = $node._M_left

end

else

set $tmp_node = $node._M_parent

while $node == $tmp_node._M_right

set $node = $tmp_node

set $tmp_node = $tmp_node._M_parent

end

if $node._M_right != $tmp_node

set $node = $tmp_node

end

set $i++

end

if $argc == 4

set $idx = $arg3

set $ElementsFound = 0

while $i < $tree_size

set $value = (void *)($node + 1)

if *($arg1*)$value == $idx

printf "elem[%u].left: ", $i

p *($arg1*)$value

set $value = $value + sizeof($arg1)

printf "elem[%u].right: ", $i

p *($arg2*)$value

set $ElementsFound++

end

if $node._M_right != 0

set $node = $node._M_right

while $node._M_left != 0

set $node = $node._M_left

end

else

set $tmp_node = $node._M_parent

while $node == $tmp_node._M_right

set $node = $tmp_node

set $tmp_node = $tmp_node._M_parent

end

if $node._M_right != $tmp_node

set $node = $tmp_node

end

set $i++

end

printf "Number of elements found = %u\n", $ElementsFound

end

if $argc == 5

set $idx1 = $arg3

set $idx2 = $arg4

set $ElementsFound = 0

while $i < $tree_size

set $value = (void *)($node + 1)

set $valueLeft = *($arg1*)$value

set $valueRight = *($arg2*)($value + sizeof($arg1))

if $valueLeft == $idx1 && $valueRight == $idx2

printf "elem[%u].left: ", $i

p $valueLeft

printf "elem[%u].right: ", $i

p $valueRight

set $ElementsFound++

end

if $node._M_right != 0

set $node = $node._M_right

while $node._M_left != 0

set $node = $node._M_left

end

else

set $tmp_node = $node._M_parent

while $node == $tmp_node._M_right

set $node = $tmp_node

set $tmp_node = $tmp_node._M_parent

end

if $node._M_right != $tmp_node

set $node = $tmp_node

end

set $i++

end

printf "Number of elements found = %u\n", $ElementsFound

end

printf "Map size = %u\n", $tree_size

end

document pmap

Prints std::map or std::multimap information. Works for std::multimap as well.

Syntax: pmap : Prints map size, if T defined all elements or just element(s) with val(s)

Examples:

pmap m - prints map size and definition

pmap m int int - prints all elements and map size

pmap m int int 20 - prints the element(s) with left-value = 20 (if any) and map size

pmap m int int 20 200 - prints the element(s) with left-value = 20 and right-value = 200 (if any) and map size

end

define pmap_member

if $argc == 0

help pmap_member

else

set $tree = $arg0

set $i = 0

set $node = $tree._M_t._M_impl._M_header._M_left

set $end = $tree._M_t._M_impl._M_header

set $tree_size = $tree._M_t._M_impl._M_node_count

if $argc == 1

printf "Map "

whatis $tree

printf "Use pmap to see the elements in the map.\n"

end

if $argc == 5

while $i < $tree_size

set $value = (void *)($node + 1)

printf "elem[%u].left: ", $i

p (*($arg1*)$value).$arg2

set $value = $value + sizeof($arg1)

printf "elem[%u].right: ", $i

p (*($arg3*)$value).$arg4

if $node._M_right != 0

set $node = $node._M_right

while $node._M_left != 0

set $node = $node._M_left

end

else

set $tmp_node = $node._M_parent

while $node == $tmp_node._M_right

set $node = $tmp_node

set $tmp_node = $tmp_node._M_parent

end

if $node._M_right != $tmp_node

set $node = $tmp_node

end

set $i++

end

if $argc == 6

set $idx = $arg5

set $ElementsFound = 0

while $i < $tree_size

set $value = (void *)($node + 1)

if *($arg1*)$value == $idx

printf "elem[%u].left: ", $i

p (*($arg1*)$value).$arg2

set $value = $value + sizeof($arg1)

printf "elem[%u].right: ", $i

p (*($arg3*)$value).$arg4

set $ElementsFound++

end

if $node._M_right != 0

set $node = $node._M_right

while $node._M_left != 0

set $node = $node._M_left

end

else

set $tmp_node = $node._M_parent

while $node == $tmp_node._M_right

set $node = $tmp_node

set $tmp_node = $tmp_node._M_parent

end

if $node._M_right != $tmp_node

set $node = $tmp_node

end

set $i++

end

printf "Number of elements found = %u\n", $ElementsFound

end

printf "Map size = %u\n", $tree_size

end

document pmap_member

Prints std::map or std::multimap information. Works for std::multimap as well.

Syntax: pmap : Prints map size, if T defined all elements or just element(s) with val(s)

Examples:

pmap_member m class1 member1 class2 member2 - prints class1.member1 : class2.member2

pmap_member m class1 member1 class2 member2 lvalue - prints class1.member1 : class2.member2 where class1 == lvalue

end

# std::set and std::multiset

define pset

if $argc == 0

help pset

else

set $tree = $arg0

set $i = 0

set $node = $tree._M_t._M_impl._M_header._M_left

set $end = $tree._M_t._M_impl._M_header

set $tree_size = $tree._M_t._M_impl._M_node_count

if $argc == 1

printf "Set "

whatis $tree

printf "Use pset to see the elements in the set.\n"

end

if $argc == 2

while $i < $tree_size

set $value = (void *)($node + 1)

printf "elem[%u]: ", $i

p *($arg1*)$value

if $node._M_right != 0

set $node = $node._M_right

while $node._M_left != 0

set $node = $node._M_left

end

else

set $tmp_node = $node._M_parent

while $node == $tmp_node._M_right

set $node = $tmp_node

set $tmp_node = $tmp_node._M_parent

end

if $node._M_right != $tmp_node

set $node = $tmp_node

end

set $i++

end

if $argc == 3

set $idx = $arg2

set $ElementsFound = 0

while $i < $tree_size

set $value = (void *)($node + 1)

if *($arg1*)$value == $idx

printf "elem[%u]: ", $i

p *($arg1*)$value

set $ElementsFound++

end

if $node._M_right != 0

set $node = $node._M_right

while $node._M_left != 0

set $node = $node._M_left

end

else

set $tmp_node = $node._M_parent

while $node == $tmp_node._M_right

set $node = $tmp_node

set $tmp_node = $tmp_node._M_parent

end

if $node._M_right != $tmp_node

set $node = $tmp_node

end

set $i++

end

printf "Number of elements found = %u\n", $ElementsFound

end

printf "Set size = %u\n", $tree_size

end

document pset

Prints std::set or std::multiset information. Works for std::multiset as well.

Syntax: pset : Prints set size, if T defined all elements or just element(s) having val

Examples:

pset s - prints set size and definition

pset s int - prints all elements and the size of s

pset s int 20 - prints the element(s) with value = 20 (if any) and the size of s

end

# std::dequeue

define pdequeue

if $argc == 0

help pdequeue

else

set $size = 0

set $start_cur = $arg0._M_impl._M_start._M_cur

set $start_last = $arg0._M_impl._M_start._M_last

set $start_stop = $start_last

while $start_cur != $start_stop

p *$start_cur

set $start_cur++

set $size++

end

set $finish_first = $arg0._M_impl._M_finish._M_first

set $finish_cur = $arg0._M_impl._M_finish._M_cur

set $finish_last = $arg0._M_impl._M_finish._M_last

if $finish_cur < $finish_last

set $finish_stop = $finish_cur

else

set $finish_stop = $finish_last

end

while $finish_first != $finish_stop

p *$finish_first

set $finish_first++

set $size++

end

printf "Dequeue size = %u\n", $size

end

document pdequeue

Prints std::dequeue information.

Syntax: pdequeue : Prints dequeue size, if T defined all elements

Deque elements are listed "left to right" (left-most stands for front and right-most stands for back)

Example:

pdequeue d - prints all elements and size of d

end

# std::stack

define pstack

if $argc == 0

help pstack

else

set $start_cur = $arg0.c._M_impl._M_start._M_cur

set $finish_cur = $arg0.c._M_impl._M_finish._M_cur

set $size = $finish_cur - $start_cur

set $i = $size - 1

while $i >= 0

p *($start_cur + $i)

set $i--

end

printf "Stack size = %u\n", $size

end

document pstack

Prints std::stack information.

Syntax: pstack : Prints all elements and size of the stack

Stack elements are listed "top to buttom" (top-most element is the first to come on pop)

Example:

pstack s - prints all elements and the size of s

end

# std::queue

define pqueue

if $argc == 0

help pqueue

else

set $start_cur = $arg0.c._M_impl._M_start._M_cur

set $finish_cur = $arg0.c._M_impl._M_finish._M_cur

set $size = $finish_cur - $start_cur

set $i = 0

while $i < $size

p *($start_cur + $i)

set $i++

end

printf "Queue size = %u\n", $size

end

document pqueue

Prints std::queue information.

Syntax: pqueue : Prints all elements and the size of the queue

Queue elements are listed "top to bottom" (top-most element is the first to come on pop)

Example:

pqueue q - prints all elements and the size of q

end

# std::priority_queue

define ppqueue

if $argc == 0

help ppqueue

else

set $size = $arg0.c._M_impl._M_finish - $arg0.c._M_impl._M_start

set $capacity = $arg0.c._M_impl._M_end_of_storage - $arg0.c._M_impl._M_start

set $i = $size - 1

while $i >= 0

p *($arg0.c._M_impl._M_start + $i)

set $i--

end

printf "Priority queue size = %u\n", $size

printf "Priority queue capacity = %u\n", $capacity

end

document ppqueue

Prints std::priority_queue information.

Syntax: ppqueue : Prints all elements, size and capacity of the priority_queue

Priority_queue elements are listed "top to buttom" (top-most element is the first to come on pop)

Example:

ppqueue pq - prints all elements, size and capacity of pq

end

# std::bitset

define pbitset

if $argc == 0

help pbitset

else

p /t $arg0._M_w

end

document pbitset

Prints std::bitset information.

Syntax: pbitset : Prints all bits in bitset

Example:

pbitset b - prints all bits in b

end

# std::string

define pstring

if $argc == 0

help pstring

else

printf "String \t\t\t= \"%s\"\n", $arg0._M_dataplus._M_p

printf "String size/length \t= %u\n", (((std::string::_Rep*) ($arg0._M_dataplus._M_p))[-1])._M_length

printf "String capacity \t= %u\n", (((std::string::_Rep*) ($arg0._M_dataplus._M_p))[-1])._M_capacity

printf "String ref-count \t= %d\n", (((std::string::_Rep*) ($arg0._M_dataplus._M_p))[-1])._M_refcount

#printf "String \t\t\t= \"%s\"\n", $arg0._M_data()

#printf "String size/length \t= %u\n", $arg0._M_rep()._M_length

#printf "String capacity \t= %u\n", $arg0._M_rep()._M_capacity

#printf "String ref-count \t= %d\n", $arg0._M_rep()._M_refcount

end

document pstring

Prints std::string information.

Syntax: pstring

Example:

pstring s - Prints content, size/length, capacity and ref-count of string s

end

# std::wstring

define pwstring

if $argc == 0

help pwstring

else

call printf("WString \t\t= \"%ls\"\n", $arg0._M_data())

printf "WString size/length \t= %u\n", $arg0._M_rep()._M_length

printf "WString capacity \t= %u\n", $arg0._M_rep()._M_capacity

printf "WString ref-count \t= %d\n", $arg0._M_rep()._M_refcount

end

document pwstring

Prints std::wstring information.

Syntax: pwstring

Example:

pwstring s - Prints content, size/length, capacity and ref-count of wstring s

end

# C++ related beautifiers (optional)

set print pretty on

set print object on

set print static-members on

set print vtbl on

set print demangle on

set demangle-style gnu-v3

set print sevenbit-strings off

so true 2012-11-07 17:51 发表评论

asm volatile GCC的内嵌汇编语法

so true — Tue, 01 May 2012 04:35:00 GMT

[Linux]__asm__ __volatile__ GCC的内嵌汇编语法 AT&T汇编语言语法（一）

2010-03-17 11:33

http://hi.baidu.com/hilyjiang/blog/item/7db5077a8180dbec2e73b380.html
http://blog.chinaunix.net/u3/93809/showart_1890394.html

开发一个OS，尽管绝大部分代码只需要用C/C++等高级语言就可以了，但至少和硬件相关部分的代码需要使用汇编语言，另外，由于启动部分的代码有大小限制，使用精练的汇编可以缩小目标代码的Size。另外，对于某些需要被经常调用的代码，使用汇编来写可以提高性能。所以我们必须了解汇编语言，即使你有可能并不喜欢它。

如果你是计算机专业的话，在大学里你应该学习过Intel格式的8086/80386汇编，这里就不再讨论。如果我们选择的OS开发工具是GCC以及GAS的话，就必须了解AT&T汇编语言语法，因为GCC/GAS只支持这种汇编语法。

本书不会去讨论8086/80386的汇编编程，这类的书籍很多，你可以参考它们。这里只会讨论AT&T的汇编语法，以及GCC的内嵌汇编语法。

--------------------------------------------------------------------------------

0.3.2 Syntax

1.寄存器引用

引用寄存器要在寄存器号前加百分号%,如“movl %eax, %ebx”。

80386有如下寄存器：

8个32-bit寄存器 %eax，%ebx，%ecx，%edx，%edi，%esi，%ebp，%esp；
8个16-bit寄存器，它们事实上是上面8个32-bit寄存器的低16位：%ax，%bx，%cx，%dx，%di，%si，%bp，%sp；
8个8-bit寄存器：%ah，%al，%bh，%bl，%ch，%cl，%dh，%dl。它们事实上是寄存器%ax，%bx，%cx，%dx的高8位和低8位；
6个段寄存器：%cs(code)，%ds(data)，%ss(stack), %es，%fs，%gs；
3个控制寄存器：%cr0，%cr2，%cr3；
6个debug寄存器：%db0，%db1，%db2，%db3，%db6，%db7；
2个测试寄存器：%tr6，%tr7；
8个浮点寄存器栈：%st(0)，%st(1)，%st(2)，%st(3)，%st(4)，%st(5)，%st(6)，%st(7)。
2. 操作数顺序

操作数排列是从源（左）到目的（右），如“movl %eax(源）, %ebx(目的）”

3. 立即数

使用立即数，要在数前面加符号$, 如“movl $0x04, %ebx”

或者：

para = 0x04

movl $para, %ebx

指令执行的结果是将立即数04h装入寄存器ebx。

4. 符号常数

符号常数直接引用如

value: .long 0x12a3f2de

movl value , %ebx

指令执行的结果是将常数0x12a3f2de装入寄存器ebx。

引用符号地址在符号前加符号$, 如“movl $value, % ebx”则是将符号value的地址装入寄存器ebx。

5. 操作数的长度

操作数的长度用加在指令后的符号表示b(byte, 8-bit), w(word, 16-bits), l(long, 32-bits)，如“movb %al, %bl”，“movw %ax, %bx”，“movl %eax, %ebx ”。

如果没有指定操作数长度的话，编译器将按照目标操作数的长度来设置。比如指令“mov %ax, %bx”，由于目标操作数bx的长度为word，那么编译器将把此指令等同于“movw %ax, %bx”。同样道理，指令“mov $4, %ebx”等同于指令“movl $4, %ebx”，“push %al”等同于“pushb %al”。对于没有指定操作数长度，但编译器又无法猜测的指令，编译器将会报错，比如指令“push $4”。

6. 符号扩展和零扩展指令

绝大多数面向80386的AT&T汇编指令与Intel格式的汇编指令都是相同的，符号扩展指令和零扩展指令则是仅有的不同格式指令。

符号扩展指令和零扩展指令需要指定源操作数长度和目的操作数长度，即使在某些指令中这些操作数是隐含的。

在AT& T语法中，符号扩展和零扩展指令的格式为，基本部分"movs"和"movz"（对应Intel语法的movsx和movzx），后面跟上源操作数长度和目的操作数长度。movsbl意味着movs （from）byte （to）long；movbw意味着movs （from）byte （to）word；movswl意味着movs （from）word （to）long。对于movz指令也一样。比如指令“movsbl %al, %edx”意味着将al寄存器的内容进行符号扩展后放置到edx寄存器中。

其它的Intel格式的符号扩展指令还有：

cbw -- sign-extend byte in %al to word in %ax；
cwde -- sign-extend word in %ax to long in %eax；
cwd -- sign-extend word in %ax to long in %dx:%ax；
cdq -- sign-extend dword in %eax to quad in %edx:%eax；
对应的AT&T语法的指令为cbtw，cwtl，cwtd，cltd。

7. 调用和跳转指令

段内调用和跳转指令为"call"，"ret"和"jmp"，段间调用和跳转指令为"lcall"，"lret"和"ljmp"。

段间调用和跳转指令的格式为“lcall/ljmp $SECTION, $OFFSET”，而段间返回指令则为“lret $STACK-ADJUST”。

8. 前缀

操作码前缀被用在下列的情况：

字符串重复操作指令(rep,repne)；
指定被操作的段(cs,ds,ss,es,fs,gs)；
进行总线加锁(lock)；
指定地址和操作的大小(data16,addr16)；
在AT&T汇编语法中，操作码前缀通常被单独放在一行，后面不跟任何操作数。例如，对于重复scas指令，其写法为：

repne
scas

上述操作码前缀的意义和用法如下：

指定被操作的段前缀为cs,ds,ss,es,fs,和gs。在AT&T语法中，只需要按照section:memory-operand的格式就指定了相应的段前缀。比如：lcall %cs:realmode_swtch
操作数／地址大小前缀是“data16”和"addr16"，它们被用来在32-bit操作数／地址代码中指定16-bit的操作数／地址。
总线加锁前缀“lock”，它是为了在多处理器环境中，保证在当前指令执行期间禁止一切中断。这个前缀仅仅对ADD, ADC, AND, BTC, BTR, BTS, CMPXCHG,DEC, INC, NEG, NOT, OR, SBB, SUB, XOR, XADD,XCHG指令有效，如果将Lock前缀用在其它指令之前，将会引起异常。
字符串重复操作前缀"rep","repe","repne"用来让字符串操作重复“%ecx”次。

9. 内存引用

Intel语法的间接内存引用的格式为：

section:[base+index*scale+displacement]

而在AT&T语法中对应的形式为：

section:displacement(base,index,scale)

其中，base和index是任意的32-bit base和index寄存器。scale可以取值1，2，4，8。如果不指定scale值，则默认值为1。section可以指定任意的段寄存器作为段前缀，默认的段寄存器在不同的情况下不一样。如果你在指令中指定了默认的段前缀，则编译器在目标代码中不会产生此段前缀代码。

下面是一些例子：

-4(%ebp)：base=%ebp，displacement=-4，section没有指定，由于base＝%ebp，所以默认的section=%ss，index,scale没有指定，则index为0。

foo(,%eax,4)：index=%eax，scale=4，displacement=foo。其它域没有指定。这里默认的section=%ds。

foo(,1)：这个表达式引用的是指针foo指向的地址所存放的值。注意这个表达式中没有base和index，并且只有一个逗号，这是一种异常语法，但却合法。

%gs:foo：这个表达式引用的是放置于%gs段里变量foo的值。

如果call和jump操作在操作数前指定前缀“*”，则表示是一个绝对地址调用/跳转，也就是说jmp/call指令指定的是一个绝对地址。如果没有指定"*"，则操作数是一个相对地址。

任何指令如果其操作数是一个内存操作，则指令必须指定它的操作尺寸(byte,word,long），也就是说必须带有指令后缀(b,w,l)。

.3 GCC Inline ASM

GCC 支持在C/C++代码中嵌入汇编代码，这些汇编代码被称作GCC Inline ASM——GCC内联汇编。这是一个非常有用的功能，有利于我们将一些C/C++语法无法表达的指令直接潜入C/C++代码中，另外也允许我们直接写 C/C++代码中使用汇编编写简洁高效的代码。

1.基本内联汇编

GCC中基本的内联汇编非常易懂，我们先来看两个简单的例子：

__asm__("movl %esp,%eax"); // 看起来很熟悉吧！

或者是

__asm__("
movl $1,%eax // SYS_exit
xor %ebx,%ebx
int $0x80
");

或

__asm__(
"movl $1,%eax\r\t" \
"xor %ebx,%ebx\r\t" \
"int $0x80" \
);

基本内联汇编的格式是

__asm__ __volatile__("Instruction List");

1、__asm__

__asm__是GCC关键字asm的宏定义：

#define __asm__ asm

__asm__或asm用来声明一个内联汇编表达式，所以任何一个内联汇编表达式都是以它开头的，是必不可少的。

2、Instruction List

Instruction List是汇编指令序列。它可以是空的，比如：__asm__ __volatile__(""); 或__asm__ ("");都是完全合法的内联汇编表达式，只不过这两条语句没有什么意义。但并非所有Instruction List为空的内联汇编表达式都是没有意义的，比如：__asm__ ("":::"memory"); 就非常有意义，它向GCC声明：“我对内存作了改动”，GCC在编译的时候，会将此因素考虑进去。

我们看一看下面这个例子：

$ cat example1.c

int main(int __argc, char* __argv[])
{
int* __p = (int*)__argc;

(*__p) = 9999;

//__asm__("":::"memory");

if((*__p) == 9999)
return 5;

return (*__p);
}

在这段代码中，那条内联汇编是被注释掉的。在这条内联汇编之前，内存指针__p所指向的内存被赋值为9999，随即在内联汇编之后，一条if语句判断__p 所指向的内存与9999是否相等。很明显，它们是相等的。GCC在优化编译的时候能够很聪明的发现这一点。我们使用下面的命令行对其进行编译：

$ gcc -O -S example1.c

选项-O表示优化编译，我们还可以指定优化等级，比如-O2表示优化等级为2；选项-S表示将C/C++源文件编译为汇编文件，文件名和C/C++文件一样，只不过扩展名由.c变为.s。

我们来查看一下被放在example1.s中的编译结果，我们这里仅仅列出了使用gcc 2.96在redhat 7.3上编译后的相关函数部分汇编代码。为了保持清晰性，无关的其它代码未被列出。

$ cat example1.s

main:
pushl %ebp
movl %esp, %ebp
movl 8(%ebp), %eax # int* __p = (int*)__argc
movl $9999, (%eax) # (*__p) = 9999
movl $5, %eax # return 5
popl %ebp
ret

参照一下C源码和编译出的汇编代码，我们会发现汇编代码中，没有if语句相关的代码，而是在赋值语句(*__p)=9999后直接return 5；这是因为GCC认为在(*__p)被赋值之后，在if语句之前没有任何改变(*__p)内容的操作，所以那条if语句的判断条件(*__p) == 9999肯定是为true的，所以GCC就不再生成相关代码，而是直接根据为true的条件生成return 5的汇编代码（GCC使用eax作为保存返回值的寄存器）。

我们现在将example1.c中内联汇编的注释去掉，重新编译，然后看一下相关的编译结果。

$ gcc -O -S example1.c

$ cat example1.s

main:
pushl %ebp
movl %esp, %ebp
movl 8(%ebp), %eax # int* __p = (int*)__argc
movl $9999, (%eax) # (*__p) = 9999
#APP

# __asm__("":::"memory")
#NO_APP
cmpl $9999, (%eax) # (*__p) == 9999 ?
jne .L3 # false
movl $5, %eax # true, return 5
jmp .L2
.p2align 2
.L3:
movl (%eax), %eax
.L2:
popl %ebp
ret

由于内联汇编语句__asm__("":::"memory")向GCC声明，在此内联汇编语句出现的位置内存内容可能了改变，所以GCC在编译时就不能像刚才那样处理。这次，GCC老老实实的将if语句生成了汇编代码。

可能有人会质疑：为什么要使用__asm__("":::"memory")向GCC声明内存发生了变化？明明“Instruction List”是空的，没有任何对内存的操作，这样做只会增加GCC生成汇编代码的数量。

确实，那条内联汇编语句没有对内存作任何操作，事实上它确实什么都没有做。但影响内存内容的不仅仅是你当前正在运行的程序。比如，如果你现在正在操作的内存是一块内存映射，映射的内容是外围I/O设备寄存器。那么操作这块内存的就不仅仅是当前的程序，I/O设备也会去操作这块内存。既然两者都会去操作同一块内存，那么任何一方在任何时候都不能对这块内存的内容想当然。所以当你使用高级语言C/C++写这类程序的时候，你必须让编译器也能够明白这一点，毕竟高级语言最终要被编译为汇编代码。

你可能已经注意到了，这次输出的汇编结果中，有两个符号：#APP和#NO_APP，GCC将内联汇编语句中"Instruction List"所列出的指令放在#APP和#NO_APP之间，由于__asm__("":::"memory")中“Instruction List”为空，所以#APP和#NO_APP中间也没有任何内容。但我们以后的例子会更加清楚的表现这一点。

关于为什么内联汇编__asm__("":::"memory")是一条声明内存改变的语句，我们后面会详细讨论。

刚才我们花了大量的内容来讨论"Instruction List"为空是的情况，但在实际的编程中，"Instruction List"绝大多数情况下都不是空的。它可以有1条或任意多条汇编指令。

当在"Instruction List"中有多条指令的时候，你可以在一对引号中列出全部指令，也可以将一条或几条指令放在一对引号中，所有指令放在多对引号中。如果是前者，你可以将每一条指令放在一行，如果要将多条指令放在一行，则必须用分号（；）或换行符（\n，大多数情况下\n后还要跟一个\t，其中\n是为了换行，\t是为了空出一个tab宽度的空格）将它们分开。比如：

__asm__("movl %eax, %ebx
sti
popl %edi
subl %ecx, %ebx");

__asm__("movl %eax, %ebx; sti
popl %edi; subl %ecx, %ebx");

__asm__("movl %eax, %ebx; sti\n\t popl %edi
subl %ecx, %ebx");

都是合法的写法。如果你将指令放在多对引号中，则除了最后一对引号之外，前面的所有引号里的最后一条指令之后都要有一个分号(；)或(\n)或(\n\t)。比如：

__asm__("movl %eax, %ebx
sti\n"
"popl %edi;"
"subl %ecx, %ebx");

__asm__("movl %eax, %ebx; sti\n\t"
"popl %edi; subl %ecx, %ebx");

__asm__("movl %eax, %ebx; sti\n\t popl %edi\n"
"subl %ecx, %ebx");

__asm__("movl %eax, %ebx; sti\n\t popl %edi;" "subl %ecx, %ebx");

都是合法的。

上述原则可以归结为：

任意两个指令间要么被分号(；)分开，要么被放在两行；
放在两行的方法既可以从通过\n的方法来实现，也可以真正的放在两行；
可以使用1对或多对引号，每1对引号里可以放任一多条指令，所有的指令都要被放到引号中。
在基本内联汇编中，“Instruction List”的书写的格式和你直接在汇编文件中写非内联汇编没有什么不同，你可以在其中定义Label，定义对齐(.align n )，定义段(.section name )。例如：

__asm__(".align 2\n\t"
"movl %eax, %ebx\n\t"
"test %ebx, %ecx\n\t"
"jne error\n\t"
"sti\n\t"
"error: popl %edi\n\t"
"subl %ecx, %ebx");

上面例子的格式是Linux内联代码常用的格式，非常整齐。也建议大家都使用这种格式来写内联汇编代码。

3、__volatile__

__volatile__是GCC关键字volatile的宏定义：

#define __volatile__ volatile

__volatile__ 或volatile是可选的，你可以用它也可以不用它。如果你用了它，则是向GCC声明“不要动我所写的Instruction List，我需要原封不动的保留每一条指令”，否则当你使用了优化选项(-O)进行编译时，GCC将会根据自己的判断决定是否将这个内联汇编表达式中的指令优化掉。

那么GCC判断的原则是什么？我不知道（如果有哪位朋友清楚的话，请告诉我）。我试验了一下，发现一条内联汇编语句如果是基本内联汇编的话（即只有“Instruction List”，没有Input/Output/Clobber的内联汇编，我们后面将会讨论这一点），无论你是否使用__volatile__来修饰， GCC 2.96在优化编译时，都会原封不动的保留内联汇编中的“Instruction List”。但或许我的试验的例子并不充分，所以这一点并不能够得到保证。

为了保险起见，如果你不想让GCC的优化影响你的内联汇编代码，你最好在前面都加上__volatile__，而不要依赖于编译器的原则，因为即使你非常了解当前编译器的优化原则，你也无法保证这种原则将来不会发生变化。而__volatile__的含义却是恒定的。

2、带有C/C++表达式的内联汇编

GCC允许你通过C/C++表达式指定内联汇编中"Instrcuction List"中指令的输入和输出，你甚至可以不关心到底使用哪个寄存器被使用，完全靠GCC来安排和指定。这一点可以让程序员避免去考虑有限的寄存器的使用，也可以提高目标代码的效率。

我们先来看几个例子：

__asm__ (" " : : : "memory" ); // 前面提到的

__asm__ ("mov %%eax, %%ebx" : "=b"(rv) : "a"(foo) : "eax", "ebx");

__asm__ __volatile__("lidt %0": "=m" (idt_descr));

__asm__("subl %2,%0\n\t"
"sbbl %3,%1"
: "=a" (endlow), "=d" (endhigh)
: "g" (startlow), "g" (starthigh), "0" (endlow), "1" (endhigh));

怎么样，有点印象了吧，是不是也有点晕？没关系，下面讨论完之后你就不会再晕了。（当然，也有可能更晕^_^）。讨论开始——

带有C/C++表达式的内联汇编格式为：

__asm__　__volatile__("Instruction List" : Output : Input : Clobber/Modify);

从中我们可以看出它和基本内联汇编的不同之处在于：它多了3个部分(Input，Output，Clobber/Modify)。在括号中的4个部分通过冒号(:)分开。

这4个部分都不是必须的，任何一个部分都可以为空，其规则为：

如果Clobber/Modify为空，则其前面的冒号(:)必须省略。比如__asm__("mov %%eax, %%ebx" : "=b"(foo) : "a"(inp) : )就是非法的写法；而__asm__("mov %%eax, %%ebx" : "=b"(foo) : "a"(inp) )则是正确的。
如果Instruction List为空，则Input，Output，Clobber/Modify可以不为空，也可以为空。比如__asm__ ( " " : : : "memory" );和__asm__(" " : : );都是合法的写法。
如果Output，Input，Clobber/Modify都为空，Output，Input之前的冒号(:)既可以省略，也可以不省略。如果都省略，则此汇编退化为一个基本内联汇编，否则，仍然是一个带有C/C++表达式的内联汇编，此时"Instruction List"中的寄存器写法要遵守相关规定，比如寄存器前必须使用两个百分号(%%)，而不是像基本汇编格式一样在寄存器前只使用一个百分号(%)。比如 __asm__( " mov %%eax, %%ebx" : : )；__asm__( " mov %%eax, %%ebx" : )和__asm__( " mov %eax, %ebx" )都是正确的写法，而__asm__( " mov %eax, %ebx" : : )；__asm__( " mov %eax, %ebx" : )和__asm__( " mov %%eax, %%ebx" )都是错误的写法。
如果Input，Clobber/Modify为空，但Output不为空，Input前的冒号(:)既可以省略，也可以不省略。比如 __asm__( " mov %%eax, %%ebx" : "=b"(foo) : )；__asm__( " mov %%eax, %%ebx" : "=b"(foo) )都是正确的。
如果后面的部分不为空，而前面的部分为空，则前面的冒号(:)都必须保留，否则无法说明不为空的部分究竟是第几部分。比如， Clobber/Modify，Output为空，而Input不为空，则Clobber/Modify前的冒号必须省略（前面的规则），而Output 前的冒号必须为保留。如果Clobber/Modify不为空，而Input和Output都为空，则Input和Output前的冒号都必须保留。比如 __asm__( " mov %%eax, %%ebx" : : "a"(foo) )和__asm__( " mov %%eax, %%ebx" : : : "ebx" )。
从上面的规则可以看到另外一个事实，区分一个内联汇编是基本格式的还是带有C/C++表达式格式的，其规则在于在"Instruction List"后是否有冒号(:)的存在，如果没有则是基本格式的，否则，则是带有C/C++表达式格式的。

两种格式对寄存器语法的要求不同：基本格式要求寄存器前只能使用一个百分号(%)，这一点和非内联汇编相同；而带有C/C++表达式格式则要求寄存器前必须使用两个百分号(%%)，其原因我们会在后面讨论。

1. Output

Output用来指定当前内联汇编语句的输出。我们看一看这个例子：

__asm__("movl %%cr0, %0": "=a" (cr0));

这个内联汇编语句的输出部分为"=r"(cr0)，它是一个“操作表达式”，指定了一个输出操作。我们可以很清楚得看到这个输出操作由两部分组成：括号括住的部分(cr0)和引号引住的部分"=a"。这两部分都是每一个输出操作必不可少的。括号括住的部分是一个C/C++表达式，用来保存内联汇编的一个输出值，其操作就等于C/C++的相等赋值cr0 = output_value，因此，括号中的输出表达式只能是C/C++的左值表达式，也就是说它只能是一个可以合法的放在C/C++赋值操作中等号(=) 左边的表达式。那么右值output_value从何而来呢？

答案是引号中的内容，被称作“操作约束”（Operation Constraint），在这个例子中操作约束为"=a"，它包含两个约束：等号(=)和字母a，其中等号(=)说明括号中左值表达式cr0是一个 Write-Only的，只能够被作为当前内联汇编的输入，而不能作为输入。而字母a是寄存器EAX / AX / AL的简写，说明cr0的值要从eax寄存器中获取，也就是说cr0 = eax，最终这一点被转化成汇编指令就是movl %eax, address_of_cr0。现在你应该清楚了吧，操作约束中会给出：到底从哪个寄存器传递值给cr0。

另外，需要特别说明的是，很多文档都声明，所有输出操作的操作约束必须包含一个等号(=)，但GCC的文档中却很清楚的声明，并非如此。因为等号(=)约束说明当前的表达式是一个 Write-Only的，但另外还有一个符号——加号(+)用来说明当前表达式是一个Read-Write的，如果一个操作约束中没有给出这两个符号中的任何一个，则说明当前表达式是Read-Only的。因为对于输出操作来说，肯定是必须是可写的，而等号(=)和加号(+)都表示可写，只不过加号(+) 同时也表示是可读的。所以对于一个输出操作来说，其操作约束只需要有等号(=)或加号(+)中的任意一个就可以了。

二者的区别是：等号(=)表示当前操作表达式指定了一个纯粹的输出操作，而加号(+)则表示当前操作表达式不仅仅只是一个输出操作还是一个输入操作。但无论是等号(=)约束还是加号(+)约束所约束的操作表达式都只能放在Output域中，而不能被用在Input域中。

另外，有些文档声明：尽管GCC文档中提供了加号(+)约束，但在实际的编译中通不过；我不知道老版本会怎么样，我在GCC 2.96中对加号(+)约束的使用非常正常。

我们通过一个例子看一下，在一个输出操作中使用等号(=)约束和加号(+)约束的不同。

$ cat example2.c

int main(int __argc, char* __argv[])
{
int cr0 = 5;

__asm__ __volatile__("movl %%cr0, %0":"=a" (cr0));

return 0;
}

$ gcc -S example2.c

$ cat example2.s

main:
pushl %ebp
movl %esp, %ebp
subl $4, %esp
movl $5, -4(%ebp) # cr0 = 5
#APP
movl %cr0, %eax
#NO_APP
movl %eax, %eax
movl %eax, -4(%ebp) # cr0 = %eax
movl $0, %eax
leave
ret

这个例子是使用等号(=)约束的情况，变量cr0被放在内存-4(%ebp)的位置，所以指令mov %eax, -4(%ebp)即表示将%eax的内容输出到变量cr0中。

下面是使用加号(+)约束的情况：

$ cat example3.c

int main(int __argc, char* __argv[])
{
int cr0 = 5;

__asm__ __volatile__("movl %%cr0, %0" : "+a" (cr0));

return 0;
}

$ gcc -S example3.c

$ cat example3.s

main:
pushl %ebp
movl %esp, %ebp
subl $4, %esp
movl $5, -4(%ebp) # cr0 = 5
movl -4(%ebp), %eax # input ( %eax = cr0 )
#APP
movl %cr0, %eax
#NO_APP
movl %eax, -4(%ebp) # output (cr0 = %eax )
movl $0, %eax
leave
ret

从编译的结果可以看出，当使用加号(+)约束的时候，cr0不仅作为输出，还作为输入，所使用寄存器都是寄存器约束(字母a，表示使用eax寄存器)指定的。关于寄存器约束我们后面讨论。

在Output域中可以有多个输出操作表达式，多个操作表达式中间必须用逗号(,)分开。例如：

__asm__(
"movl %%eax, %0 \n\t"
"pushl %%ebx \n\t"
"popl %1 \n\t"
"movl %1, %2"
: "+a"(cr0), "=b"(cr1), "=c"(cr2));

2、Input

Input域的内容用来指定当前内联汇编语句的输入。我们看一看这个例子：

__asm__("movl %0, %%db7" : : "a" (cpu->db7));

例中Input域的内容为一个表达式"a"[cpu->db7)，被称作“输入表达式”，用来表示一个对当前内联汇编的输入。

像输出表达式一样，一个输入表达式也分为两部分：带括号的部分(cpu->db7)和带引号的部分"a"。这两部分对于一个内联汇编输入表达式来说也是必不可少的。

括号中的表达式cpu->db7是一个C/C++语言的表达式，它不必是一个左值表达式，也就是说它不仅可以是放在C/C++赋值操作左边的表达式，还可以是放在C/C++赋值操作右边的表达式。所以它可以是一个变量，一个数字，还可以是一个复杂的表达式（比如a+b/c*d）。比如上例可以改为： __asm__("movl %0, %%db7" : : "a" (foo))，__asm__("movl %0, %%db7" : : "a" (0x1000))或__asm__("movl %0, %%db7" : : "a" (va*vb/vc))。

引号号中的部分是约束部分，和输出表达式约束不同的是，它不允许指定加号(+)约束和等号(=)约束，也就是说它只能是默认的Read-Only的。约束中必须指定一个寄存器约束，例中的字母a表示当前输入变量cpu->db7要通过寄存器eax输入到当前内联汇编中。

我们看一个例子：

$ cat example4.c

int main(int __argc, char* __argv[])
{
int cr0 = 5;

__asm__ __volatile__("movl %0, %%cr0"::"a" (cr0));

return 0;
}

$ gcc -S example4.c

$ cat example4.s

main:
pushl %ebp
movl %esp, %ebp
subl $4, %esp
movl $5, -4(%ebp) # cr0 = 5
movl -4(%ebp), %eax # %eax = cr0
#APP
movl %eax, %cr0
#NO_APP
movl $0, %eax
leave
ret

我们从编译出的汇编代码可以看到，在"Instruction List"之前，GCC按照我们的输入约束"a"，将变量cr0的内容装入了eax寄存器。

3. Operation Constraint

每一个Input和Output表达式都必须指定自己的操作约束Operation Constraint，我们这里来讨论在80386平台上所可能使用的操作约束。

1、寄存器约束

当你当前的输入或输入需要借助一个寄存器时，你需要为其指定一个寄存器约束。你可以直接指定一个寄存器的名字，比如：

__asm__ __volatile__("movl %0, %%cr0"::"eax" (cr0));

也可以指定一个缩写，比如：

__asm__ __volatile__("movl %0, %%cr0"::"a" (cr0));

如果你指定一个缩写，比如字母a，则GCC将会根据当前操作表达式中C/C++表达式的宽度决定使用%eax，还是%ax或%al。比如：

unsigned short __shrt;

__asm__ ("mov %0，%%bx" : : "a"(__shrt));

由于变量__shrt是16-bit short类型，则编译出来的汇编代码中，则会让此变量使用%ex寄存器。编译结果为：

movw -2(%ebp), %ax # %ax = __shrt
#APP
movl %ax, %bx
#NO_APP

无论是Input，还是Output操作表达式约束，都可以使用寄存器约束。

下表中列出了常用的寄存器约束的缩写。

约束 Input/Output 意义
r I,O 表示使用一个通用寄存器，由GCC在%eax/%ax/%al, %ebx/%bx/%bl, %ecx/%cx/%cl, %edx/%dx/%dl中选取一个GCC认为合适的。
q I,O 表示使用一个通用寄存器，和r的意义相同。
a I,O 表示使用%eax / %ax / %al
b I,O 表示使用%ebx / %bx / %bl
c I,O 表示使用%ecx / %cx / %cl
d I,O 表示使用%edx / %dx / %dl
D I,O 表示使用%edi / %di
S I,O 表示使用%esi / %si
f I,O 表示使用浮点寄存器
t I,O 表示使用第一个浮点寄存器
u I,O 表示使用第二个浮点寄存器

2、内存约束
如果一个Input/Output操作表达式的C/C++表达式表现为一个内存地址，不想借助于任何寄存器，则可以使用内存约束。比如：

__asm__ ("lidt %0" : "=m"(__idt_addr)); 或 __asm__ ("lidt %0" : :"m"(__idt_addr));

我们看一下它们分别被放在一个C源文件中，然后被GCC编译后的结果：

$ cat example5.c

// 本例中，变量sh被作为一个内存输入

int main(int __argc, char* __argv[])
{
char* sh = (char*)&__argc;

__asm__ __volatile__("lidt %0" : : "m" (sh));

return 0;
}

$ gcc -S example5.c

$ cat example5.s

main:
pushl %ebp
movl %esp, %ebp
subl $4, %esp
leal 8(%ebp), %eax
movl %eax, -4(%ebp) # sh = (char*) &__argc
#APP
lidt -4(%ebp)
#NO_APP
movl $0, %eax
leave
ret

$ cat example6.c

// 本例中，变量sh被作为一个内存输出

int main(int __argc, char* __argv[])
{
char* sh = (char*)&__argc;

__asm__ __volatile__("lidt %0" : "=m" (sh));

return 0;
}

$ gcc -S example6.c

$ cat example6.s

main:
pushl %ebp
movl %esp, %ebp
subl $4, %esp
leal 8(%ebp), %eax
movl %eax, -4(%ebp) # sh = (char*) &__argc
#APP
lidt -4(%ebp)
#NO_APP
movl $0, %eax
leave
ret
首先，你会注意到，在这两个例子中，变量sh没有借助任何寄存器，而是直接参与了指令lidt的操作。

其次，通过仔细观察，你会发现一个惊人的事实，两个例子编译出来的汇编代码是一样的！虽然，一个例子中变量sh作为输入，而另一个例子中变量sh作为输出。这是怎么回事？

原来，使用内存方式进行输入输出时，由于不借助寄存器，所以GCC不会按照你的声明对其作任何的输入输出处理。GCC只会直接拿来用，究竟对这个C/C++表达式而言是输入还是输出，完全依赖与你写在"Instruction List"中的指令对其操作的指令。

由于上例中，对其操作的指令为lidt，lidt指令的操作数是一个输入型的操作数，所以事实上对变量sh的操作是一个输入操作，即使你把它放在 Output域也不会改变这一点。所以，对此例而言，完全符合语意的写法应该是将sh放在Input域，尽管放在Output域也会有正确的执行结果。

所以，对于内存约束类型的操作表达式而言，放在Input域还是放在Output域，对编译结果是没有任何影响的，因为本来我们将一个操作表达式放在 Input域或放在Output域是希望GCC能为我们自动通过寄存器将表达式的值输入或输出。既然对于内存约束类型的操作表达式来说，GCC不会自动为它做任何事情，那么放在哪儿也就无所谓了。但从程序员的角度而言，为了增强代码的可读性，最好能够把它放在符合实际情况的地方。

约束 Input/Output 意义
m I,O 表示使用系统所支持的任何一种内存方式，不需要借助寄存器

[Linux]__asm__ __volatile__ GCC的内嵌汇编语法 AT&T汇编语言语法（二）

2010-03-17 11:35

http://hi.baidu.com/hilyjiang/blog/item/2254e62afd6db42cd42af180.html

3、立即数约束

如果一个Input/Output操作表达式的C/C++表达式是一个数字常数，不想借助于任何寄存器，则可以使用立即数约束。

由于立即数在C/C++中只能作为右值，所以对于使用立即数约束的表达式而言，只能放在Input域。

比如：__asm__ __volatile__("movl %0, %%eax" : : "i" (100) );

立即数约束很简单，也很容易理解，我们在这里就不再赘述。

约束 Input/Output 意义
i I 表示输入表达式是一个立即数(整数)，不需要借助任何寄存器
F I 表示输入表达式是一个立即数(浮点数)，不需要借助任何寄存器

4、通用约束

约束 Input/Output 意义
g I,O 表示可以使用通用寄存器，内存，立即数等任何一种处理方式。
0,1,2,3,4,5,6,7,8,9 I 表示和第n个操作表达式使用相同的寄存器/内存。

通用约束g是一个非常灵活的约束，当程序员认为一个C/C++表达式在实际的操作中，究竟使用寄存器方式，还是使用内存方式或立即数方式并无所谓时，或者程序员想实现一个灵活的模板，让GCC可以根据不同的C/C++表达式生成不同的访问方式时，就可以使用通用约束g。比如：

#define JUST_MOV(foo) __asm__ ("movl %0, %%eax" : : "g"(foo))

JUST_MOV(100)和JUST_MOV(var)则会让编译器产生不同的代码。

int main(int __argc, char* __argv[])
{
JUST_MOV(100);

return 0;
}

编译后生成的代码为：

main:
pushl %ebp
movl %esp, %ebp
#APP
movl $100, %eax
#NO_APP
movl $0, %eax
popl %ebp
ret

很明显这是立即数方式。而下一个例子：

int main(int __argc, char* __argv[])
{
JUST_MOV(__argc);

return 0;
}

经编译后生成的代码为：

main:
pushl %ebp
movl %esp, %ebp
#APP
movl 8(%ebp), %eax
#NO_APP
movl $0, %eax
popl %ebp
ret

这个例子是使用内存方式。

一个带有C/C++表达式的内联汇编，其操作表达式被按照被列出的顺序编号，第一个是0，第2个是1，依次类推，GCC最多允许有10个操作表达式。比如：

__asm__ ("popl %0 \n\t"
"movl %1, %%esi \n\t"
"movl %2, %%edi \n\t"
: "=a"(__out)
: "r" (__in1), "r" (__in2));

此例中，__out所在的Output操作表达式被编号为0，"r"(__in1)被编号为1，"r"(__in2)被编号为2。

再如：

__asm__ ("movl %%eax, %%ebx" : : "a"(__in1), "b"(__in2));

此例中，"a"(__in1)被编号为0，"b"(__in2)被编号为1。

如果某个Input操作表达式使用数字0到9中的一个数字（假设为1）作为它的操作约束，则等于向GCC声明：“我要使用和编号为1的Output操作表达式相同的寄存器（如果Output操作表达式1使用的是寄存器），或相同的内存地址（如果Output操作表达式1使用的是内存）”。上面的描述包含两个限定：数字0到数字9作为操作约束只能用在Input操作表达式中，被指定的操作表达式（比如某个Input操作表达式使用数字1作为约束，那么被指定的就是编号为1的操作表达式）只能是Output操作表达式。

由于GCC规定最多只能有10个Input/Output操作表达式，所以事实上数字9作为操作约束永远也用不到，因为Output操作表达式排在Input操作表达式的前面，那么如果有一个Input操作表达式指定了数字9作为操作约束的话，那么说明Output操作表达式的数量已经至少为10个了，那么再加上这个Input操作表达式，则至少为11个了，以及超出GCC的限制。

5、Modifier Characters（修饰符）

等号(=)和加号(+)用于对Output操作表达式的修饰，一个Output操作表达式要么被等号(=)修饰，要么被加号(+)修饰，二者必居其一。使用等号(=)说明此Output操作表达式是Write- Only的，使用加号(+)说明此Output操作表达式是Read-Write的。它们必须被放在约束字符串的第一个字母。比如"a="(foo)是非法的，而"+g"(foo)则是合法的。

当使用加号(+)的时候，此Output表达式等价于使用等号(=)约束加上一个Input表达式。比如

__asm__ ("movl %0, %%eax; addl %%eax, %0" : "+b"(foo)) 等价于

__asm__ ("movl %1, %%eax; addl %%eax, %0" : "=b"(foo) : "b"(foo))

但如果使用后一种写法，"Instruction List"中的别名也要相应的改动。关于别名，我们后面会讨论。

像等号(=)和加号(+)修饰符一样，符号(&)也只能用于对Output操作表达式的修饰。当使用它进行修饰时，等于向GCC声明："GCC不得为任何Input操作表达式分配与此Output操作表达式相同的寄存器"。其原因是&修饰符意味着被其修饰的Output操作表达式要在所有的 Input操作表达式被输入前输出。我们看下面这个例子：

int main(int __argc, char* __argv[])
{
int __in1 = 8, __in2 = 4, __out = 3;

__asm__ ("popl %0 \n\t"
"movl %1, %%esi \n\t"
"movl %2, %%edi \n\t"
: "=a"(__out)
: "r" (__in1), "r" (__in2));

return 0;
}
此例中，%0对应的就是Output操作表达式，它被指定的寄存器是%eax，整个Instruction List的第一条指令popl %0，编译后就成为popl %eax，这时%eax的内容已经被修改，随后在Instruction List后，GCC会通过movl %eax, address_of_out这条指令将%eax的内容放置到Output变量__out中。对于本例中的两个Input操作表达式而言，它们的寄存器约束为"r"，即要求GCC为其指定合适的寄存器，然后在Instruction List之前将__in1和__in2的内容放入被选出的寄存器中，如果它们中的一个选择了已经被__out指定的寄存器%eax，假如是__in1，那么GCC在Instruction List之前会插入指令movl address_of_in1, %eax，那么随后popl %eax指令就修改了%eax的值，此时%eax中存放的已经不是Input变量__in1的值了，那么随后的movl %1, %%esi指令，将不会按照我们的本意——即将__in1的值放入%esi中——而是将__out的值放入%esi中了。
下面就是本例的编译结果，很明显，GCC为__in2选择了和__out相同的寄存器%eax，这与我们的初衷不符。

main:
pushl %ebp
movl %esp, %ebp
subl $12, %esp
movl $8, -4(%ebp)
movl $4, -8(%ebp)
movl $3, -12(%ebp)
movl -4(%ebp), %edx # __in1使用寄存器%edx
movl -8(%ebp), %eax # __in2使用寄存器%eax
#APP
popl %eax
movl %edx, %esi
movl %eax, %edi

#NO_APP
movl %eax, %eax
movl %eax, -12(%ebp) # __out使用寄存器%eax
movl $0, %eax
leave
ret

为了避免这种情况，我们必须向GCC声明这一点，要求GCC为所有的Input操作表达式指定别的寄存器，方法就是在Output操作表达式"=a" (__out)的操作约束中加入&约束，由于GCC规定等号(=)约束必须放在第一个，所以我们写作"=&a"(__out)。
下面是我们将&约束加入之后编译的结果：
main:
pushl %ebp
movl %esp, %ebp
subl $12, %esp
movl $8, -4(%ebp)
movl $4, -8(%ebp)
movl $3, -12(%ebp)
movl -4(%ebp), %edx #__in1使用寄存器%edx
movl -8(%ebp), %eax
movl %eax, %ecx # __in2使用寄存器%ecx
#APP
popl %eax
movl %edx, %esi
movl %ecx, %edi

#NO_APP
movl %eax, %eax
movl %eax, -12(%ebp) #__out使用寄存器%eax
movl $0, %eax
leave
ret

OK！这下好了，完全与我们的意图吻合。
如果一个Output操作表达式的寄存器约束被指定为某个寄存器，只有当至少存在一个Input操作表达式的寄存器约束为可选约束时，（可选约束的意思是可以从多个寄存器中选取一个，或使用非寄存器方式），比如"r"或"g"时，此Output操作表达式使用&修饰才有意义。如果你为所有的 Input操作表达式指定了固定的寄存器，或使用内存/立即数约束，则此Output操作表达式使用&修饰没有任何意义。比如：

__asm__ ("popl %0 \n\t"
"movl %1, %%esi \n\t"
"movl %2, %%edi \n\t"
: "=&a"(__out)
: "m" (__in1), "c" (__in2));

此例中的Output操作表达式完全没有必要使用&来修饰，因为__in1和__in2都被指定了固定的寄存器，或使用了内存方式，GCC无从选择。

但如果你已经为某个Output操作表达式指定了&修饰，并指定了某个固定的寄存器，你就不能再为任何Input操作表达式指定这个寄存器，否则会出现编译错误。比如：

__asm__ ("popl %0 \n\t"
"movl %1, %%esi \n\t"
"movl %2, %%edi \n\t"
: "=&a"(__out)
: "a" (__in1), "c" (__in2));

本例中，由于__out已经指定了寄存器%eax，同时使用了符号&修饰，则再为__in1指定寄存器%eax就是非法的。

反过来，你也可以为Output指定可选约束，比如"r","g"等，让GCC为其选择到底使用哪个寄存器，还是使用内存方式，GCC在选择的时候，会首先排除掉已经被Input操作表达式使用的所有寄存器，然后在剩下的寄存器中选择，或干脆使用内存方式。比如：

__asm__ ("popl %0 \n\t"
"movl %1, %%esi \n\t"
"movl %2, %%edi \n\t"
: "=&r"(__out)
: "a" (__in1), "c" (__in2));

本例中，由于__out指定了约束"r"，即让GCC为其决定使用哪一格寄存器，而寄存器%eax和%ecx已经被__in1和__in2使用，那么GCC在为__out选择的时候，只会在%ebx和%edx中选择。

前3 个修饰符只能用在Output操作表达式中，而百分号[%]修饰符恰恰相反，只能用在Input操作表达式中，用于向GCC声明：“当前Input操作表达式中的C/C++表达式可以和下一个Input操作表达式中的C/C++表达式互换”。这个修饰符号一般用于符合交换律运算，比如加(+)，乘(*)，与(&)，或(|)等等。我们看一个例子：

int main(int __argc, char* __argv[])
{
int __in1 = 8, __in2 = 4, __out = 3;

__asm__ ("addl %1, %0\n\t"
: "=r"(__out)
: "%r" (__in1), "0" (__in2));

return 0;
}
在此例中，由于指令是一个加法运算，相当于等式__out = __in1 + __in2，而它与等式__out = __in2 + __in1没有什么不同。所以使用百分号修饰，让GCC知道__in1和__in2可以互换，也就是说GCC可以自动将本例的内联汇编改变为：

__asm__ ("addl %1, %0\n\t"
: "=r"(__out)
: "%r" (__in2), "0" (__in1));

修饰符 Input/Output 意义
= O 表示此Output操作表达式是Write-Only的
+ O 表示此Output操作表达式是Read-Write的
& O 表示此Output操作表达式独占为其指定的寄存器
% I 表示此Input操作表达式中的C/C++表达式可以和下一个Input操作表达式中的C/C++表达式互换

4. 占位符

什么叫占位符？我们看一看下面这个例子：

__asm__ ("addl %1, %0\n\t"
: "=a"(__out)
: "m" (__in1), "a" (__in2));

这个例子中的%0和%1就是占位符。每一个占位符对应一个Input/Output操作表达式。我们在之前已经提到，GCC规定一个内联汇编语句最多可以有 10个Input/Output操作表达式，然后按照它们被列出的顺序依次赋予编号0到9。对于占位符中的数字而言，和这些编号是对应的。

由于占位符前面使用一个百分号(%)，为了区别占位符和寄存器，GCC规定在带有C/C++表达式的内联汇编中，"Instruction List"中直接写出的寄存器前必须使用两个百分号(%%)。

GCC 对其进行编译的时候，会将每一个占位符替换为对应的Input/Output操作表达式所指定的寄存器/内存地址/立即数。比如在上例中，占位符%0对应 Output操作表达式"=a"(__out)，而"=a"(__out)指定的寄存器为%eax，所以把占位符%0替换为%eax，占位符%1对应 Input操作表达式"m"(__in1)，而"m"(__in1)被指定为内存操作，所以把占位符%1替换为变量__in1的内存地址。

也许有人认为，在上面这个例子中，完全可以不使用%0，而是直接写%%eax，就像这样：

__asm__ ("addl %1, %%eax\n\t"
: "=a"(__out)
: "m" (__in1), "a" (__in2));

和上面使用占位符%0没有什么不同，那么使用占位符%0就没有什么意义。确实，两者生成的代码完全相同，但这并不意味着这种情况下占位符没有意义。因为如果不使用占位符，那么当有一天你想把变量__out的寄存器约束由a改为b时，那么你也必须将addl指令中的%%eax改为%%ebx，也就是说你需要同时修改两个地方，而如果你使用占位符，你只需要修改一次就够了。另外，如果你不使用占位符，将不利于代码的清晰性。在上例中，如果你使用占位符，那么你一眼就可以得知，addl指令的第二个操作数内容最终会输出到变量__out中；否则，如果你不用占位符，而是直接将addl指令的第2个操作数写为%% eax，那么你需要考虑一下才知道它最终需要输出到变量__out中。这是占位符最粗浅的意义。毕竟在这种情况下，你完全可以不用。

但对于这些情况来说，不用占位符就完全不行了：

首先，我们看一看上例中的第1个Input操作表达式"m"(__in1)，它被GCC替换之后，表现为addl address_of_in1, %%eax，__in1的地址是什么？编译时才知道。所以我们完全无法直接在指令中去写出__in1的地址，这时使用占位符，交给GCC在编译时进行替代，就可以解决这个问题。所以这种情况下，我们必须使用占位符。

其次，如果上例中的Output操作表达式"=a"(__out)改为" =r"(__out)，那么__out在究竟使用那么寄存器只有到编译时才能通过GCC来决定，既然在我们写代码的时候，我们不知道究竟哪个寄存器被选择，我们也就不能直接在指令中写出寄存器的名称，而只能通过占位符替代来解决。

5. Clobber/Modify

有时候，你想通知GCC当前内联汇编语句可能会对某些寄存器或内存进行修改，希望GCC在编译时能够将这一点考虑进去。那么你就可以在Clobber/Modify域声明这些寄存器或内存。

这种情况一般发生在一个寄存器出现在"Instruction List"，但却不是由Input/Output操作表达式所指定的，也不是在一些Input/Output操作表达式使用"r","g"约束时由GCC 为其选择的，同时此寄存器被"Instruction List"中的指令修改，而这个寄存器只是供当前内联汇编临时使用的情况。比如：

__asm__ ("movl %0, %%ebx" : : "a"(__foo) : "bx");

寄存器%ebx出现在"Instruction List中"，并且被movl指令修改，但却未被任何Input/Output操作表达式指定，所以你需要在Clobber/Modify域指定"bx"，以让GCC知道这一点。

因为你在Input/Output操作表达式所指定的寄存器，或当你为一些Input/Output操作表达式使用"r","g"约束，让GCC为你选择一个寄存器时，GCC对这些寄存器是非常清楚的——它知道这些寄存器是被修改的，你根本不需要在Clobber/Modify域再声明它们。但除此之外， GCC对剩下的寄存器中哪些会被当前的内联汇编修改一无所知。所以如果你真的在当前内联汇编指令中修改了它们，那么就最好在Clobber/Modify 中声明它们，让GCC针对这些寄存器做相应的处理。否则有可能会造成寄存器的不一致，从而造成程序执行错误。

在Clobber/Modify域中指定这些寄存器的方法很简单，你只需要将寄存器的名字使用双引号(" ")引起来。如果有多个寄存器需要声明，你需要在任意两个声明之间用逗号隔开。比如：

__asm__ ("movl %0, %%ebx; popl %%ecx" : : "a"(__foo) : "bx", "cx" );

这些串包括：

声明的串代表的寄存器
"al","ax","eax" %eax
"bl","bx","ebx" %ebx
"cl","cx","ecx" %ecx
"dl","dx","edx" %edx
"si","esi" %esi
"di", "edi" %edi

由上表可以看出，你只需要使用"ax","bx","cx","dx","si","di"就可以了，因为其它的都和它们中的一个是等价的。

如果你在一个内联汇编语句的Clobber/Modify域向GCC声明某个寄存器内容发生了改变，GCC在编译时，如果发现这个被声明的寄存器的内容在此内联汇编语句之后还要继续使用，那么GCC会首先将此寄存器的内容保存起来，然后在此内联汇编语句的相关生成代码之后，再将其内容恢复。我们来看两个例子，然后对比一下它们之间的区别。

这个例子中声明了寄存器%ebx内容发生了改变：

$ cat example7.c

int main(int __argc, char* __argv[])
{
int in = 8;

__asm__ ("addl %0, %%ebx"
: /* no output */
: "a" (in) : "bx");

return 0;
}

$ gcc -O -S example7.c

$ cat example7.s

main:
pushl %ebp
movl %esp, %ebp
pushl %ebx # %ebx内容被保存
movl $8, %eax
#APP
addl %eax, %ebx
#NO_APP
movl $0, %eax
movl (%esp), %ebx # %ebx内容被恢复
leave
ret

下面这个例子的C源码与上一个例子除了没有声明%ebx寄存器发生了改变之外，其它都相同。

$ cat example8.c

int main(int __argc, char* __argv[])
{
int in = 8;

__asm__ ("addl %0, %%ebx"
: /* no output */
: "a" (in) );

return 0;
}

$ gcc -O -S example8.c

$ cat example8.s

main:
pushl %ebp
movl %esp, %ebp
movl $8, %eax
#APP
addl %eax, %ebx
#NO_APP
movl $0, %eax
popl %ebp
ret

仔细对比一下example7.s和example8.s，你就会明白在Clobber/Modify域声明一个寄存器的意义。

另外需要注意的是，如果你在Clobber/Modify域声明了一个寄存器，那么这个寄存器将不能再被用做当前内联汇编语句的Input/Output操作表达式的寄存器约束，如果Input/Output操作表达式的寄存器约束被指定为"r"或"g"，GCC也不会选择已经被声明在 Clobber/Modify中的寄存器。比如：

__asm__ ("movl %0, %%ebx" : : "a"(__foo) : "ax", "bx");

此例中，由于Output操作表达式"a"(__foo)的寄存器约束已经指定了%eax寄存器，那么再在Clobber/Modify域中指定"ax"就是非法的。编译时，GCC会给出编译错误。

除了寄存器的内容会被改变，内存的内容也可以被修改。如果一个内联汇编语句"Instruction List"中的指令对内存进行了修改，或者在此内联汇编出现的地方内存内容可能发生改变，而被改变的内存地址你没有在其Output操作表达式使用"m" 约束，这种情况下你需要使用在Clobber/Modify域使用字符串"memory"向GCC声明：“在这里，内存发生了，或可能发生了改变”。例如：

void * memset(void * s, char c, size_t count)
{
__asm__("cld\n\t"
"rep\n\t"
"stosb"
: /* no output */
: "a" (c),"D" (s),"c" (count)
: "cx","di","memory");
return s;
}

此例实现了标准函数库memset，其内联汇编中的stosb对内存进行了改动，而其被修改的内存地址s被指定装入%edi，没有任何Output操作表达式使用了"m"约束，以指定内存地址s处的内容发生了改变。所以在其Clobber/Modify域使用"memory"向GCC声明：内存内容发生了变动。

如果一个内联汇编语句的Clobber/Modify域存在"memory"，那么GCC会保证在此内联汇编之前，如果某个内存的内容被装入了寄存器，那么在这个内联汇编之后，如果需要使用这个内存处的内容，就会直接到这个内存处重新读取，而不是使用被存放在寄存器中的拷贝。因为这个时候寄存器中的拷贝已经很可能和内存处的内容不一致了。

这只是使用"memory"时，GCC会保证做到的一点，但这并不是全部。因为使用"memory"是向GCC声明内存发生了变化，而内存发生变化带来的影响并不止这一点。比如我们在前面讲到的例子：

int main(int __argc, char* __argv[])
{
int* __p = (int*)__argc;

(*__p) = 9999;

__asm__("":::"memory");

if((*__p) == 9999)
return 5;

return (*__p);
}

本例中，如果没有那条内联汇编语句，那个if语句的判断条件就完全是一句废话。GCC在优化时会意识到这一点，而直接只生成return 5的汇编代码，而不会再生成if语句的相关代码，而不会生成return (*__p)的相关代码。但你加上了这条内联汇编语句，它除了声明内存变化之外，什么都没有做。但GCC此时就不能简单的认为它不需要判断都知道 (*__p)一定与9999相等，它只有老老实实生成这条if语句的汇编代码，一起相关的两个return语句相关代码。

当一个内联汇编指令中包含影响eflags寄存器中的条件标志（也就是那些Jxx等跳转指令要参考的标志位，比如，进位标志，0标志等），那么需要在 Clobber/Modify域中使用"cc"来声明这一点。这些指令包括adc, div，popfl，btr，bts等等，另外，当包含call指令时，由于你不知道你所call的函数是否会修改条件标志，为了稳妥起见，最好也使用 "cc"。

我很少在相关资料中看到有关"cc"的确切用法，只有一份文档提到了它，但还不是i386平台的，只是说"cc"是处理器平台相关的，并非所有的平台都支持它，但即使在不支持它的平台上，使用它也不会造成编译错误。我做了一些实验，但发现使用"cc"和不使用"cc"所生成的代码没有任何不同。但Linux 2.4的相关代码中用到了它。如果谁知道在i386平台上"cc"的细节，请和我联系。

另外，还可以在 Clobber/Modify域指定数字0到9，以声明第n个Input/Output操作表达式所使用的寄存器发生了变化，但正如我们在前面所提到的，如果你为某个Input/Output操作表达式指定了寄存器，或使用"g","r"等约束让GCC为其选择寄存器，GCC已经知道哪个寄存器内容发生了变化，所以这么做没有什么意义；我也作了相关的试验，没有发现使用它会对GCC生成的汇编代码有任何影响，至少在i386平台上是这样。Linux 2.4的所有i386平台相关内联汇编代码中都没有使用这一点，但S390平台相关代码中有用到，但由于我对S390汇编没有任何概念，所以，也不知道这么做的意义何在。

so true 2012-05-01 12:35 发表评论

列出某目录下的所有目录并且可以自由控制深度的脚本

so true — Sat, 18 Jul 2009 08:44:00 GMT

#!/bin/bash

[ $# -gt 2 ] && {
    echo "Usage: ${0##*/} "
    exit 1
}

TOP=0
QUEUELIST[${#QUEUELIST[@]}]=`cd ${1:-.};pwd`
DEEPMAX=${2:-1}
DEEP=0
#The number of directories in the upper directory(DEEP-1)
X=1
#The number of directories in the next directory(DEEP+1)
Y=0
#The number of directories scanned in the current directory(DEEP)
Z=0
while [ $TOP -ne ${#QUEUELIST[@]} ]
do
    curdir=${QUEUELIST[$TOP]}
    cd $curdir
    ((TOP++))

    for list in `ls`
    do
        if [ -d $list ]
        then
            echo $curdir/$list
            QUEUELIST[${#QUEUELIST[@]}]=$curdir/$list
            ((Y++))
        fi
    done
    ((Z++))
    if [ $Z -eq $X ];then
        ((DEEP++))
        if [ $DEEP -eq $DEEPMAX ];then
            exit 0
        fi
        X=$Y
        Y=0
        Z=0
    fi
done

说明：其实用find就可以，只要指定-maxdepth即可，这里只为练练手

so true 2009-07-18 16:44 发表评论

Shell编程积累

so true — Mon, 15 Jun 2009 16:37:00 GMT

ls -lr反向排序结果
==============================
ls ${PATH//:/\ } | grep
==============================
echo $RANDOM
==============================
[[ $# -ne 3 ]] && {echo "Usage: ${0##.*/} "; exit 1}
==============================
awk '/'$VAR'/{print $0}' file
==============================
#得到绝对路径
bin=`dirname "$0"`
bin=`cd "$bin"; pwd`
==============================
echo $[23*34] <==> echo $((23*34))
==============================
echo $[7#23] #7是底，23是在这个底上的数字，因此最终的结果为17
==============================
echo ${!P*} #列出当前变量中，所有以P开头的变量的名称
==============================
shell的处理过程：alias la='ls -A'->{1..100}->~admin->$PATH->$(ls)->$((23*34))->rm a*o?[a-zA-Z]*
==============================
#下面这种处理方式等同于for f in "$(ls)"，但是可以应对文件名中有空格的情况，而for f in "$(ls)"则不行。
[ $# -eq 0 ] && ls | while read f
do
    ll-2.sh "$f"
done
==============================
可以在一行内定义一个函数，写在shell脚本里可以，还可以直接写在命令行上，比如：
root@pc1:~#testfunc(){ echo "$# parameters;echo "$@";}
而且，如果你在命令行直接这么定义的，你想查看该函数的内容时，可以用type testfunc，你会看到：
testfunc is a function
testfunc ()
{
    echo "$# params";
    IFS=;
    echo "$*"
}
需要特别注意的是：{和echo之间的那个空格，其他地方有没有空格无所谓，但是这个空格如果没有的话，是必然会出错的；还有个地方是}前面那条命令的;必须有，否则也会有问题；最后，还需要提醒的是，如果你不是写在一行内，那么}前的;不必有，{后的空格也不必有。
===============================
对$*和$@作些说明：
其实要分四种情况：$*, $@, "$*", "$@"
对于前两种情况，都等同于$1 $2 $3 ...，如果某个参数内有了空格或者换行（不要觉得不可能，参数中是可以有换行符的，下面就有例子），比如a "b c" d，那么替换后的结果是a b c d，看上去就是四个参数了；
对于"$@"，等同于"$1" "$2" "$3" ...，这下就不必担心参数中有空格或者换行符号了；
对于"$*"，还要受到IFS的影响，其实是IFS中的第一个字符的影响，假定IFS中第一个字符是|的话，那么替换后的结果是"$1|$2|$3..."；这里对IFS还得作下说明，如果 IFS 为空，则没有间隔空格。IFS 的默认值是空白、制表符和换行符。如果没有设置 IFS，则使用空白作为分隔符（仅对默认 IFS 而言），这里特别提到的是，如果你想把参数都串接起来，那么必须得显示设置IFS=''或者IFS=""或者IFS=即可。
下面给出一个验证上述描述的超级牛b的例子：
[ian@pinguino ~]$ type testfunc2
testfunc2 is a function
testfunc2 ()
{
    echo "$# parameters";
    echo Using '$*';
    for p in $*;
    do
        echo "[$p]";
    done;
    echo Using '"$*"';
    for p in "$*";
    do
        echo "[$p]";
    done;
    echo Using '$@';
    for p in $@;
    do
        echo "[$p]";
    done;
    echo Using '"$@"';
    for p in "$@";
    do
        echo "[$p]";
    done
}

[ian@pinguino ~]$ IFS="|${IFS}" testfunc2 abc "a bc" "1 2
> 3"
3 parameters
Using $*
[abc]
[a]
[bc]
[1]
[2]
[3]
Using "$*"
[abc|a bc|1 2
3]
Using $@
[abc]
[a]
[bc]
[1]
[2]
[3]
Using "$@"
[abc]
[a bc]
[1 2
3]
看到参数中使用换行符号了吧，哈哈。
===============================
函数返回值return 0~255必须为一个整数，而且范围只能是0~255，如果大于255，那么会返回$((x%256))，而且不能返回负数，但是允许你写负数，负数会被强制转换成整数。
===============================
#!/bin/sh会提供系统默认的shell解释器，会带来一些想不到的异常情况，建议都使用#!/bin/bash，在bash中定义函数时function关键字是可选的。
===============================
#!/bin/bash

showopts () {
while getopts ":pq:" optname
    do
      case "$optname" in
        "p")
          echo "Option $optname is specified"
          ;;
        "q")
          echo "Option $optname has value $OPTARG"
          ;;
        "?")
          echo "Unknown option $OPTARG"
          ;;
        ":")
          echo "No argument value for option $OPTARG"
          ;;
        *)
        # Should not occur
          echo "Unknown error while processing options"
          ;;
      esac
    done
return $OPTIND
}

showargs () {
for p in "$@"
    do
      echo "[$p]"
    done
}

optinfo=$(showopts "$@")
argstart=$?
arginfo=$(showargs "${@:$argstart}")
echo "Arguments are:"
echo "$arginfo"
echo "Options are:"
echo "$optinfo"

getopts 命令使用了两个预先确定的变量。OPTIND 变量开始被设为 1。之后它包含待处理的下一个参数的索引。如果找到一个选项，则 getopts 命令返回 true，因此常见的选项处理范例使用带 case 语句的 while 循环，本例中就是如此。getopts 的第一个参数是一列要识别的选项字母，在本例中是 p 和 r。选项字母后的冒号 (:) 表示该选项需要一个值；例如，-f 选项可能用于表示文件名，tar 命令中就是如此。此例中的前导冒号告诉 getopts 保持静默（silent）并抑制正常的错误消息，因为此脚本将提供它自己的错误处理。

此例中的第二个参数 optname 是一个变量名，该变量将接收找到选项的名称。如果预期某个选项应该拥有一个值，而且目前存在该值，则会把该值放入 OPTARG 变量中。在静默模式下，可能出现以下两种错误情况。

   1. 如果发现不能识别的选项，则 optname 将包含一个 ? 而 OPTARG 将包含该未知选项。
   2. 如果发现一个选项需要值，但是找不到这个值，则 optname 将包含一个 : 而 OPTARG 将包含丢失参数的选项的名称。

如果不是在静默模式，则这些错误将导致一条诊断错误消息而 OPTARG 不会被设置。脚本可能在 optname 中使用 ? 或 : 值来检测错误（也可能处理错误）。
此外，getopts ":pq:" optname后面还可以配置上可选的getopts ":pq:" optname "$@"

[ian@pinguino ~]$ ./testargs.sh -p -q qoptval abc "def ghi"
Arguments are:
[abc]
[def ghi]
Options are:
Option p is specified
Option q has value qoptval
[ian@pinguino ~]$ ./testargs.sh -q qoptval -p -r abc "def ghi"
Arguments are:
[abc]
[def ghi]
Options are:
Option q has value qoptval
Option p is specified
Unknown option r
[ian@pinguino ~]$ ./testargs.sh "def ghi"
Arguments are:
[def ghi]
Options are:
===============================
父shell设置的alias是不能传到子shell中的，但是在shell script中依然可以使用alias，不过要自己手动设定了，然后还要注意在脚本中显示开启alias的使用，即 shopt -s expand_aliases；有时候会希望alias能带参数就好了，其实可以用函数代替即可，在.bashrc中增加：cpdev1(){ [ $# -eq 1 ] && scp $1 yanbin@dev1.asc.cnz.alimama.com: ; }，具体啥意思，自己去琢磨吧。
===============================
while [ "${i:-1}" -lt 30 ];do a="-"${a:="-"};((i++));done && echo $a
知识点：while的条件，不新建变量还能正常使用，while是个整体，可以有返回值，可以重定向其输出
===============================
如果想实现对shell变量的二次解析，那么可以用eval完成，例如：eval cd "\"\$$#\""
===============================
for var in "$@"; <==> for var;
===============================
在shell总一般extglob都是开着的，你可以用shopt查看一下，如果没开你可以用shopt -s extglob设置一下，在这个选项打开的状态下，我们可以使用一些扩展的glob选项，在shell中是这么使用的：
?(pattern-list)Matches zero or one occurrence of the given patterns
*(pattern-list)Matches zero or more occurrences of the given patterns
+(pattern-list)Matches one or more occurrences of the given patterns
@(pattern-list)Matches one of the given patterns
!(pattern-list)Matches anything except one of the given patterns
===============================
find . -regextype posix-extended -regex '.*\.(h|cpp)'
===============================
findc(){ [ $# -eq 1 ] && compgen -c | grep --color=auto -i $1; }
===============================
在.bashrc中添加：export PS1='\[\e[1;32;40m\]\u@\h:\w\$ '达到的效果：绿色高亮显示，且折行时不会在同一行，如果去掉\[和\]则会在同一行折行。
本人目前在用的一个PS1是：export PS1='\[\e[0;35m\]>>>>[\[\e[0;33m\]\t\[\e[0;35m\]][\[\e[0;31m\]\u@\h\[\e[0;35m\]:\[\e[0;33m\]\[\e[0;34m\]\w\[\e[0;35m\]]\n\[\e[1;$((31+3*!$?))m\]\$ \[\e[0;32m\]' ，这个PS1会换行，而且新行的开始部分（$或者#）会显示红色高亮（上次的命令执行失败）或者蓝色高亮（上次的命令执行正常）。
对于配色，可以参考：
   前景             背景              颜色
   ---------------------------------------
   30                40               黑色
   31                41               紅色
   32                42               綠色
   33                43               黃色
   34                44               藍色
   35                45               紫紅色
   36                46               青藍色
   37                47               白色

   代码              意义
   -------------------------
   0                 OFF
   1                 高亮显示
   4                 underline
   5                 闪烁
   7                 反白显示
   8                 不可见
此外，我在ubuntu上设置了上述PS1之后，当我在终端里打开vi再关闭vi之后，发现命令行出现了乱码，此时输入reset即可恢复正常，此后再使用vi将不再出现乱码，不过每次都这么搞一通实在是不爽，不知道在其他发行版上会不会有这个问题。
现在终于解决了这个问题，有两种方法，一种可以在虚拟终端的title设置中给原先的终端二字前后分别添加一个英文空格即可；另一种方法是重新设置PS1为\[\e]0;\u@\h: \w\a\]\[\e[1;31m\]\u\[\e[1;32m\]@\h\[\e[1;31m\]:\[\e[1;32m\]\w\[\e[1;31m\]\$ \[\e[0m\]
==========================
echo "export LS_COLORS='$LS_COLORS'" >> .bashrc之后打开.bashrc，将di=01;34改为di=01;33即可使得目录以黄色显示
==========================
shell脚本调试，可以先设置export PS4='+{$LINENO:${FUNCNAME[0]}} '，再用sh -x来执行脚本，即可在+号后面打印行号和函数名；使用trap DEBUG/ERR/EXIST可以分别在执行每一行前/某个命令返回值不为0时／函数或程序退出时执行cmd；可以在脚本里面的脚本段落前后分别用sh -x和sh +x来使得只有该段落的内容执行sh -x；可以通过变量DEBUG作为开关来统一控制调试与否，当然需要有个函数，比如也叫做DEBUG的话，那这个函数的定义大概为：DEBUG() { [ "$DEBUG" = "true" ] && $@ ; }，然后你就可以肆无忌惮的DEBUG echo $a,$b或者在一段落前后分别加上DEBUG set -x和DEBUG set +x来进行控制了；还可以使用类似于Gdb调试的bash调试工具bashdb，官网地址为：http://bashdb.sourceforge.net/；上述总结来自于http://www.ibm.com/developerworks/cn/linux/l-cn-shell-debug/index.html
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
export HISTTIMEFORMAT="%Y-%m-%d %H:%M:%S "可以让history显示出执行的时间
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
date -d "1970-01-01 0:0:0 UTC `date +%s` sec" +'%F %T' 可以将时间戳转换为指定的时间表示形式
用date -d @1313418365 +%F\ %T也可以实现将时间戳转换为指定的时间格式
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
find . $ -path './rrds*' -o -path './bash*' $ -prune -o -maxdepth 3 -name '*m*' -printf '%f\n'
该命令实现的功能是查找当前目录下，除了rrds*和bash*文件夹之外的名字中含有m字符的且深度不超过3层的, 将符合上述条件的目录或文件名打印出来, 不打印全部路径, 只打印文件名或目录名. 写该命令时需要注意的几点:$和-path之间以及$之前都必须有空格;针对path或name定义它们需要符合的pattern时必须要./开头或者*开头,因为这里的匹配都是全匹配,而不是包含即可的意思. 对该命令的几点解释:find查找文件名或目录名(其实目录也是文件)符合pattern所有项, 如果只是中间路径中含有pattern, 并不能保证该目录下的所有文件都能和pattern匹配,因为匹配发生在整个路径的最后,也就是文件名或目录名上;prune本意为删除或砍掉的意思,基本上可以理解为和print恰恰相反即可,它们都是action,find命令其实类似于一个复合的if语句, action前面的默认连接是使用-a(即and的意思, 类似于我们常见的command1 && command2 || command3中的&&的作用), 当然也可以显示的指定-o(即or的意思, 类似于||的作用), 既然谈到了and和or，那么自然就有not了，在find命令里，not是!，举个例子就清楚了：find . ! -name '*.sh'会找到所有不是以.sh结尾的文件, 此外还有就是通过$和$能够把一些复合起来的条件作为一个整体, 因此对于该条命令, 执行过程是这样的, if ( -path './rrds*' && -path './bash*' ); then -prune else { if (-maxdepth 3 && -name '*m*' ); then -printf '%f\n' fi } fi
此外对于find命令, 最常用的几个参数是 -type和-name,其实还有-iname(忽略大小写的匹配), 还有-regex和-iregex,注意-name只是用基本的shell的pattern,即*,?,[]三种, 如果真想用正则来匹配,还是用-regex吧; 此外对于find最神奇的莫过于-exec或者-ok或者xargs了,这里给出两个例子即可:
find . -name '*my*' -exec rm '{}' \;   <==> find . -name '*my*' | xargs rm
find. -name '*my*' -exec cp '{}' ~ \;   <==> find . -name '*my*' | xargs -i cp '{}' ~
对于rm这种单参数的命令, find找到的结果直接会塞给rm的; 对于cp这种双参数的命令, 可以用'{}'这个东西来代表find找到的部分, 但对于xargs中需要注意使用-i参数, 该参数其实和-I参数作用是一样的,但是特别之处在于当不指定replace-str时, -i这个参数会把{}作为replace-str, 因此使用-i就用经管道|过来的标准输入去替换{},因此cp命令就生效了.
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
注释大段shell脚本的方法：
:||:<<\{{
...
{{
这里对here document也多少作些讨论:该文档其实是个临时文档,被生成到/tmp目录下,你用命令bash -c 'lsof -a -p $$ -d0' < EOF就可以很清楚的看到这一点;该临时文档为交互式shell脚本或者可执行程序提供输入,最典型的是为cat和ed这样的命令feed输入;最典型的应用是在shell中通过cat<<来大段输出文本, 还有一些比较巧妙的用法,比如为脚本中的函数塞入数据(注意不是为函数塞入参数, 而是当函数中有类似于read这样的命令时通过here文档来feed给它), 在比如为变量赋值variable=$(cat < This variable
runs over multiple lines.
SETVAR)
再比如
vi $TARGETFILE <<\EOF
i
This is line 1 of the example file.
This is line 2 of the example file.
^[
ZZ
EOF
here document自身所特有的几点包括:
1.用<<-代替<<可以使内容中的leading tabs被忽略，对leading spaces无效
2.用’HERE’, “HERE”, \HERE代替<<后面的HERE，可以使内容中变量不被替换,诸如$HOME
3.如果只希望输入一行数据,可以用<<<即可,例如cat <<<'hello world' (说到这里, 还真觉得蛮有意思的,一个<表示0号标准输入; 两个<<表示here document的临时性输入;三个<<<表示单行的here document输入)
更多详细例子,可以参考:http://tldp.org/LDP/abs/html/here-docs.html
===============
对于cat这种可以接受标准输出或者标准输入流的程序来说, 可以通过一个-来承载送过来的流, 大致可分为通过管道|过来的标准输出流和通过<送进来的标准输入流, 通过这样一个例子就可以看出ls | cat - t.C - - < t.sh    <<<'single here document'   <<{{
multiple
here
document
{{
结果只是<<发挥作用了, 它们的优先级别是: <<最高, <<<次之, < 排第三, | 排第四
这样就可以利用该特性为某t.C这样的文档添加页眉和页脚了:
页眉: cat - t.C <<<'header'
页脚: cat t.C - <<<'footer'
=======================================
在脚本中，对于那些脚本依赖的变量，如果没定义的话就不希望继续执行脚本，那么可以使用：
set -u
使用了那些你关注的变量的代码段
set +u
这样就可以保证脚本在执行过程中没有发现这些变量时就自动报错退出
==========================================
按照字符串的长度进行排序:
#! /bin/sh
awk 'BEGIN { FS=RS } { print length, $0}' $1 |
sort -k 1n,1 |
sed 's/^[0-9][0-9]* //' | tee $1 >/de
==========================================
有关shell脚本的第一行，这一行可不是随便写的，是有讲究的，首先要从这一行中提取出的是一个可执行程序的全路径，比需要全路径，在#!后面可以跟空格；其次，会为这个命令要么附加一个选项，要么附加一个参数，记住，有且只能有一个，而且是option和arg二选一，如果有多个参数，其实可以合并，举个例子，比如ls，可以把-a和-f合并为-af，因此在这条规则下：#!/usr/bin/env sed -f就不能work了，因为sed本身就已经是env的一个arg了，其实在这种情况下，系统会认为'sed -f'整体为一个arg，系统判断你指定的究竟是一个arg还是一个option的依据就是：是否以-开头。
=============================================
cd ~1 与cd ~-1代表cd到dirs命令列表中左数/右数第1个目录(从0开始计数); 注意这种用法并不会与pushd冲突, 因为pushd会对dirs列表进行rotate(一定要好好理解这个单词的含义, 它相当于把dirs的结果看作是一个round robin的环状结构, pushd要更改的就是从这个环上的哪个地方找到队首,然后顺时针就可以找到其他的元素了)操作, 举个例子: 假如dirs的结果为: ~    /usr     /etc    /tmp四个目录,那么cd ~1后的结果是/usr /usr /etc /tmp; cd ~-1的结果是/etc /usr /etc /tmp; pushd +1的结果为: /usr /etc /tmp ~; pushd -1的结果为: /etc /tmp ~ /usr
=============================================
查看bash内建命令的help内容，可以用help ulimit，不过这样得到的信息不全面，全面的信息可以在man builtins里面找到；
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
echo -e 'a\tb'和echo $'a\tb'的结果一样，$'string'形式的字符串会被特殊处理，字符串会被展开，并像c语言那样将反斜杠及紧跟的字符进行替换，扩展后的结果将被单引号包裹，就好像美元符号一直就不存在一样，例如$'\n' <=> $'\012' <=> $'\x0a' <=> $'\x0A'；$"string"将会使得字符串被翻译成符合当前locale的语言，如果当前locale是 C 或者 POSIX，美元符号会被忽略，如果字符串被翻译并替换，替换后的字符串仍被双引号包裹。
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
command > out.log 2>&1 可以被command &> out.log代替，二者意义一样，注意&和>之间不能有空格，否则&就会被认为是要把命令放到后台执行，有关bash一些新增的用法可以参见：http://zh.wikipedia.org/wiki/Bash
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
grep -e a -e b file能够匹配到file中的行内含有a或者b的行
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
chvt可以替代Ctrl+Alt+Fn功能键；openvt可以在开满了6个tty之后再新开tty
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
在man或者less搜索的时候，用-i来切换大小写是否敏感（当最左下角显示为:时进行）
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
export -f可以export函数；unset -f/export -f -n可以取消函数定义；declare -f可以看到当前bash里面所有的函数
==========================================================
函数中可以再定义函数，但却不是嵌在函数里面的子函数，外部依然可以随意调用该函数，也就是说和放在外面一样，只不过看上去能感觉到：这个定义在函数A里面的函数B，应该是专注于为函数A服务的。
==========================================================
在bash里fork子shell
#!/bin/bash
if [ "$PROC_PID" != "$PPID" ]; then
    export PROC_PID=$$
    var="mype"
    echo "initial $var"
    declare -r var
    export var
    $0 & # child process
else
    echo "before $var"
    var="netty5"
    echo "after $var"
fi
=================================================================================================
在脚本中$@代表当前shell脚本执行时的所有参数或者代表传递到当前函数内部的所有参数，通过shift命令，可以改变$@的内容，但是$0始终代表当前进程的命令名字，而不是函数名字
=================================================================================================
getopts函数(bash builtin)的功能还是很弱的，比如要解析pq:，那么必须得这么写命令才行： -p -q test arg1 arg2 ...；参数之间不能断开，而且还得必须紧跟在command的后面，当然，getopts是解析$@，如果你用shift处理后的$@能满足$1开始就是option，那么也行。
======================================================
在linux下作各种进制的转化，有两种方法比较好用：
printf "%x\n" 2342 #该方法和c语言中的printf没什么区别
echo 'obase=16; 2342' | bc #该方法很强大, 可以转化为任意进制, 比如printf不能做到的2进制转化
============================================================
echo $content | while read line;
do
...
done
上面这段代码有3个问题：
1. echo时应该给$content添加双引号,否则content中的空格换行tab之类的东西就都丢了;
2. 用管道会导致while是在一个新的子shell里, 导致在while中用的变量其实是新定义的, 而不是context中的;
3. read会忽略前导空格, 因为read会使用IFS的第一个字符作为分割符号, 把当前line分割为若干个word, 你用read word1 word2 word3会读取到各个单词, 默认IFS的第一个字符是空格, 因此假定当前line为' a'的话, 那么会被切割为3部分(因为有2个空格), 最后组装的时候, 会忽略掉空单词, 因此最后就只剩下a了.

正确的做法是:
IFS=
while read line;
do
...
done < <(echo "$content")
这里提一下<()和>()的用法, 这两个东西都是命名管道(但这里是没有名字的, 实则它们是借助于某一个fd来完成的), 相当于你先mkfifo了一个命令管道xxx, 然后你echo "$content" > xxx, 同时你的read函数已经在xxx的另一端候着了while read line; do ... done < xxx. 用<()和>()省略了建立xxx的过程.
==============================================================================
tr 'a-z' 'A-Z' < t1.txt > t1.txt像这种语句，都会把t1.txt清空，其实是bash在这里做了手脚，我们都知道在bash中ls *时，其实bash会先把*扩展为当前所有的文件，然后再让ls去显示，这里也差不多，bash发现>时，会先把该文件清空，然后再交给tr去处理，所以tr啥都不用做就完成了，而此时t1.txt就变成空文件了，要想避免这种情况发生，可以tr 'a-z' 'A-Z' < t1.txt >> t1.txt，但这样会保留t1.txt之前的内容，现在借助于<>，搞出个简单的方法：tr 'a-z' 'A-Z' < t1.txt 1<> t1.txt，这里1<>代表通过fd为1的文件进行read and write，这样就绕过了bash的提前解析，因此t1.txt中的内容也被成功替换掉了。但要注意的是，同时从一个文件既读取又写入，而且是以管道这种流的形式来搞（正因为是流的形式［读一点写一点］，所以就不会全部读到内存中，然后再处理，再把处理后的结果从内存中dump到输出文件），所以这种只对那种本位替换有效果，例如tr或者sed这种，其实说到这里，主要是为了引出<>这个符号的用法，并让大家知道bash会先把>给解析了，其他的都不重要。
strace是个太好太好的命令，例如strace sed -i 's/a/A/g' t1.cpp即可看到sed是使用了临时文件进行替换的。
================================================

#!/bin/bash

mput() {
    eval "__map_$1"__"$2"='$3'
}

mget() {
    eval echo '${__map_'"$1__$2"'}'
}

mgetall() {
    for i in $(eval echo '${!__map_'"$1"'__*}'); do
        echo -n "${i#__map_$1__*}:"
        eval echo '${'"$i"'}';
    done
}

mput capitals France Paris
mput capitals Spain Madrid

echo "$(mget capitals France)"
mgetall capitals
=================================================
func () {
    local unset_x=false
    [[ "$(echo $-)" =~ x ]] || unset_x=true
    [ "false" == "$unset_x" ] && set +x
    #procedure here
    [ "false" == "$unset_x" ] && set -x
}
=================================================
ulimit -c unlimited
export PS4='+{$LINENO($(date +"%F %T")):${FUNCNAME[0]}} '
exec 1>${0%.*}.log
exec 2>${0%.*}.err
mkdir -p .tmp
export TMPDIR=.tmp
set -x
====================================================
__created_tmp_files__=""
delete_tmp_files() {
    if [ -n "$__created_tmp_files__" ]; then
        rm -f $__created_tmp_files__
    fi
}

trap delete_tmp_files EXIT

create_tmp_file() {
    local unset_x=false
    [[ "$(echo $-)" =~ x ]] || unset_x=true
    [ "false" == "$unset_x" ] && set +x
    if [ -z "$(eval "echo $"$1)" ]; then
        eval "$1=.tmp/.__${0##*/}_${LINENO}_$1_${RANDOM}__.tmp"
        rm -f $(eval "echo $"$1)
        __created_tmp_files__="$__created_tmp_files__ $(eval "echo $"$1)"
    fi
    [ "false" == "$unset_x" ] && set -x
}
===================================================

awk '

{

if (NF>5 || ("noresource" != $NF && "zero" != $NF && "part" != $NF && "all" != $NF)) {

print $0 > "/dev/stderr"

} else if ($4 ~ /^http/) {

print $1, (4==$2 ? "y" : "n"), $4, ($5=="all" ? "y" : "n")

} else {

print $1, (4==$2 ? "y" : "n"), "none", ($4=="all" ? "y" : "n")

}

}' $2 | awk '

BEGIN {

pv=0;

}

{

if (FILENAME==ARGV[1]) {

sitepv[$1]=++pv;

} else {

r[sitepv[$1]]=$0;

}

END {

for (i in r) {

print i, r[i];

}

}' $1 - | sort -n -k 1 | awk '

{

for (i=2; i

printf "%s ", $i

}

printf "%s\n", $NF

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

awk -v max_qps=$max_qps -v max_qps_time="$max_qps_time" -v bad_request_num=$bad_request_num '

BEGIN {

total_request_num=0;

total_sum=0;

max_value=0;

max_value_time=0;

min_value=0;

min_value_time=0;

cur_value=0;

level8_threshold=(0 != l8 ? l8 : 3000);

level7_threshold=(0 != l7 ? l7 : 1500);

level6_threshold=(0 != l6 ? l6 : 1000);

level5_threshold=(0 != l5 ? l5 : 500);

level4_threshold=(0 != l4 ? l4 : 200);

level3_threshold=(0 != l3 ? l3 : 100);

level2_threshold=(0 != l2 ? l2 : 50);

level1_threshold=(0 != l1 ? l1 : 30);

gt_level8_threshold_num=0;

gt_level7_threshold_num=0;

gt_level6_threshold_num=0;

gt_level5_threshold_num=0;

gt_level4_threshold_num=0;

gt_level3_threshold_num=0;

gt_level2_threshold_num=0;

gt_level1_threshold_num=0;

le_level1_threshold_num=0;

}

1 == NR {

cur_value=int(substr($14,4));

max_value=min_value=cur_value;

max_value_time=min_value_time=int(substr($1,4));

++total_request_num;

total_sum += cur_value;

next;

}

{

cur_value=int(substr($14,4));

if (cur_value > max_value) {

max_value=cur_value;

max_value_time=int(substr($1,4));

} else if (cur_value < min_value) {

min_value=cur_value;

min_value_time=int(substr($1,4));

}

if (cur_value > level8_threshold) {

++gt_level8_threshold_num;

} else if (cur_value > level7_threshold) {

++gt_level7_threshold_num;

} else if (cur_value > level6_threshold) {

++gt_level6_threshold_num;

} else if (cur_value > level5_threshold) {

++gt_level5_threshold_num;

} else if (cur_value > level4_threshold) {

++gt_level4_threshold_num;

} else if (cur_value > level3_threshold) {

++gt_level3_threshold_num;

} else if (cur_value > level2_threshold) {

++gt_level2_threshold_num;

} else if (cur_value > level1_threshold) {

++gt_level1_threshold_num;

} else {

++le_level1_threshold_num;

}

++total_request_num;

total_sum += cur_value;

}

END {

gt_level7_threshold_num += gt_level8_threshold_num;

gt_level6_threshold_num += gt_level7_threshold_num;

gt_level5_threshold_num += gt_level6_threshold_num;

gt_level4_threshold_num += gt_level5_threshold_num;

gt_level3_threshold_num += gt_level4_threshold_num;

gt_level2_threshold_num += gt_level3_threshold_num;

gt_level1_threshold_num += gt_level2_threshold_num;

print total_request_num;

printf "%d(%.2f%%)\n", bad_request_num, bad_request_num * 100 / total_request_num;

printf "%d(occur at: %s)\n", max_qps, max_qps_time;

cmd="date -d @"max_value_time" +\"%F %T\""; cmd | getline max_value_time_str; close(cmd);

printf "%d ms(occur at: %s)\n", max_value, max_value_time_str;

# printf "%d ms(occur at: %s)\n", min_value, strftime("%F %T", min_value_time);

printf "%.2f ms\n", total_sum / total_request_num;

print gt_level8_threshold_num;

print gt_level7_threshold_num;

print gt_level6_threshold_num;

print gt_level5_threshold_num;

print gt_level4_threshold_num;

print gt_level3_threshold_num;

print gt_level2_threshold_num;

print gt_level1_threshold_num;

print le_level1_threshold_num;

}' $tmp_analyse_file
=================================================================

awk -v threshold=1000 -v debug=n '

BEGIN {

}

{

if (FILENAME==ARGV[1]) {

checked_css[$1]="y";

} else if ("y" != checked_css[$1]) {

if (n[$1] < threshold) {

css[$1, n[$1]++] = $2;

} else {

k = int((rand() * threshold) % threshold);

if("y"==debug)print "[DEBUG]over threshold:", $1, "k=", k, "old item:", css[$1, k], "new item:", $2 > "/dev/stderr";

css[$1, k] = $2;

}

} else {

if("y"==debug)print "[DEBUG]existed css:",$1 > "/dev/stderr";

}

END {

for (i in n) {

if (n[i] >= threshold) {

printf "%s\t", i;

for (j=0; j< threshold; ++j) {

printf "%s ", css[i, j];

}

printf "\n";

}

}' css_ok.txt -

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

awk 'BEGIN {

OFS=",";

array[1,2]=3; array[2,3]=5; array[3,4]=8;

for (comb in array) {

split(comb,sep,SUBSEP);

print sep[1], sep[2], array[sep[1],sep[2]];

}

}'
========================================================================

$ awk 'BEGIN{a["one"]=1;a["two"]=2;a["three"]; if("one2" in a)print a["one"]; for(i in a) print i, a[i]}'

three

one 1

two 2

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

$ awk 'BEGIN{a=3;b=4; print a,b; print a, b; print a b;print a b;}'

3 4

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

$ awk -F$'\t' 'BEGIN{OFS="\t"}{if($3 ~ /ECSHOP/)print $1,$2;}' t3.4 #否则会用空格来分隔fields，print $0不受OFS的影响
==========================================================================

bash里面的大小写转换：

$ a="abCdEF"

$ echo ${a^} #process the first character

AbCdEF

$ echo ${a^^} #process all characters

ABCDEF

$ echo ${a,} #process the first character

abCdEF

$ echo ${a,,} #process all characters

abcdef

bash里的substr：

$ a="abCdEF"

$ echo ${a:1}

bCdEF

$ echo ${a:2:1}

bash里的数组操作：

a=() #empty array

a=(one two three) #three elements in array, with subscripts: 0 1 2

${#a[*]} #length of array

${a[*]} #all elements of array

${!a[*]} #all subscripts of array
${a[*]:2:1} #extract elements, offset index is 2, and length is 1
${a[*]:2} #extract elements, offset index is 2, and length is big enough to fetch all residue elements
${a[*]: -1} #extract last element, note that the space between : and -, by the way, ${@:3:2} will extract $3 and $4

unset a[0] #destory the element with 0 subscript

unset a[*] #destory array

bash里的associated数组（即map）：

这个特性需要bash的版本>=4

declare -A a

$ a[one]=1

$ a["two"]=2

$ a[3]=three

$ echo ${!a[*]}

one two 3

bash里数组元素是否存在的检测方法：

$ ${a[two]+:} false && echo ok || echo fail #${var+XX} will be XX if var is set, or empty; so ${a[two]+:} false will be ': false'

$ [[ ${a[two]+set} ]] && echo ok || echo fail #${a[two]+set} will be 'set', so [[ set ]] is true;

$ ${a[2]+:} false && echo ok || echo fail #${a[2]+:} false will be ' false'

fail

更多详情可参见：http://mywiki.wooledge.org/BashFAQ/083

bash里的复合命令(Compound Commands):

(( expression ))用于检测数值运算(ARITHMETIC EVALUATION)，例如

$ (( 3+3 )) && echo ok || echo fail

$ (( 3-3 )) && echo ok || echo fail

fail

也包括数值类的比较运算符:< > >= !=等

[[ expression ]]用于检测字符串相关的表达式，例如 [[ hello ]], [[ -f test.dat ]], 也可用于带BashPattern的匹配，例如[[ abc == ab* ]]，或者正则字符串匹配[[ abc =~ ^ab ]]

[ expression ]不属于bash，因为[其实是一个外部命令，和ls一样

bash里忽略大小写的字符串比较：

$ shopt -s nocasematch

$ [[ aBc == abc ]] && echo ok || echo fail

set -o会列出控制bash的所有选项，其实还有一些其他的选项需要通过shopt来控制，shopt会列出全部的选项
===========================================================
a2=99
a1=88
b=a2
echo ${!a*} #list all shell variables that start with a
a1 a2
echo ${!b} #this express is equal to: eval 'echo $'$b
99
================================================================
!net #从历史命令里搜索以net开头的最近使用的一条命令

!?net #从历史命令里搜索包含net的最近使用的一条命令
!:0 #上一条命令的command（类似于argv[0]）

!:^ #上一条命令的第一个参数

!:$ #上一条命令的最后一个参数（效果等同于Alt+. ，不过Alt+.按n次，是会到倒数第n条命令里取得最后一个参数的）

!:* #上一条命令的所有参数（效果等同于 !:^-$）

!:2-4 #上一条命令的第2个到第4个参数

!:2* #上一条命令从第2个参数开始（包括第2个参数）以后的参数（效果等同于!:2-$）

!:2- #上一条命令从第2个参数开始（包括第2个参数）到倒数第2个参数，即省略掉最后一个参数

^ll^md5sum #从上一条里把第一次出现的ll替换为md5sum后重新执行

!!:gs/ll/md5sum #从上一条命令里把所有出现的ll都替换为md5sum（这里的语法类似于sed，/也可以用其他符号例如@来代替，g表示多次匹配）

!! #重新执行上一条命令（效果等同于Ctrl-p）

so true 2009-06-16 00:37 发表评论