x86下linux工程师

① linux操作系统所说的i386 和x86的系统盘有什么区别

区别：

1、i386是32位微处理器。

2、x86是16位处理器。

3、i386即Intel 80386。其实i386通常被用来作为对Intel（英特尔）32位微处理器的统称。是英特尔（Intel）公司的一款x86系列CPU。

4、X86是由Intel推出的一种复杂指令集，用于控制芯片的运行的程序。

(1)x86下linux工程师扩展阅读：

发展历史：

x86架构于1978年推出的Intel 8086中央处理器中首度出现，它是从Intel 8008处理器中发展而来的。

而8008则是发展自Intel 4004的。8086在三年后为IBM PC所选用，之后x86便成为了个人计算机的标准平台，成为了历来最成功的CPU架构。。

直到1985年32位的80386的开发，这个架构都维持是16位。接着一系列的处理器表示了32位架构的细微改进，推出了数种的扩充，直到2003年AMD对于这个架构发展了64位的扩充，并命名为AMD64。

后来Intel也推出了与之兼容的处理器，并命名为Intel 64。两者一般被统称为x86-64或x64，开创了x86的64位时代。

资料来源：网络-Intel x86

资料来源：网络-i386

② linux系统和安卓X86的区别

1、从底层来讲，linux一般是要安装在pc，pc-server，及部分小型机上的。 那大体来说呢，架构属于X86-64或者安腾。
而android 一般是安装在手机跟平板电脑上的。 现在市面上，其CPU型号千变万化，一个厂家一个架构。 而且手机跟PC的硬件也不同。 必然导致其内核的不同
也就是说，从底层来讲，linux与android的内核支持架构有很大区别。 即便同样是android系统本身，由于不同型号的手机，使用的硬件也不同，
所以使用的内核也就不同，这也是为什么普遍的， 没一款手机几乎都有自己的底包，不能像PC那样互通。 关键是由于现在的手机CPU，硬件架构没有一个同一的标准。

2、架构上内核之上的则是lib了，也就是模块。这个两者没有太大的差别。 linux的lib也是可以随便定制的。android也一样。 但是lib是要依赖底包的。

3、应用的区别，lib之上是各种应用。 这个可以理解为软件。 这一个层面就没啥不同之处可讲了。 就是一个开发问题了。

总体来说呢，android采用了linux系统的开发思想跟工作原理。 lib这个中间层很多都是照搬linux核心lib重新定制开发的。 所以，说android是一种嵌入式定制的linux系统也是可以的。

③ linux操作系统所说的i386和x86有什么区别

x86 包含 i386 ，i386 仅仅是 x86 的一部分。
x86 这里的 x 本来就是一个未知数性质的，他可以是 3、4、5、6、7 。

x86 是 Intel 建立起来的 CPU 架构。
他的 8086、8088、80286、80386、80486、Pentium 、Pentium Pro 、Pentium MMX ，Pentium 2 ，还有后面的 P3、P4 、PD 、Core 全系列，Xeon 的 x86 系列。以及 AMD 的 Intel 架构兼容全系列（楼主的 AMD 肯定也是啦，非 x86 架构如果楼主作为桌面计算机用上了，肯定不会来这里问这个问题了）。当然还有最近重新崛起的 VIA 的 C7 系列。
他们都是 x86 架构。

更多的 x86 代表的是 32 位的 Intel CPU 架构体系。

但其中分成很多代。i386 就是 80386 的那代 CPU 的标准，主要是支持 32 位的保护模式和实模式两种工作环境。这个功能很好很强大，一直沿用至今，而且系统对于这个功能是必须支持的。386 之后的 cpu 是完全兼容 i386 体系的。

i486 加入了新的一个功能，i586 （奔腾 1 代系列）又加入了新功能，i686 （奔腾 Pro 系列以后）又加入了新的功能体系。
i386 的软件可以运行在 i686 系统，但是 i686 的软件不能运行在之前的架构上。

旧 CPU 不能运行新软件主要是不能使用新的特性导致不能运行，但是旧的架构软件在新的架构上运行，仅仅是不能用新的功能体系，运行效率是没有减少的。
而且这个功能架构主要是 Linux 内核在使用。

所以楼主不要考虑 i386 和 x86 的关系。只要看到 i 什么 86 ，基本都能用。
如果有 i686 ，楼主的 CPU 只要不是 K6 系列，而是 Athlon 系列，最好选择 i686 ，但如果只有 i386 的，楼主注意安装后看看你的内核是不是 i686 体系的，如果是，性能不受影响。

