干瞪眼源码

① 如何从boot.img提取ramdisk文件

首先你要有一个用户解锁fastboot的手机，这样才能允许你刷入第三方ROM
其次你要能找到当前版本所对应的boot.img或sec_boot.img（带签名）,通常能拿到的也就是刷机包里面解出来的sec_boot.img，通过cat mtd出来的不知道行不行=。=

工具：
split_bootimg.pl
mkbootfs和mkbootimg

1）sec_boot.img是经过签名的，需要把文件前0x1000个字节删除，也就是ANDROID! 8个字符前面所有字节删除，保存为boot.img

2) 运行perl split_bootimg.pl boot.img解出kernel和ramdisk文件，同时记下运行结果中的“Command line: vmalloc=384M mem=2044m@0x200000。。。。”一长串字符备用

3）运行指令把ramdisk的文件解出来
mkdir ramdisk
cd ramdisk
gzip -dc ../boot.img-ramdisk.gz | cpio -i
cd ..

4）修改其中的文件，例如我觉得default.prop里面的persist.sys.usb.config=manufacture,adb不太爽，想改成=adb，修改保存。如果你想adb有root权限的话，就去改ro.secure和ro.debuggable

5）重新打包
mkbootfs ./ramdisk | gzip > ramdisk-new.gz
当然如果你自己编译的mkbootfs也没有加到path里，就把编译完的程序考到当前目录，运行./mkbootfs...
生成boot-new.img
mkbootimg --cmdline '单引号里面这一段拷贝刚才记下的Command line冒号后面的一长串' --kernel boot.img-kernel --ramdisk ramdisk-new.gz -o boot-new.img

6) 现在如果把生成的boot-new.img直接刷进去，手机就起不来了，问题在于kernel,ramdisk,second stage,tags的地址，
自己编译的mkbootimg查看一下.c文件就知道base=0x10000000，生成的boot-new.img是按照这个规则来的：
kernel地址=base + 0x00008000，ramdisk地址=base + 0x01000000，
second stage地址=base + 0x00f00000，tags地址=base + 0x00000100。
这跟原始sec_boot.img里面的地址是不一样的，本想找到正确的base值，但原始img的几个地址并非此规律，拿不到源码只能干瞪眼喽，
最简单的办法就是用16进制编辑器将boot-new.img对应的4个地址修改为原始值，如图：

7）保存后就可以fastboot刷入这个boot了，然后就是验证一下能否启动啦^_^，启动不了也不至于变砖，因为咱recovery和fastboot没刷，可以利用这两种方法恢复

② linux下的PID,PIDD是什么他们之间的关系以及应用是什么

在 Linux 底下执行一个指令时，系统会给予这个动作一个 ID， 我们称为 PID，而根据启用这个指令的使用者与相关的指令功能，而给予这个特定 PID 一组权限， 该指令可以进行的行为则与这个 PID 的权限有关。

linux进程简介
Linux是一个多任务的操作系统，也就是说，在同一个时间内，可以有多个进程同时执行。如果读者对计算机硬件体系有一定了解的话，会知道我们大家常用的单CPU计算机实际上在一个时间片断内只能执行一条指令，那么Linux是如何实现多进程同时执行的呢？原来Linux使用了一种称为"进程调度（process scheling）"的手段，首先，为每个进程指派一定的运行时间，这个时间通常很短，短到以毫秒为单位，然后依照某种规则，从众多进程中挑选一个投入运行，其他的进程暂时等待，当正在运行的那个进程时间耗尽，或执行完毕退出，或因某种原因暂停，Linux就会重新进行调度，挑选下一个进程投入运行。因为每个进程占用的时间片都很短，在我们使用者的角度来看，就好像多个进程同时运行一样了。

在Linux中，每个进程在创建时都会被分配一个数据结构，称为进程控制块（Process Control Block，简称PCB）。PCB中包含了很多重要的信息，供系统调度和进程本身执行使用，其中最重要的莫过于进程ID（process ID）了，进程ID也被称作进程标识符，是一个非负的整数，在Linux操作系统中唯一地标志一个进程，在我们最常使用的I386架构（即PC使用的架构）上，一个非负的整数的变化范围是0-32767，这也是我们所有可能取到的进程ID。其实从进程ID的名字就可以看出，它就是进程的身份证号码，每个人的身份证号码都不会相同，每个进程的进程ID也不会相同。

