书籍详情

Linux操作系统内核分析

Linux操作系统内核分析

作者:陈莉君编著

出版社:人民邮电出版社

出版时间:2000-01-01

ISBN:9787115083739

定价:¥40.00

购买这本书可以去
内容简介
  自由软件Linux操作系统源代码的开放,为我们掌握操作系统核心技术提供了良好的条件。本书共分十三章 ,对Linux内核进行了较全面的分析,既包括了对进程调度、内存管理、进程间通信、虚拟文件系统、设备驱动程序及网络子系统的分析,也包括对Linux整体结构的把握、Linux启动过程的剖析以及Linux独具特色的模块机制的分析与应用等。这些内容对于那些准备深入Linux操作系统内部、阅读Linux内核源代码的读者具有非常高的参考价值。Linux应用开发、管理人员,大专院校相关专业师生,以及对Linux感兴趣的用户均可从本书中受益。
作者简介
暂缺《Linux操作系统内核分析》作者简介
目录
第一章 走进Linux                  
  1. 1 GNU与Linux的成长                  
  1. 2 Linux的开发模式和运作机制                  
  1. 3 走进Linux内核                  
  1. 3. 1 Linux内核的特征                  
  1. 3. 2 Linux内核版本的变化                  
  1. 4 分析Linux内核的意义                  
  1. 4. 1 开发适合自己的操作系统                  
  1. 4. 2 开发高水平软件                  
  1. 4. 3 有助于计算机科学的教学和科研                  
 第二章 Linux操作系统结构                  
  2. 1 Linux的抽象结构                  
  2. 1. 1 概述                  
  2. 1. 2 Linux内核的作用                  
  2. 1. 3 Linux内核的抽象结构                  
  2. 1. 4 系统数据结构                  
  2. 2 Linux的具体结构                  
  2. 3 进程调度子系统                  
  2. 3. 1 子系统描述                  
  2. 3. 2 功能                  
  2. 3. 3 接口                  
  2. 3. 4 数据结构                  
  2. 3. 5 子系统结构                  
  2. 3. 6 子系统依赖关系                  
  2. 4 内存管理子系统                  
  2. 4. 1 子系统描述                  
  2. 4. 2 功能                  
  2. 4. 3 接口                  
  2. 4. 4 数据结构                  
  2. 4. 5 子系统结构                  
  2. 4. 6 子系统依赖关系                  
  2. 5 虚拟文件系统                  
  2. 5. 1 子系统描述                  
  2. 5. 2 功能                  
  2. 5. 3 接口                  
  2. 5. 4 数据结构                  
  2. 5. 5 子系统结构                  
  2. 5. 6 子系统依赖关系                  
  2. 6 进程间通信(IPC)                  
  2. 6. 1 子系统描述                  
  2. 6. 2 功能                  
  2. 6. 3 接口                  
  2. 6. 4 数据结构                  
  2. 6. 5 子系统结构                  
  2. 6. 6 子系统的依赖关系                  
  2. 7 网络接口                  
  2. 7. 1 Linux的网络层                  
  2. 7. 2 接口                  
  2. 7. 3 子系统描述                  
  2. 7. 4 数据结构                  
  2. 7. 5 子系统结构                  
  2. 7. 6 子系统依赖关系                  
  2. 8 Linux内核源代码                  
  2. 8. 1 多版本的内核源代码                  
  2. 8. 2 Linux内核源代码的结构                  
  2. 8. 3 从何处开始阅读源代码                  
  2. 9 常用术语的定义                  
 第三章 进程调度                  
  3. 1 进程描述                  
  3. 1. 1 进程和程序(Process and Program)                  
  3. 1. 2 Linux中的进程概述                  
  3. 1. 3 task_struct结构描述                  
  3. 1. 4 task_struct数据结构                  
  3. 2 Linux时间系统                  
  3. 2. 1 时钟硬件及时钟运作机制                  
  3. 2. 2 千年危机(千年虫)简介                  
  3. 2. 3 Linux时间系统                  
  3. 2. 4 时钟中断                  
  3. 3 Linux的调度程序——Schedule()                  
  3. 3. 1 基本原理                  
  3. 3. 2 Linux进程调度时机                  
  3. 3. 3 进程调度的依据                  
  3. 3. 4 可运行队列(Runnable Queue)                  
  3. 3. 5 进程调度(调度正文)的工作流程                  
  3. 3. 6 调度程序流程图                  
  3. 4 Linux内核机制                  
  3. 4. 1 内核机制的引入                  
  3. 4. 2 Linux内核机制                  
  3. 4. 3 任务队列(Task Queue)                  
  3. 4. 4 定时器内核例程处理程序(timer bottom half handler)                  
 第四章 保护模式                  
  4. 1 虚拟存储器                  
  4. 1. 1 虚地址和虚地址空间                  
  4. 1. 2 段机制和分页机制                  
  4. 1. 3 保护                  
  4. 2 描述符                  
  4. 2. 1 段机制                  
  4. 2. 2 描述符的概念                  
  4. 2. 3 系统段描述符                  
  4. 2. 4 门描述符                  
  4. 3 描述符表和寻址方式                  
  4. 3. 1 描述符表                  
  4. 3. 2 选择器与描述符表                  
  4. 3. 3 描述符投影寄存器                  
  4. 4 分页机制                  
  4. 4. 1 状态和控制寄存器                  
  4. 4. 2 分页机构                  
  4. 4. 3 页面高速缓冲寄存                  
  4. 5 控制转移和任务切换                  
  4. 5. 1 控制转移                  
  4. 5. 2 调用门                  
  4. 5. 3 任务切换                  
  4. 6 小结                  
 第五章 Linux启动系统                  
  5. 1 初始化流程                  
  5. 1. 1 系统加电或复位                  
  5. 1. 2 BIOS启动                  
  5. 1. 3 Boot Loader                  
  5. 1. 4 操作系统的初始化                  
  5. 2 初始化的任务                  
  5. 2. 1 处理器对初始化的影响                  
  5. 2. 2 其他硬件设备对初始化的影响                  
  5. 3 Linux的Boot Loader                  
  5. 3. 1 软盘的结构                  
  5. 3. 2 硬盘的结构                  
  5. 3. 3 Boot Loader                  
  5. 3. 4 LILO                  
  5. 3. 5 LILO的运行分析                  
  5. 4 进入操作系统                  
  5. 4. 1 Setup. S                  
  5. 4. 2 Head. S                  
  5. 5 main. c中的初始化                  
  5. 6 建立init进程                  
  5. 6. 1 init进程的建立                  
  5. 6. 2 启动所需的Shell脚本文件                  
 第六章 Linux内存管理                  
  6. 1 Linux的虚拟内存管理                  
  6. 1. 1 Linux虚拟内存的实现结构                  
  6. 1. 2 多任务及保护                  
  6. 1. 3 内核空间和用户空间                  
  6. 1. 4 Linux虚拟内存实现机制间的关系                  
  6. 2 地址映射机制                  
  6. 2. 1 地址映射的数据结构                  
  6. 2. 2 进程的虚拟内存                  
  6. 2. 3 内存映射                  
  6. 3 请页机制                  
  6. 3. 1 页故障的产生                  
  6. 3. 2 页错误的定位                  
  6. 3. 3 页错误处理程序                  
  6. 3. 4 几点说明                  
  6. 4 交换机制                  
  6. 4. 1 页交换的方法                  
  6. 4. 2 交换守护进程(kswapd)的分析                  
  6. 4. 3 交换空间的数据结构                  
  6. 4. 4 交换空间的应用                  
  6. 5 内存分配和回收机制                  
  6. 5. 1 分配策略                  
  6. 5. 2 系统级调用分配过程和释放过程                  
  6. 5. 3 用户级内存分配释放函数                  
  6. 6 缓存和刷新机制                  
  6. 6. 1 Linux使用的缓存                  
  6. 6. 2 缓冲区高速缓存                  
  6. 6. 3 翻译后援存储器(TBL)                  
  6. 6. 4 刷新机制                  
  6. 7 进程的创建和执行                  
  6. 7. 1 进程的创建                  
  6. 7. 2 程序执行                  
  6. 7. 3 执行函数                  
  6. 8 内存共享机制                  
  6. 9 内存初始化                  
  6. 9. 1. 内存初始化过程                  
  6. 9. 2 进入用户模式                  
 第七章 进程间通信                  
  7. 1 管道                  
  7. 1. 1 Linux管道的实现机制                  
  7. 1. 2 管道的应用                  
  7. 1. 3 命名管道(FIFO)                  
  7. 2 System V的IPC机制                  
  7. 2. 1 信号量                  
  7. 2. 2 消息队列                  
  7. 2. 3 共享内存                  
  7. 3 信号(signal)                  
  7. 3. 1 信号的引入                  
  7. 3. 2 信号掩码                  
  7. 3. 3 系统调用                  
  7. 3. 4 典型系统调用的实现                  
  7. 3. 5 进程与信号的关系                  
  7. 3. 6 信号举例                  
 第八章 虚拟文件系统                  
  8. 1 概述                  
  8. 2 VFS中的重要数据结构                  
  8. 2. 1 VFS的超级块                  
  8. 2. 2 VFS的索引节点                  
  8. 2. 3 与进程联系的三个结构                  
  8. 2. 4 有关操作的数据结构                  
  8. 3 高速缓存                  
  8. 3. 1 块高速缓存                  
  8. 3. 2 索引节点高速缓存                  
  8. 3. 3 目录高速缓存                  
  8. 4 文件系统的注册. 安装与卸载                  
  8. 4. 1 文件系统的注册                  
  8. 4. 2 文件系统的安装                  
  8. 4. 3 文件系统的卸载                  
  8. 5 限额机制                  
  8. 6 文件系统的系统调用                  
  8. 6. 1 open系统调用                  
  8. 6. 2 read系统调用                  
  8. 6. 3 fcntl系统调用                  
 第九章 EXT2文件系统                  
  9. 1 基本概念                  
  9. 2 EXT2的磁盘布局和数据结构                  
  9. 2. 1 EXT2的磁盘布局                  
  9. 2. 2 EXT2的超级块                  
  9. 2. 3 EXT2的索引节点                  
  9. 2. 4 组描述符                  
  9. 2. 5 位图                  
  9. 2. 6 索引节点表及举例                  
  9. 2. 7 EXT2的目录项及文件的定位                  
  9. 3 文件的访问权限和安全                  
  9. 4 链接文件                  
  9. 5 错误处理                  
  9. 6 分配策略                  
 第十章 模块机制                  
  10. 1 概述                  
  10. 1. 1 什么是模块                  
  10. 1. 2 为什么要使用模块                  
  10. 1. 3 Linux内核模块的优缺点                  
  10. 2 实现机制                  
  10. 2. 1 数据结构                  
  10. 2. 2 实现函数的分析                  
  10. 2. 3 模块的装入                  
  10. 3 卸载(unload)一个模块                  
  10. 4 编写内核模块                  
  10. 4. 1 内核的复制函数                  
  10. 4. 2 内核版本2. 0. 35与2. 2. 3之间的变化                  
  10. 4. 3 简单内核模块的编写                  
  10. 4. 4 内核模块的Makefiles文件                  
  10. 4. 5 内核模块的多个文件                  
  10. 5 系统调用                  
  10. 6 模块实用程序                  
 第十一章 设备驱动程序                  
  11. 1 Linux的设备管理                  
  11. 1. 1 I/O软件                  
  11. 1. 2 设备驱动程序                  
  11. 1. 3 Linux驱动程序的几个通用函数                  
  11. 2 中断                  
  11. 2. 1 硬件对中断的支持                  
  11. 2. 2 Linux对中断的管理                  
  11. 2. 3 Linux对中断的处理                  
  11. 3 块设备驱动程序                  
  11. 3. l 块设备驱动程序的登记                  
  11. 3. 2 块设备基于缓冲区的数据交换                  
  11. 3. 3 块设备驱动程序的几个函数                  
  11. 3. 4 RAM盘驱动程序的实现                  
  11. 3. 5 硬盘驱动程序的实现                  
  11. 4 字符设备驱动程序                  
  11. 4. 1 字符设备的注册                  
  11. 4. 2 工作内存                  
  11. 4. 3 基本入口点                  
  11. 4. 4 一个字符设备驱动程序的实例                  
  11. 4. 5 驱动程序的编译与装载                  
 第十二章 Linux系统调用机制                  
  12. 1 基本原理                  
  12. 2 系统调用的初始化                  
  12. 3 Linux系统调用的执行                  
  12. 4 增加新的系统调用                  
  12. 4. 1 编写一个系统调用                  
  12. 4. 2 连接新的系统调用                  
  12. 4. 3 使用新的系统调用                  
 第十三章 网络                  
  13. 1 概述                  
  13. 2 网络协议                  
  13. 2. 1 网络参考模型                  
  13. 2. 2 TCP/IP协议工作原理及数据流                  
  13. 2. 3 Internet协议                  
  13. 2. 4 TCP协议                  
  13. 3 套接字(socket)                  
  13. 3. 1 套接字在网络中的地位和作用                  
  13. 3. 2 套接字接口的种类                  
  13. 3. 3 套接字的工作原理                  
  13. 3. 4 socket的通信过程                  
  13. 3. 5 和套接字相关的数据结构                  
  13. 3. 6 socket为用户提供的系统调用                  
  13. 4 套接字缓冲区(sk_buff)                  
  13. 4. 1 套接字缓冲区的特点                  
  13. 4. 2 套接字缓冲区操作基本原理                  
  13. 4. 3 sk_buff数据结构的核心内容                  
  13. 4. 4 套接字缓冲区提供的函数                  
  13. 4. 5 套接字缓冲区的上层支持例程                  
  13. 4. 6 sk_buff数据结构                  
  13. 5 网络设备接口                  
  13. 5. 1 基本结构                  
  13. 5. 2 命名规则                  
  13. 5. 3 设备注册                  
  13. 5. 4 网络设备数据结构                  

猜您喜欢

读书导航