题外：
i786 是一个隐藏的新体系，听说只能用在 P4 以后的 Intel CPU 上面。但是很多软件没有针对这个架构编写，所以除非自己基于 i786 编译，不然网上没有 i786 的软件。

这里还要说 x86_64 体系，这个是 AMD 提出并且最先使用的 x86 新的架构体系。他把 32 位的 i686 架构体系，扩展为 64 位。
但是因为变动很大的原因，64 位的系统软件要兼容 32 位的软件，需要在内核里打开支持，并且安装 32 位的兼容库才行。其实如果你有源代码，32位系统的源代码基本上可以直接在 64 位的系统上面编译成为 64 位架构可运行的软件（新的技术还是用不上）。

同样 64 位的 CPU 兼容上一代的 i686 架构，i686 CPU 不支持 x86_64 的软件。

如果楼主的 AMD CPU 是 Athlon 64 及其以后的 cpu 可以装 x86_64 的系统玩玩，不过注意，很多 32 位特有的软件，而且没有源代码的要么不能用，要么需要 32 位兼容库，Flash 的浏览器插件就是一个例子。64位的 Firefox 需要 32 位兼容库才能借助 Flash 插件显示 Flash 动画。Adobe 没有放出 64 位的插件，也没有提供源代码。

AMD 总是有新的点子，新的技术，却总是拼不过 Intel 的缓慢的技术革新。

④ 为什么x86和arm的架构不同，但是都能装linux呢，他们的编译时如何实现的。

rm架构和x86架构区别：

一、性能：

X86结构的电脑无论如何都比ARM结构的系统在性能方面要快得多、强得多。X86的CPU随便就是1G以上、双核、四核大行其道，通常使用45nm（甚至更高级）制程的工艺进行生产；

而ARM方面：CPU通常是几百兆，最近才出现1G左右的CPU，制程通常使用不到65nm制程的工艺，可以说在性能和生产工艺方面ARM根本不是X86结构系统的对手。

但ARM的优势不在于性能强大而在于效率，ARM采用RISC流水线指令集，在完成综合性工作方面根本就处于劣势，而在一些任务相对固定的应用场合其优势就能发挥得淋漓尽致。

二、扩展能力：

X86结构的电脑采用“桥”的方式与扩展设备（如：硬盘、内存等）进行连接，而且x86结构的电脑出现了近30年，其配套扩展的设备种类多、价格也比较便宜，所以x86结构的电脑能很容易进行性能扩展，如增加内存、硬盘等。

ARM结构的电脑是通过专用的数据接口使CPU与数据存储设备进行连接，所以ARM的存储、内存等性能扩展难以进行（一般在产品设计时已经定好其内存及数据存储的容量），所以采用ARM结构的系统，一般不考虑扩展。基本奉行“够用就好”的原则。

三实现编译：

因为linux是系统，他支持现在大多数的结构体系。而要使他移植到相应的不同的硬件平台上时，需要对内核源码进行相对应的交叉编译处理，然后才能进行烧写运行，因为都有驱动只要那个系统有对应平台的驱动就可以。

(4)x86下linux工程师扩展阅读：

Linux常用命令

1、pwd命令该命令的英文解释为print working directory(打印工作目录)。

2、输入pwd命令，Linux会输出当前目录。

3、cd命令cd命令用来改变所在目录。

4、cd / 转到根目录中

5、cd ~ 转到/home/user用户目录下

6、cd /usr 转到根目录下的usr目录中-------------绝对路径

7、cd test 转到当前目录下的test子目录中-------相对路径

8、cat命令可以用来合并文件，也可以用来在屏幕上显示整个文件的内容。

9、cat snow.txt 该命令显示文件snow.txt的内容，ctrl+D退出cat。

⑤ x86电脑能装linux系统么

可以，咱们的配置差不多，我就玩过但是不很习惯，

http://download.chinaunix.net/
这里去下载Linux去，只有你不会用的，全！！

ubuntu、 红旗和小红帽都用过，不熟，呵呵……

⑥ intel x86+linux是属于嵌入式的吗

嵌入式是看用途，而不是看硬件。
不过……
x86 耗电量很大……在某些便携设备上本来就电量不足，x86 就施展不开了。

建议楼主看看 power + 嵌入式，交换机经常用这种 CPU ，其次还有国产的龙芯，MIPS 的。

相对来说，我觉得数码产品类更有前途，因为他的需求量要比交换机等专用设备大，市场大品种多，相对前途更广。不过交换机相对更容易赚钱。专用设备的利润更大，而且竞争不如数码产品厉害。