一个或多个进程可以合起来构成一个进程组（process group），一个或多个进程组可以合起来构成一个会话（session）。这样我们就有了对进程进行批量操作的能力，比如通过向某个进程组发送信号来实现向该组中的每个进程发送信号。

最后，让我们通过ps命令亲眼看一看自己的系统中目前有多少进程在运行：

$ps -aux（以下是在我的计算机上的运行结果，你的结果很可能与这不同。）
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
root 1 0.1 0.4 1412 520 ? S May15 0:04 init [3]
root 2 0.0 0.0 0 0 ? SW May15 0:00 [keventd]
root 3 0.0 0.0 0 0 ? SW May15 0:00 [kapm-idled]
root 4 0.0 0.0 0 0 ? SWN May15 0:00 [ksoftirqd_CPU0]
root 5 0.0 0.0 0 0 ? SW May15 0:00 [kswapd]
root 6 0.0 0.0 0 0 ? SW May15 0:00 [kreclaimd]
root 7 0.0 0.0 0 0 ? SW May15 0:00 [bdflush]
root 8 0.0 0.0 0 0 ? SW May15 0:00 [kupdated]
root 9 0.0 0.0 0 0 ? SW< May15 0:00 [mdrecoveryd]
root 13 0.0 0.0 0 0 ? SW May15 0:00 [kjournald]
root 132 0.0 0.0 0 0 ? SW May15 0:00 [kjournald]
root 673 0.0 0.4 1472 592 ? S May15 0:00 syslogd -m 0
root 678 0.0 0.8 2084 1116 ? S May15 0:00 klogd -2
rpc 698 0.0 0.4 1552 588 ? S May15 0:00 portmap
rpcuser 726 0.0 0.6 1596 764 ? S May15 0:00 rpc.statd
root 839 0.0 0.4 1396 524 ? S May15 0:00 /usr/sbin/apmd -p
root 908 0.0 0.7 2264 1000 ? S May15 0:00 xinetd -stayalive
root 948 0.0 1.5 5296 1984 ? S May15 0:00 sendmail: accepti
root 967 0.0 0.3 1440 484 ? S May15 0:00 gpm -t ps/2 -m /d
wnn 987 0.0 2.7 4732 3440 ? S May15 0:00 /usr/bin/cserver
root 1005 0.0 0.5 1584 660 ? S May15 0:00 crond
wnn 1025 0.0 1.9 3720 2488 ? S May15 0:00 /usr/bin/tserver
xfs 1079 0.0 2.5 4592 3216 ? S May15 0:00 xfs -droppriv -da
daemon 1115 0.0 0.4 1444 568 ? S May15 0:00 /usr/sbin/atd
root 1130 0.0 0.3 1384 448 tty1 S May15 0:00 /sbin/mingetty tt
root 1131 0.0 0.3 1384 448 tty2 S May15 0:00 /sbin/mingetty tt
root 1132 0.0 0.3 1384 448 tty3 S May15 0:00 /sbin/mingetty tt
root 1133 0.0 0.3 1384 448 tty4 S May15 0:00 /sbin/mingetty tt
root 1134 0.0 0.3 1384 448 tty5 S May15 0:00 /sbin/mingetty tt
root 1135 0.0 0.3 1384 448 tty6 S May15 0:00 /sbin/mingetty tt
root 8769 0.0 0.6 1744 812 ? S 00:08 0:00 in.telnetd: 192.1
root 8770 0.0 0.9 2336 1184 pts/0 S 00:08 0:00 login -- lei
lei 8771 0.1 0.9 2432 1264 pts/0 S 00:08 0:00 -bash
lei 8809 0.0 0.6 2764 808 pts/0 R 00:09 0:00 ps -aux