⑦ 嵌入式linux和普通x86上的linux支持的软件区别

嵌入式是指超轻型的系统。
一般嵌入式所用的 CPU 多为 arm 架构的 CPU 。这个架构是特殊设计的，与 X86 不兼容。所以两个系统的二进制程序不同用。

对于 Linux 来说，他们的源代码大部分是通用的（除了那些针对某种 CPU 或者设备进行特殊算法优化的，或者没有避让某些架构对于源代码编写的特殊要求的）。基本只要他们需要的软件库能提供，需要的其他软件能提供，就可以在任何 Linux 支持的设备上面运行。

但嵌入式又有一个问题，他是超轻型的，所以他不可能像 x86 计算机那样装一套 1DVD 的 Linux （完全安装一个 DVD 的 Linux ，一般实际需要 8G 左右的硬盘空间）。嵌入式一般体积不超 128M，甚至只有 4M 空间可用 ，一般都在 32M-64M 之间的容量。这样对于软件来说，不可能完全提供足够的软件功能库或者软件。

结果就是，他们的软件“理论上”“源代码级别”的通用，但却又有实际限制。
当然对于嵌入式高手或者超级财主来说，这些都不是问题。
主要还是看具体的限制了。

⑧ linux x86下的程序移植到arm板子上需要做哪些

需要交叉编译后，将编译出的文件放到板子上执行。
交叉编译器arm-linux-gcc或者arm-linux-g++，过程比较复杂，一时是说不清楚的。
建议多看些资料，了解一下原理

⑨ NVIDIA-Linux-x86-260.19.44 能不能对Linux支持双显卡切换

不支持 nvidIA 还没出这个 版本的双显卡 驱动程序 直接用独显好了

⑩ x86架构下linux驱动编程 看什么书

编写好驱动,通过挂载的方法将驱动程序挂载到内核里面,大致步骤如下:
一: 1>建立以.c为后缀的c语言程序文件(里面包含了设备名及设备号等)
2>建立Makefile文件(作用是通过make来产生设备文件*.ko文件,里面可以建立自己的平台所需的设备文件如:arm等).make产生相应的设备文件
二: 要在/dev下建立相应的设备结点(设备名),用insomd *.ko命令将相应的驱动设备文件挂载到内核中.
三:编写测试文件(.c文件)用来测试内核是否已近成功挂载到内核.(编写好相应的测试文件后,用gcc –o Filename Filename.c(测试文件名)来产生相应的可执行文件).
四:如果设备驱动挂载成功,当执行测试文件(./Filename)时会产生相应的结果.

五:可能用到的相关命令:
1.lsmod:列出内核已经载入模块的专题.
输出:
Mole(模块名)size(大小)used by (被..使用)
2.demop:分析可加载模块的依赖性,生成moles.dep文件和映射文件
3.uname –r 显示内核版本(在编写Makefile时使用到)
4.modprobe : linux内核添加和删除模块(相关参数请查看man帮助文档)
5.modinfo:显示内核模块的信息.
6.insmod: 向linux内核中加载一个模块,用法:insmod[filename] [mole options…]
7.rmmod: 删除内核中的模块, 用法: rmmod [-f,w,s,v][molename]
8.dmesg: 显示内核缓冲区,内核的各种信息,内核启动时的信息会写入到/var/log/下.

六.例子1:
第一步：增加头文件和宏定义
#include <linux/fs.h>
#include <linux/types.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>
#include <linux/mole>
#include <linux/kernel>

第二步：添加与字符设备定义及注册有关的数据成员
//定义设备名称
#define DEVICE_NAME "test" //设备名
#define BUF_SIZE 1024
static char tmpbuf[BUF_SIZE];

//定义主次设备号
static unsigned int TestMajor=0; //主
static unsigned int TestMinor=0; //次

static struct cdev *test_cdev;
static dev_t dev;

第三步：增加open/release函数

static int test_chardev_open(struct inode *inode,struct file *file)
{
printk("open major=%d, minor=%d\n", imajor(inode),
iminor(inode));
return 0;
}

static int test_chardev_release(struct inode *inode,struct file *file)
{
printk("close major=%d,minor=%d\n",imajor(inode),
iminor(inode));
return 0;
}

第四步：增加read函数
static ssize_t test_chardev_read(struct file *file,char __user *buf,
size_t const count,loff_t *offset)
{
if(count < BUF_SIZE)
{
if(_to_user(buf,tmpbuf,count))
{
printk(" to user fail \n");
return -EFAULT;
}
}else{
printk("read size must be less than %d\n", BUF_SIZE);
return -EINVAL;
}
*offset += count;
return count;
}