以上除标题外，每一行都代表一个进程。在各列中，PID一列代表了各进程的进程ID，COMMAND一列代表了进程的名称或在Shell中调用的命令行，对其他列的具体含义，我就不再作解释，有兴趣的读者可以去参考相关书籍。

getpid

在2.4.4版内核中，getpid是第20号系统调用，其在Linux函数库中的原型是：

#include<sys/types.h> /* 提供类型pid_t的定义 */
#include<unistd.h> /* 提供函数的定义 */
pid_t getpid(void);

getpid的作用很简单，就是返回当前进程的进程ID，请大家看以下的例子：

/* getpid_test.c */
#include<unistd.h>
main()
{
printf("The current process ID is %d
",getpid());
}

细心的读者可能注意到了，这个程序的定义里并没有包含头文件sys/types.h，这是因为我们在程序中没有用到pid_t类型，pid_t类型即为进程ID的类型。事实上，在i386架构上（就是我们一般PC计算机的架构），pid_t类型是和int类型完全兼容的，我们可以用处理整形数的方法去处理pid_t类型的数据，比如，用"%d"把它打印出来。

编译并运行程序getpid_test.c：

$gcc getpid_test.c -o getpid_test
$./getpid_test
The current process ID is 1980
（你自己的运行结果很可能与这个数字不一样，这是很正常的。）

再运行一遍：

$./getpid_test
The current process ID is 1981

正如我们所见，尽管是同一个应用程序，每一次运行的时候，所分配的进程标识符都不相同。

fork

在2.4.4版内核中，fork是第2号系统调用，其在Linux函数库中的原型是：

#include<sys/types.h> /* 提供类型pid_t的定义 */
#include<unistd.h> /* 提供函数的定义 */
pid_t fork(void);

只看fork的名字，可能难得有几个人可以猜到它是做什么用的。fork系统调用的作用是复制一个进程。当一个进程调用它，完成后就出现两个几乎一模一样的进程，我们也由此得到了一个新进程。据说fork的名字就是来源于这个与叉子的形状颇有几分相似的工作流程。

在Linux中，创造新进程的方法只有一个，就是我们正在介绍的fork。其他一些库函数，如system()，看起来似乎它们也能创建新的进程，如果能看一下它们的源码就会明白，它们实际上也在内部调用了fork。包括我们在命令行下运行应用程序，新的进程也是由shell调用fork制造出来的。fork有一些很有意思的特征，下面就让我们通过一个小程序来对它有更多的了解。

/* fork_test.c */
#include<sys/types.h>
#inlcude<unistd.h>
main()
{
pid_t pid;
/*此时仅有一个进程*/
pid=fork();
/*此时已经有两个进程在同时运行*/
if(pid<0)
printf("error in fork!");
else if(pid==0)
printf("I am the child process, my process ID is %d
",getpid());
else
printf("I am the parent process, my process ID is %d
",getpid());
}

编译并运行：

$gcc fork_test.c -o fork_test
$./fork_test
I am the parent process, my process ID is 1991
I am the child process, my process ID is 1992

看这个程序的时候，头脑中必须首先了解一个概念：在语句pid=fork()之前，只有一个进程在执行这段代码，但在这条语句之后，就变成两个进程在执行了，这两个进程的代码部分完全相同，将要执行的下一条语句都是if(pid==0)......。

两个进程中，原先就存在的那个被称作"父进程"，新出现的那个被称作"子进程"。父子进程的区别除了进程标志符（process ID）不同外，变量pid的值也不相同，pid存放的是fork的返回值。fork调用的一个奇妙之处就是它仅仅被调用一次，却能够返回两次，它可能有三种不同的返回值：

在父进程中，fork返回新创建子进程的进程ID；

在子进程中，fork返回0；

如果出现错误，fork返回一个负值；

fork出错可能有两种原因：

（1）当前的进程数已经达到了系统规定的上限，这时errno的值被设置为EAGAIN。（2）系统内存不足，这时errno的值被设置为ENOMEM。（关于errno的意义，请参考本系列的第一篇文章。）

fork系统调用出错的可能性很小，而且如果出错，一般都为第一种错误。如果出现第二种错误，说明系统已经没有可分配的内存，正处于崩溃的边缘，这种情况对Linux来说是很罕见的。

说到这里，聪明的读者可能已经完全看懂剩下的代码了，如果pid小于0，说明出现了错误；pid==0，就说明fork返回了0，也就说明当前进程是子进程，就去执行printf("I am the child!")，否则（else），当前进程就是父进程，执行printf("I am the parent!")。完美主义者会觉得这很冗余，因为两个进程里都各有一条它们永远执行不到的语句。不必过于为此耿耿于怀，毕竟很多年以前，UNIX的鼻祖们在当时内存小得无法想象的计算机上就是这样写程序的，以我们如今的"海量"内存，完全可以把这几个字节的顾虑抛到九霄云外。

说到这里，可能有些读者还有疑问：如果fork后子进程和父进程几乎完全一样，而系统中产生新进程唯一的方法就是fork，那岂不是系统中所有的进程都要一模一样吗？那我们要执行新的应用程序时候怎么办呢？从对Linux系统的经验中，我们知道这种问题并不存在。至于采用了什么方法，我们把这个问题留到后面具体讨论。

exit

在2.4.4版内核中，exit是第1号调用，其在Linux函数库中的原型是：

#include<stdlib.h>
void exit(int status);

不像fork那么难理解，从exit的名字就能看出，这个系统调用是用来终止一个进程的。无论在程序中的什么位置，只要执行到exit系统调用，进程就会停止剩下的所有操作，清除包括PCB在内的各种数据结构，并终止本进程的运行。请看下面的程序：

/* exit_test1.c */
#include<stdlib.h>
main()
{
printf("this process will exit!
");
exit(0);
printf("never be displayed!
");
}

编译后运行：

$gcc exit_test1.c -o exit_test1
$./exit_test1
this process will exit!

我们可以看到，程序并没有打印后面的"never be displayed! "，因为在此之前，在执行到exit(0)时，进程就已经终止了。

exit系统调用带有一个整数类型的参数status，我们可以利用这个参数传递进程结束时的状态，比如说，该进程是正常结束的，还是出现某种意外而结束的，一般来说，0表示没有意外的正常结束；其他的数值表示出现了错误，进程非正常结束。我们在实际编程时，可以用wait系统调用接收子进程的返回值，从而针对不同的情况进行不同的处理。关于wait的详细情况，我们将在以后的篇幅中进行介绍。

exit和_exit

作为系统调用而言，_exit和exit是一对孪生兄弟，它们究竟相似到什么程度，我们可以从Linux的源码中找到答案：

#define __NR__exit __NR_exit /* 摘自文件include/asm-i386/unistd.h第334行 */

"__NR_"是在Linux的源码中为每个系统调用加上的前缀，请注意第一个exit前有2条下划线，第二个exit前只有1条下划线。

这时随便一个懂得C语言并且头脑清醒的人都会说，_exit和exit没有任何区别，但我们还要讲一下这两者之间的区别，这种区别主要体现在它们在函数库中的定义。_exit在Linux函数库中的原型是：

#include<unistd.h>
void _exit(int status);

和exit比较一下，exit()函数定义在stdlib.h中，而_exit()定义在unistd.h中，从名字上看，stdlib.h似乎比unistd.h高级一点，那么，它们之间到底有什么区别呢？让我们先来看流程图，通过下图，我们会对这两个系统调用的执行过程产生一个较为直观的认识。

从图中可以看出，_exit()函数的作用最为简单：直接使进程停止运行，清除其使用的内存空间，并销毁其在内核中的各种数据结构；exit()函数则在这些基础上作了一些包装，在执行退出之前加了若干道工序，也是因为这个原因，有些人认为exit已经不能算是纯粹的系统调用。

exit()函数与_exit()函数最大的区别就在于exit()函数在调用exit系统调用之前要检查文件的打开情况，把文件缓冲区中的内容写回文件，就是图中的"清理I/O缓冲"一项。

在Linux的标准函数库中，有一套称作"高级I/O"的函数，我们熟知的printf()、fopen()、fread()、fwrite()都在此列，它们也被称作"缓冲I/O（buffered I/O）"，其特征是对应每一个打开的文件，在内存中都有一片缓冲区，每次读文件时，会多读出若干条记录，这样下次读文件时就可以直接从内存的缓冲区中读取，每次写文件的时候，也仅仅是写入内存中的缓冲区，等满足了一定的条件（达到一定数量，或遇到特定字符，如换行符和文件结束符EOF），再将缓冲区中的内容一次性写入文件，这样就大大增加了文件读写的速度，但也为我们编程带来了一点点麻烦。如果有一些数据，我们认为已经写入了文件，实际上因为没有满足特定的条件，它们还只是保存在缓冲区内，这时我们用_exit()函数直接将进程关闭，缓冲区中的数据就会丢失，反之，如果想保证数据的完整性，就一定要使用exit()函数。

请看以下例程：

/* exit2.c */
#include<stdlib.h>
main()
{
printf("output begin
");
printf("content in buffer");
exit(0);
}

编译并运行：

$gcc exit2.c -o exit2
$./exit2
output begin
content in buffer
/* _exit1.c */
#include<unistd.h>
main()
{
printf("output begin
");
printf("content in buffer");
_exit(0);
}

编译并运行：

$gcc _exit1.c -o _exit1
$./_exit1
output begin

在Linux中，标准输入和标准输出都是作为文件处理的，虽然是一类特殊的文件，但从程序员的角度来看，它们和硬盘上存储数据的普通文件并没有任何区别。与所有其他文件一样，它们在打开后也有自己的缓冲区。

请读者结合前面的叙述，思考一下为什么这两个程序会得出不同的结果。相信如果您理解了我前面所讲的内容，会很容易的得出结论。

在这篇文章中，我们对Linux的进程管理作了初步的了解，并在此基础上学习了getpid、fork、exit和_exit四个系统调用。在下一篇文章中，我们将学习与Linux进程管理相关的其他系统调用，并将作一些更深入的探讨。

前面的文章中，我们已经了解了父进程和子进程的概念，并已经掌握了系统调用exit的用法，但可能很少有人意识到，在一个进程调用了exit之后，该进程并非马上就消失掉，而是留下一个称为僵尸进程（Zombie）的数据结构。在Linux进程的5种状态中，僵尸进程是非常特殊的一种，它已经放弃了几乎所有内存空间，没有任何可执行代码，也不能被调度，仅仅在进程列表中保留一个位置，记载该进程的退出状态等信息供其他进程收集，除此之外，僵尸进程不再占有任何内存空间。从这点来看，僵尸进程虽然有一个很酷的名字，但它的影响力远远抵不上那些真正的僵尸兄弟，真正的僵尸总能令人感到恐怖，而僵尸进程却除了留下一些供人凭吊的信息，对系统毫无作用。

也许读者们还对这个新概念比较好奇，那就让我们来看一眼Linux里的僵尸进程究竟长什么样子。

当一个进程已退出，但其父进程还没有调用系统调用wait（稍后介绍）对其进行收集之前的这段时间里，它会一直保持僵尸状态，利用这个特点，我们来写一个简单的小程序：

/* zombie.c */
#include
#include
main()
{
pid_t pid;

pid=fork();

if(pid<0) /* 如果出错 */
printf("error occurred!n");
else if(pid==0) /* 如果是子进程 */
exit(0);
else /* 如果是父进程 */
sleep(60); /* 休眠60秒，这段时间里，父进程什么也干不了 */
wait(NULL); /* 收集僵尸进程 */
}

sleep的作用是让进程休眠指定的秒数，在这60秒内，子进程已经退出，而父进程正忙着睡觉，不可能对它进行收集，这样，我们就能保持子进程60秒的僵尸状态。

编译这个程序：

$ cc zombie.c -o zombie

后台运行程序，以使我们能够执行下一条命令：

$ ./zombie &
[1] 1577

列一下系统内的进程：

$ ps -ax
... ...
1177 pts/0 S 0:00 -bash
1577 pts/0 S 0:00 ./zombie
1578 pts/0 Z 0:00 [zombie ]
1579 pts/0 R 0:00 ps -ax

看到中间的"Z"了吗？那就是僵尸进程的标志，它表示1578号进程现在就是一个僵尸进程。

我们已经学习了系统调用exit，它的作用是使进程退出，但也仅仅限于将一个正常的进程变成一个僵尸进程，并不能将其完全销毁。僵尸进程虽然对其他进程几乎没有什么影响，不占用CPU时间，消耗的内存也几乎可以忽略不计，但有它在那里呆着，还是让人觉得心里很不舒服。而且Linux系统中进程数目是有限制的，在一些特殊的情况下，如果存在太多的僵尸进程，也会影响到新进程的产生。那么，我们该如何来消灭这些僵尸进程呢？

先来了解一下僵尸进程的来由，我们知道，Linux和UNIX总有着剪不断理还乱的亲缘关系，僵尸进程的概念也是从UNIX上继承来的，而UNIX的先驱们设计这个东西并非是因为闲来无聊想烦烦其他的程序员。僵尸进程中保存着很多对程序员和系统管理员非常重要的信息，首先，这个进程是怎么死亡的？是正常退出呢，还是出现了错误，还是被其它进程强迫退出的？其次，这个进程占用的总系统CPU时间和总用户CPU时间分别是多少？发生页错误的数目和收到信号的数目。这些信息都被存储在僵尸进程中，试想如果没有僵尸进程，进程一退出，所有与之相关的信息都立刻归于无形，而此时程序员或系统管理员需要用到，就只好干瞪眼了。

那么，我们如何收集这些信息，并终结这些僵尸进程呢？就要靠我们下面要讲到的waitpid调用和wait调用。这两者的作用都是收集僵尸进程留下的信息，同时使这个进程彻底消失。下面就对这两个调用分别作详细介绍。

③ 通达信 arbr指标

AR是人气意愿指标，BR是买卖意愿指标比较简单，就是两条线AR和BR

1.AR和BR指标的一般身高是70-150，太高了容易折，太低了(50以下)就会有人抢筹码而拉高它。

2.AR有先知能力，若股价行情正好上涨时而AR开始掉头向下，我们就要出货了，反之，就要快快抢筹码了。

3.若是二者携手一飞冲天的上涨，我们此时就要减仓了。若是慢悠悠的一起向上，那我们也就慢慢的拿。

4.BR没有AR是不行的，离开了AR，BR就没有了生命，所以使用时一定要把BRAR放在一起用。

5.若是BR从高处摔落了1/2，而AR还是在上方干瞪眼看着，那就买票进场吧，因为后期BR还是会乖乖的回到AR身边的。

④ 想要用易语言制作辅助需要学习哪些易语言知识，

这些人都瞎吹，
除非拿现成的外挂模块无脑调用。否则一个0基础新手一上来就想学做外挂痴人说梦。外挂不仅要学易语言 还要学内存方面的知识 api CE也要学不是单纯的搜索浮数点，还要过得了游戏基础检测，没有坚实的编程基础想都别想。
很多新手下个模块 源码东拼西凑改个名就成自己的了 什么原理怎么实现根本搞不懂 只是调用别人写好封装的子程序 每天就是忙碌在找基址改基址 然后 游戏商换个检测思路 就只能干瞪眼到处求人。很多人就是想学做外挂赚钱，你不懂基本原理怎么实现全是拿别人的成品复制粘贴 做出成品又怎样 一发出去 别人分分钟给你破了限制 还会怕你套飘零网络验证？。
我建议你还是从最基层学起，先学个进度条怎么实现 把那些组件属性搞清楚怎么用 循序渐进 多动手 。别想那些离你很远的东西。

⑤ java阅读源码，大量英文注释阅读不方便，求集成idea里面的翻译java注释由英文翻译为中文的工具。

学会在idea（eclipse）中阅读、调试源码，是java程序员必不可少的一项技能。

在idea中配完环境后，默认其实也是能够对jdk的源码进行debug调试的。但是无法在源码中添加自己的注释，无法添加自己的理解。如果干瞪眼看的话，可能过段时间，就忘记了。下面就介绍下，如何在jdk源码中为所欲为，像在我们自己的代码中一样写注释、调代码：

打开idea，选择Project->File->Project Structure->SDKs->Sourcepath，初始状态如下图 ：

这时，再重新打开jdk的源码类，我们就可以在源java文件中，添加自己的注释了。

一定注意：添加注释时，一定不要新加一行写注释。最好在一行代码的后面，使用//进行注释。否则行号和真正的jre中编译后的代码行号对应不上，如果对源码debug时，会出现代码运行和行号不匹配的情况

⑥ 如何编辑boot.img里面的ramdisk

首先你要有一个用户解锁fastboot的手机，这样才能允许你刷入第三方ROM
其次你要能找到当前版本所对应的boot.img或sec_boot.img（带签名）,通常能拿到的也就是刷机包里面解出来的sec_boot.img，通过cat mtd出来的不知道行不行=。=
工具：
split_bootimg.pl google一下，很好找
mkbootfs和mkbootimg 可以从网上下，最好是自己直接编译

1）sec_boot.img是经过签名的，需要把文件前0x1000个字节删除，也就是ANDROID! 8个字符前面所有字节删除，保存为boot.img
2) 运行perl split_bootimg.pl boot.img解出kernel和ramdisk文件，同时记下运行结果中的“Command line: vmalloc=384M mem=2044m@0x200000。。。。”一长串字符备用
3）运行指令把ramdisk的文件解出来
mkdir ramdisk
cd ramdisk
gzip -dc ../boot.img-ramdisk.gz | cpio -i
cd ..
4）修改其中的文件，例如我觉得default.prop里面的persist.sys.usb.config=manufacture,adb不太爽，想改成=adb，修改保存。如果你想adb有root权限的话，就去改ro.secure和ro.debuggable
5）重新打包
mkbootfs ./ramdisk | gzip > ramdisk-new.gz
当然如果你自己编译的mkbootfs也没有加到path里，就把编译完的程序考到当前目录，运行./mkbootfs...
生成boot-new.img
mkbootimg --cmdline '单引号里面这一段拷贝刚才记下的Command line冒号后面的一长串' --kernel boot.img-kernel --ramdisk ramdisk-new.gz -o boot-new.img
6) 现在如果把生成的boot-new.img直接刷进去，手机就起不来了，问题在于kernel,ramdisk,second stage,tags的地址，
自己编译的mkbootimg查看一下.c文件就知道base=0x10000000，生成的boot-new.img是按照这个规则来的：
kernel地址=base + 0x00008000，ramdisk地址=base + 0x01000000，
second stage地址=base + 0x00f00000，tags地址=base + 0x00000100。
这跟原始sec_boot.img里面的地址是不一样的，本想找到正确的base值，但原始img的几个地址并非此规律，拿不到源码只能干瞪眼喽，
最简单的办法就是用16进制编辑器将boot-new.img对应的4个地址修改为原始值，如图：

⑦ 易语言 怎么样一按信息框的确定还20秒后自动关闭窗口

.版本2

.程序集窗口程序集1

.程序集变量i,整数型

.子程序__启动窗口_创建完毕

i＝20

.子程序_按钮1_被单击

信息框(“窗口将在20秒后关闭！”,0,)

时钟1.时钟周期＝1000

.子程序_时钟1_周期事件

.如果真(i≠0)

标签1.标题＝“还剩”＋到文本(i)＋“秒，窗口将自动关闭！”

i＝i－1

返回()

.如果真结束

结束()

.子程序_按钮2_被单击

信息框(“窗口将在20秒后关闭！”,0,)

延时(20000)

结束()

‘---------------------------------

这两种方法是有区别的，

方法一：用时钟控件那个，算是软关闭，在这20秒内，用户可以进行其他操作，也可以取消关闭，

方法二：这个就属于硬关闭了，因为用的是延时命令，这20秒内，程序可以说是处在一个假死状态，用户无法进行其他操作，只能干瞪眼的等着程序关闭

希望对你有用

⑧ 《UNIX环境高级编程》这本书怎么看怎么学习

W.Richard Stevens 先生所着之书比较适合有经验的人进一步深入学习

W.Richard Stevens 先生所着的UNIX 环境高级编程、UNIX网络编程、TCP/IP详解是难得的入门好书，但这里的入门指得是研究生级别的入门。Stevens 先生所着之书多半是为了给研究生上课时用做教材，因此 Stevens 先生假设阅读这些书的人至少已经接受过了系统的计算机技术本科教育，已经拥有了比较系统的计算机相关基础理论知识。在书中 Stevens 先生假设读者拥有了最基础的操作系统理论，网络技术理论，以及UNIX理论和实践经验，并拥有数种业界常用的UNIX系统作为学习环境（在国外的大学里很容易获得），这样才能体会书中所述的细节。因此这些书刚接触时看似通俗易懂，但在阅读细节上却对读者要求甚高，如果没有足够的专业理论和系统实践是很难真正读进去的。

所以，对于没有接受过系统的计算机专业教育的爱好者，或者主要以 linux 系统维护，或以linux 桌面应用为主的普通用户，Stevens 先生的书并不是很合适的阅读对象。

因此，就我个人的看法，掌握任何一种知识都是需要投入的。我们需要花费金钱去得知识来源（花钱买书，花钱上网，花钱培训），需要花费宝贵的时间去阅读（人生匆匆几十年，没多少时间可以给我们去浪费），需要花费精力去理解书中的内容（基础知识越扎实，理解所学内容越快，但累积基础同样需要大量时间和精力），需要找到合适的环境（光看不实践心里是不会有底的）去验证自己掌握的东西。因此，如果在决定投入之前，先要摸清楚自己到底想要达到什么样的目标，这个目标是否切合自己的实际（相信一个在流水线上辛苦劳作的普通工人，即使学会了计算机编程也是没有用武之地的，除非他有机会离开流水线）。自己是否有足够的资源承载自己的理想（如对于温饱问题尚未解决之人，要他花上千上万的钱去学MBA显然是不现实的）。

同时，任何一本书都会对读者提出一个基本的知识架构和程度上的要求，比方说即使是文学博士，让他去读高能物理学方面的书也会要他的命的。因此在选择所读之书前，先要对自己的实际能力做一次详细的评估，看自己目前到了哪种阶段，是否有能力去掌握自己想要掌握的东西。千万不要因为好高骛远而勉力为之。选择适合自己当前水平的书去阅读并理解，远好过拿着大师所着的神作干瞪眼。

如果主要希望掌握UNIX下的编程技术，尤其是网络编程技术的话，可以有两条路走：

1、以实际需要完善知识架构：为自己做一个项目，比方说自己写个简单的 Web 服务器，因为现在 Web 应用非常丰富，既有成熟的客户端如浏览器可以配合，又有足够全的文档如 RFC文档可供参考，再加上最基本的 socket 编程经验，就可以开始做自己的 Web 服务器。一步一步的为 Web 服务器添加流行的功能，如支持后台 FastCGI 接口，支持 WebDAV，支持流媒体等。在这个过程中不断地学习和掌握相关的理论知识，有时在发觉设计上的不足时甚至需要推翻全盘重新架构。当最终一个完全符合自己心意且足够实用的 Web 服务器做成时，就拥有了可以由自己支配和修改的服务器，同时也掌握了相关的专业理论。这种方式比较适合有一定专业基础的人使用。优点是直观，方向明确所以学习效率高。缺点是需求驱动，形成知识架构不容易完整。

2、系统掌握计算机专业理论：最好的书就是大学里的理论教科书，这些书不会去讲解过于具体的计算机应用，而是从概念开始讲起，力图使学习者获得一个完整的知识体系。只要以后碰到的工作和这个知识体系相关，自然就能很快学会。这种方式比较适合没有基础，或者希望深入学习的人使用，优点是知识架构会逐渐趋于完整，理论功底扎实，后劲足。缺点是花费时间长，方向不明确所以学习效率低，初期会因缺少实践而进展缓慢。