第五步：增加write函数
static ssize_t test_chardev_write(struct file *file, const char __user*buf,size_t const count,loff_t *offset)
{
if(count < BUF_SIZE)
{
if(_from_user(tmpbuf,buf,count))
{
printk(" from user fail \n");
return -EFAULT;
}
}else{

printk("size must be less than %d\n", BUF_SIZE);
return -EINVAL;
}
*offset += count;
return count;
}

第六步：添加增加file_operations成员

static struct file_operations chardev_fops={
.owner = THIS_MODULE,
.read = test_chardev_read,
.write = test_chardev_write,
.open = test_chardev_open,
.release = test_chardev_release,
};

第七步：在模块的入口添加设备的设备号获取及设备注册
static int __init chrdev_init(void)
{
int result;

if(TestMajor)
{
dev=MKDEV(TestMajor,TestMinor);//创建设备编号
result=register_chrdev_region(dev,1,DEVICE_NAME);
} else {
result=alloc_chrdev_region(&dev,TestMinor,1,DEVICE_NAME);
TestMajor=MAJOR(dev);
}
if(result<0)
{
printk(KERN_WARNING"LED: cannot get major %d \n",TestMajor);
return result;
}

test_cdev=cdev_alloc();
cdev_init(test_cdev,&chardev_fops);
//test_cdev->ops=&chardev_fops;
test_cdev->owner=THIS_MODULE;
result=cdev_add(test_cdev,dev,1);
if(result)
printk("<1>Error %d while register led device!\n",result);

return 0;
}

第八步：在模块的出口函数增加设备设备号释放及设备注销函数

unregister_chrdev_region(MKDEV(TestMajor,TestMinor),1);
cdev_del(test_cdev);

第九步：编译并加载该模块

第十步：根据设备号的设置，在文件系统中建立对应的设备节点
#mknod /dev/test c XXX XX

例子2:
驱动文件:
#include <linux/init.h>
#include <linux/mole.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/kernel.h>
#include <linux/uaccess.h>

#define DEVICENAME "ccccc"

unsigned int major=221;
unsigned int minor=0;
struct cdev *abc;
dev_t dev;
static char bufrh[1024]="read success!";

static int aaaaa_open(struct inode *inodep, struct file *filep)
{
printk("read success!\n");
return 0;
}

int aaaaa_release(struct inode *inodep, struct file *filep)
{
return 0;
}
static ssize_t aaaaa_read (struct file *filep, char __user *buf, size_tcount, loff_t *offset)
{
if(_to_user(buf, bufrh, 1))
{
printk("_to_user fail!\n");
}
return 0;
}

ssize_t aaaaa_write (struct file *filep, const char __user *buf,size_t count, loff_t *offse)
{
printk("write!\n");
return 0;
}

static const struct file_operations fops = {
.owner = THIS_MODULE,
.open = aaaaa_open,
.release = aaaaa_release,
.read = aaaaa_read,
.write = aaaaa_write,

};

static int __init aaaaa_init(void)
{
int a;
dev=MKDEV(major, minor);
a=register_chrdev_region(dev, 1, DEVICENAME);

abc=cdev_alloc();
abc->owner=THIS_MODULE;
cdev_init(abc, &fops);

cdev_add(abc, dev, 1);

return 0;
}

static void __exit aaaaa_cleanup(void)
{
cdev_del(abc);
unregister_chrdev_region(dev, 1);
}

mole_init(aaaaa_init);
mole_exit(aaaaa_cleanup);
MODULE_LICENSE("GPL ");

Makefile文件:

obj-m += firstqd.o(相应设备文件名)

KERDIR = /usr/src/linux-headers-2.6.32-24-generic
#KERDIR=/home/linux2.6/linux #arm骞冲彴
PWD=$(shell pwd)

moles:
$(MAKE) -C $(KERDIR) M=$(PWD)moles

pc:
gcc -o fristqd firstqd.c
arm:
arm-linux-gcc -o fristqd firstqd.c

clean:
rm -rf *.o *~core *.depend *.cmd *.ko *.mod.c *.tmp_versions

测试文件(test.c):

#include <stdio.h>
#include <sys/types.h>
#include <fcntl.h>

char buf[1024];
char bufw[1024]="write success";
int main()
{
int fd,m,n;
fd=open("/dev/aaa",O_RDWR);
if (fd)
{
m=read(fd,buf,100);
printf("read kernel:%s\n",buf);

n=write(fd,bufw,10);
}
//printf("ni hao");
return 0;

}