精华内容
下载资源
问答
  • 内核开发和开发实践环境。 pwn.college用于内核开发和利用的帮助程序环境先决条件:构建内核,busybox和演示模块:$ ./build.sh运行内核:$ ./launch.sh所有模块都将位于/中,并且随时可以插入后,主机的主目录将在...
  • 内核开发.rar

    2011-10-14 02:13:59
    内核开发.rar内核开发.r内核开发.rarar
  • 详细描述vxworks内核开发文档,介绍内核开发所需要的问题,对从事vxworks开发的大有裨益
  • windows内核开发

    2009-11-26 12:36:34
    windows内核开发宝典,内核开发权威书籍
  • archlinux内核开发

    千次阅读 2016-10-15 18:16:48
    archlinux内核开发前文介绍了如何安装archlinux,这里主要对archlinux内核修改/定制进行介绍。(因为自己写模块问题,模块编译入内核,但一直没执行,以为内核没更新到,由于国内运行archlinux的机器少,对内核开发...

    archlinux内核开发

    前文介绍了如何安装archlinux,这里主要对archlinux内核修改/定制进行介绍。(因为自己写模块问题,模块编译入内核,但一直没执行,以为内核没更新到,由于国内运行archlinux的机器少,对内核开发的更少,没地方交流,中间卡了2天时间,希望对修改内核的开发者有帮助,少走弯路。)

    ABS安装官方内核

    ABS介绍见官方WIKI,我们将用它来制作内核安装包。
    - 安装ABS工具

    pacman -S abs
    • 获取ABS目录树
    abs
    • 创建archlinux工作目录,并将ABS同步下来的包放到该目录下
    mkdir ~/archlinux
    cp /var/abs/core/linux ~/archlinux/
    ///archlinux/linux文件内容如下
    //补丁文件:change-default-console-loglevel.patch
    //kernel的配置文件:config  config.4.8  config.x86_64  config.x86_64.4.8  
    //安装脚本:linux.install
    //mkinitcpio配置文件,mkinitcpio是制作initrd的工具:linux.preset  
    //制作包的主脚本:PKGBUILD
    • 制作ABS安装包
    makepkg -s
    //这一步会根据PKGBUILD脚本中的"source"字段的地址去下载linux源码,时间非常长。如果手上有LINUX源代码可以修改PKGBUILD脚本来用本地代码进行制包,后续的错误也可以通过手动修改PKGBUILD来避开。

    错误1:缺少依赖

    ==> Making package: linux 4.7.6-1 (Sat Oct 15 17:42:03 CST 2016)
    ==> Checking runtime dependencies...
    ==> Checking buildtime dependencies...
    warning: no 'XferCommand' configured
    ==> Missing dependencies:
      -> xmlto
      -> docbook-xsl
      -> kmod
      -> inetutils
      -> bc
      -> libelf
    ==> ERROR: Could not resolve all dependencies.

    解决办法

    //打开PKGBUILD脚本文件,把依赖注释掉,去掉此部分不会影响生成,只是文档相关的。
    #makedepends=('xmlto' 'docbook-xsl' 'kmod' 'inetutils' 'bc' 'libelf')

    错误2:makepkg错误

    oeh@EMVR-R1:~/archlinux/linux$ makepkg -s
    ==> Making package: linux 4.7.6-1 (Sat Oct 15 17:02:07 CST 2016)
    ==> Checking runtime dependencies...
    ==> Checking buildtime dependencies...
    ==> Retrieving sources...
      -> Found linux-4.7.tar.xz
      -> Found linux-4.7.tar.sign
      -> Found patch-4.7.6.xz
      -> Found patch-4.7.6.sign
      -> Found config
      -> Found config.x86_64
      -> Found linux.preset
    ==> Validating source files with sha256sums...
        linux-4.7.tar.xz ... Passed
        linux-4.7.tar.sign ... Skipped
        patch-4.7.6.xz ... Passed
        patch-4.7.6.sign ... Skipped
        config ... Passed
        config.x86_64 ... Passed
        linux.preset ... Passed
    ==> Verifying source file signatures with gpg...
        linux-4.7.tar ... FAILED (unknown public key 79BE3E4300411886)
        patch-4.7.6 ... FAILED (unknown public key 38DBBDC86092693E)
    ==> ERROR: One or more PGP signatures could not be verified!

    解决办法

    //编译时先忽略签名
    makepkg --skippgpcheck -s

    错误3:找不到补丁文件

    patch: **** Can't open patch file /home/oeh/archlinux/linux/src/change-default-console-loglevel.patch : No such file or directory
    ==> ERROR: A failure occurred in prepare().
        Aborting...

    解决办法

    //手动拷贝补丁文件到指定目录
    oeh@EMVR-R1:~/archlinux/linux$ cp ~/archlinux/linux/change-default-console-loglevel.patch /home/oeh/archlinux/linux/src/

    编译成功后,将在PKGBUILD同级目录下生成安装包文件”linux-4.7.6-1-x86_64.pkg.tar.gz”,”linux-headers-4.7.6-1-x86_64.pkg.tar.gz”.

    //在目标板上安装内核包
    pacman -U linux-headers-4.7.6-1-x86_64.pkg.tar.gz
    pacman -U linux-4.7.6-1-x86_64.pkg.tar.gz

    基于官方内核定制/修改

    内核定制一般可以分为直接编译入内核和模块加载两种方式.
    - 编译入内核

    1.修改内核代码
    2.生成bzImage:
    make bzImage
    3.拷贝bzImage到目标板的/boot目录下:
    cp arch/x86_64/boot/bzImage /boot/vmlinuz-linux
    4.制作initrd:
    mkinitcpio -p linux
    5.重启后就是新内核了:reboot
    • 模块加载
    1.修改模块代码
    2.修改安装目录:
    export INSTALL_MOD_PATH=./libmodules
    3.生成模块:
    make modules_install
    4.将生成的模块(*.ko)文件复制拷贝到目标板的/lib/modules/kernelversion目录中-ARCH即可

    后记

    搞好后,写下来感觉没什么内容,但自己在搞的时候过程是痛苦的,搞过之后学习到的东西也挺多的,archlinux的WIKI真的很棒,推荐这几个相关的链接:

    • arch_boot_process
      搞的过程中,经常把机器搞死了,搞清楚这里的流程后处理起来就方便很多。
    • mkinitcpio
      制作init ram disk的工具,碰到不少问题,如果在制作initrd有问题时,可以把这个脚本的源码跟了一下。
    • ABS:arch build system
      arch很有特色的安装系统,当然还有PKGBUILD
    展开全文
  • 内核配置参考 。。。linux内核开发
  • linux内核开发教程

    2012-01-11 18:12:28
    非常好的资源,对于学习Linux内核开发技术很有帮助。另外,对于那些想要从事Android驱动开发的人也是一个必学的资源。
  • 鸿蒙内核开发概述

    千次阅读 2020-09-18 15:00:51
    第一章 鸿蒙内核开发概述 1.1 鸿蒙系统有哪些内容? 鸿蒙系统,就相当于一套完整的PC软件系统。 Windows里含有: 简单地说,鸿蒙系统里含有 ① 电脑一开机,那些界面是谁显示的?是BIOS,它做什么?一些...

    在线课堂:https://www.100ask.net/index(课程观看)
    论  坛:http://bbs.100ask.net/(学术答疑)
    开 发 板:https://100ask.taobao.com/ (淘宝)
         https://weidongshan.tmall.com/(天猫)
    交流群一:QQ群:869222007(鸿蒙开发/Linux/嵌入式/驱动/资料下载)
    交流群二:QQ群:536785813(单片机-嵌入式)
    公 众 号:百问科技


    版本日期作者说明
    V12020韦东山技术文档

    第一章 鸿蒙内核开发概述

    1.1 鸿蒙系统有哪些内容?

    鸿蒙系统,就相当于一套完整的PC软件系统。
    在这里插入图片描述

    Windows里含有:简单地说,鸿蒙系统里含有
    ① 电脑一开机,那些界面是谁显示的?是BIOS,它做什么?一些自检,然后从硬盘上读入windows,并启动它。类似的,这个BIOS对应于鸿蒙里的bootloader。Bootloader的作用就是去Flash、SD卡等设备上读入鸿蒙内核,并启动它。
    ②Windows系统必需的软件,比如IE、文件浏览器等保存在哪里?在C盘上,里面有各种系统软件。对应的,系统运行必需的文件在鸿蒙系统中我们称之为根文件系统。
    ③windows能识别出C盘、D盘,那么肯定有读写硬盘的能力。这个能力我们称之为驱动程序。当然不仅仅是操作硬盘,还有网卡、USB等等其他硬件。Liteos-a能从Flash上读出并执行应用程序,肯定也得有Flash的驱动程序啊,当然也不仅仅是Flash。
    ④ Windows启动之后,我们就是聊QQ、玩游戏了,这些就是APP,它们存在磁盘上同样的,鸿蒙系统中也有各种APP,它们位于根文件系统上。
    ①bootloader:用于启动鸿蒙内核Liteos-a
    ②内核(含有驱动程序):提供进程管理、文件管理、硬件驱动等
    ③ 根文件系统:系统运行必需的文件、程序
    ④ APP:保存于根文件系统上

    1.2 日常工作中开发流程是怎样?

    Bootloader、内核、APP等等软件,需要在Ubuntu中编译;但是阅读、修改这些源码时,在Windows下会比较方便。
    所以,我们需要在Windows、Ubuntu上都存有源码。

    ① 在Windows上阅读、研究、修改(使用Source insight会很方便),修改后上传到Ubuntu(使用Filezilla)

    ② 在Ubuntu上编译、制作(使用MobaXterm远程登录Ubuntu会很方便)

    ③ 把制作好的可执行程序下载到开发板上运行、测试(使用MobaXterm连接开发板的串口)。

    在整个开发过程中,我们会用到Windows、Ubuntu、开发板,如下图所示:
    在这里插入图片描述

    1.3 搭建开发环境需要做哪些事情

    这里只是列出要做的事情,后面会一一讲到。

    1. 安装VMware、下载Ubuntu映象
    2. 安装Windows上各个APP
      这些APP有:SouceInsight、FileZilla、MobaXterm、Notepad++
    3. 下载源码和工具链
      使用repo命令在Ubuntu中下载,后面介绍。
    4. 连接开发板
      ① 连接电源线到开发板,
      ② 开发板的串口线,接到Windows电脑;并用MobaXterm连接串口。
    5. 烧写系统
      开发过程会不断编译程序、烧写、测试。
    展开全文
  • Linux 内核开发

    千次阅读 2018-11-08 23:27:35
    Linux 内核开发 简介 如你所知,我从去年开始写了一系列关于 x86_64 架构汇编语言程序设计的博文。除了大学期间写过一些 Hello World 这样无实用价值的程序之外,我从来没写过哪怕一行的底层代码。那些程序也...

    Linux 内核开发

    简介

    如你所知,我从去年开始写了一系列关于 x86_64 架构汇编语言程序设计的博文。除了大学期间写过一些 Hello World 这样无实用价值的程序之外,我从来没写过哪怕一行的底层代码。那些程序也是很久以前的事情了,就像我刚才说的,我几乎完全没有写过底层代码。直到不久前,我才开始对这些事情感兴趣,因为我意识到我虽然可以写出程序,但是我却不知道我的程序是怎样被组织运行的。

    在写了一些汇编代码之后,我开始大致了解了程序在编译之后会变成什么样子。尽管如此,还是有很多其他的东西我不能够理解。例如:当 syscall 指令在我的汇编程序内执行时究竟发生了什么,当 printf 函数开始工作时又发生了什么,还有,我的程序是如何通过网络与其他计算机进行通信的。汇编语言并没有为这些问题带来答案,于是我决定做一番深入研究。我开始学习 Linux 内核的源代码,并且尝试着理解那些让我感兴趣的东西。然而 Linux 内核源代码也没有解答我所有的问题,不过我自身关于 Linux 内核及其外围流程的知识确实掌握的更好了。

    在我开始学习 Linux 内核的九个半月之后,我写了这部分内容,并且发布了本书的第一部分。到现在为止,本书共包括了四个部分,而这并不是终点。我之所以写这一系列关于 Linux 内核的文章其实更多的是为了我自己。你也知道,Linux 内核的代码量极其巨大,另外还非常容易忘记这一块或那一块内核代码做了什么,或者忘记某些东西是怎么实现的。出乎意料的是 linux-insides 很快就火了,并且在九个月后积攒了 9096 个星星:

    github

    看起来人们对 Linux 内核的内在机制非常的感兴趣。除此之外,在我写 linux-insides 的这段时间里,我收到了很多人发来的问题,这些问题大都是关于如何开始向 Linux 内核贡献代码。通常来说,人们是很有兴趣为开源项目做贡献的,Linux 内核也不例外:

    google-linux

    这么看起来大家对 Linux 内核的开发流程非常感兴趣。我认为如果这么一本关于 Linux 内核的书却不包括一部分来讲讲如何参与 Linux 内核开发的话,那就非常奇怪了。这就是我决定写这篇文章的原因。在本文中,你不会看到为什么你应该对贡献 Linux 内核感兴趣,但是如果你想参与 Linux 内核开发的话,那这部分就是为你而作。

    让我们开始吧。

    如何入门 Linux 内核

    首先,让我们看看如何获取、构建并运行 Linux 内核。你可以通过两种方式来运行你自己定制的内核:

    • 在虚拟机里运行 Linux 内核;
    • 在真实的硬件上运行 Linux 内核。

    我会对这两种方式都展开描述。在我们开始对 Linux 内核做些什么之前,我们首先需要先获取它。根据你目的的不同,有两种方式可以做到这一点。如果你只是想更新一下你电脑上的 Linux 内核版本,那么你可以使用特定于你 Linux 发行版的命令。

    在这种情况下,你只需要使用软件包管理器下载新版本的 Linux 内核。例如,为了将 Ubuntu (Vivid Vervet) 系统的 Linux 内核更新至 4.1版本,你只需要执行以下命令:

     
    1. $ sudo add-apt-repository ppa:kernel-ppa/ppa

    2. $ sudo apt-get update

    在这之后,再执行下面的命令:

    $ apt-cache showpkg linux-headers
    

    然后选择你感兴趣的 Linux 内核的版本。最后,执行下面的命令并且将 ${version} 替换为你从上一条命令的输出中选择的版本号。

    $ sudo apt-get install linux-headers-${version} linux-headers-${version}-generic linux-image-${version}-generic --fix-missing
    

    最后重启你的系统。重启完成后,你将在 grub 菜单中看到新的内核。

    另一方面,如果你对 Linux 内核开发感兴趣,那么你就需要获得 Linux 内核的源代码。你可以在 kernel.org 网站上找到它并且下载一个包含了 Linux 内核源代码的归档文件。实际上,Linux 内核的开发流程完全建立在 git 版本控制系统之上,所以你需要通过 git 来从 kernel.org 上获取内核源代码:

    $ git clone git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
    

    我不知道你怎么看,但是我本身是非常喜欢 github 的。它上面有一个 Linux 内核主线仓库的镜像,你可以通过以下命令克隆它:

    $ git clone git@github.com:torvalds/linux.git
    

    我是用我自己 fork 的仓库来进行开发的,等到我想从主线仓库拉取更新的时候,我只需要执行下方的命令即可:

     
    1. $ git checkout master

    2. $ git pull upstream master

    注意这个主线仓库的远程主机名叫做 upstream。为了将主线 Linux 仓库添加为一个新的远程主机,你可以执行:

    git remote add upstream git@github.com:torvalds/linux.git
    

    在此之后,你将有两个远程主机:

     
    1. ~/dev/linux (master) $ git remote -v

    2. origin git@github.com:0xAX/linux.git (fetch)

    3. origin git@github.com:0xAX/linux.git (push)

    4. upstream https://github.com/torvalds/linux.git (fetch)

    5. upstream https://github.com/torvalds/linux.git (push)

    其中一个远程主机是你的 fork 仓库 (origin),另一个是主线仓库 (upstream)。

    现在,我们已经有了一份 Linux 内核源代码的本地副本,我们需要配置并编译内核。Linux 内核的配置有很多不同的方式,最简单的方式就是直接拷贝 /boot 目录下已安装内核的配置文件:

    $ sudo cp /boot/config-$(uname -r) ~/dev/linux/.config
    

    如果你当前的内核被编译为支持访问 /proc/config.gz 文件,你也可以使用以下命令复制当前内核的配置文件:

    $ cat /proc/config.gz | gunzip > ~/dev/linux/.config
    

    如果你对发行版维护者提供的标准内核配置文件并不满意,你也可以手动配置 Linux 内核,有两种方式可以做到这一点。Linux 内核的根 Makefile 文件提供了一系列可配置的目标选项。例如 menuconfig 为内核配置提供了一个菜单界面:

    menuconfig

    defconfig 参数会为当前的架构生成默认的内核配置文件,例如 x86_64 defconfig。你可以将 ARCH 命令行参数传递给 make,以此来为给定架构创建 defconfig 配置文件:

    $ make ARCH=arm64 defconfig
    

    allnoconfig、 allyesconfig 以及 allmodconfig 参数也允许你生成新的配置文件,其效果分别为尽可能多的选项都关闭、尽可能多的选项都启用或尽可能多的选项都作为模块启用。nconfig 命令行参数提供了基于 ncurses 的菜单程序来配置 Linux 内核:

    nconfig

    randconfig 参数甚至可以随机地生成 Linux 内核配置文件。我不会讨论如何去配置 Linux 内核或启用哪个选项,因为没有必要这么做:首先,我不知道你的硬件配置;其次,如果我知道了你的硬件配置,那么剩下的问题就是搞清楚如何使用程序生成内核配置,而这些程序的使用都是非常容易的。

    好了,我们现在有了 Linux 内核的源代码并且完成了配置。下一步就是编译 Linux 内核了。最简单的编译 Linux 内核的方式就是执行以下命令:

     
    1. $ make

    2. scripts/kconfig/conf --silentoldconfig Kconfig

    3. #

    4. # configuration written to .config

    5. #

    6. CHK include/config/kernel.release

    7. UPD include/config/kernel.release

    8. CHK include/generated/uapi/linux/version.h

    9. CHK include/generated/utsrelease.h

    10. ...

    11. ...

    12. ...

    13. OBJCOPY arch/x86/boot/vmlinux.bin

    14. AS arch/x86/boot/header.o

    15. LD arch/x86/boot/setup.elf

    16. OBJCOPY arch/x86/boot/setup.bin

    17. BUILD arch/x86/boot/bzImage

    18. Setup is 15740 bytes (padded to 15872 bytes).

    19. System is 4342 kB

    20. CRC 82703414

    21. Kernel: arch/x86/boot/bzImage is ready (#73)

    为了增加内核的编译速度,你可以给 make 传递命令行参数 -jN,这里的 N 指定了并发执行的命令数目:

    $ make -j8
    

    如果你想为一个架构构建一个与当前内核不同的内核,那么最简单的方式就是传递下面两个参数:

    • ARCH 命令行参数是目标架构名;
    • CROSS_COMPILER 命令行参数是交叉编译工具的前缀;

    例如,如果我们想使用默认内核配置文件为 arm64 架构编译 Linux 内核,我们需要执行以下命令:

     
    1. $ make -j4 ARCH=arm64 CROSS_COMPILER=aarch64-linux-gnu- defconfig

    2. $ make -j4 ARCH=arm64 CROSS_COMPILER=aarch64-linux-gnu-

    编译的结果就是你会看到压缩后的内核文件 - arch/x86/boot/bzImage。既然我们已经编译好了内核,那么就可以把它安装到我们的电脑上或者只是将它运行在模拟器里。

    安装 Linux 内核

    就像我之前写的,我们将考察两种运行新内核的方法:第一种情况,我们可以在真实的硬件上安装并运行新版本的 Linux 内核,第二种情况就是在虚拟机上运行 Linux 内核。在前面的段落中我们看到了如何从源代码来构建 Linux 内核,并且我们现在已经得到了内核的压缩镜像:

     
    1. ...

    2. ...

    3. ...

    4. Kernel: arch/x86/boot/bzImage is ready (#73)

    在我们获得了 bzImage 之后,我们需要使用以下命令来为新的 Linux 内核安装 headers 和 modules

     
    1. $ sudo make headers_install

    2. $ sudo make modules_install

    以及内核自身:

    $ sudo make install
    

    从这时起,我们已经安装好了新版本的 Linux 内核,现在我们需要通知 bootloader 新内核已经安装完成。我们当然可以手动编辑/boot/grub2/grub.cfg 配置文件并将新内核添加进去,但是我更推荐使用脚本来完成这件事。我现在在使用两种不同的 Linux 发行版:Fedora 和 Ubuntu,有两种方式可以用来更新 grub 配置文件,我目前正在使用下面的脚本来达到这一目的:

    #!/bin/bash
    
    source "term-colors"
    
    DISTRIBUTIVE=$(cat /etc/*-release | grep NAME | head -1 | sed -n -e 's/NAME\=//p')
    echo -e "Distributive: ${Green}${DISTRIBUTIVE}${Color_Off}"
    
    if [[ "$DISTRIBUTIVE" == "Fedora" ]] ;
    then
        su -c 'grub2-mkconfig -o /boot/grub2/grub.cfg'
    else
        sudo update-grub
    fi
    
    echo "${Green}Done.${Color_Off}"

    这是新 Linux 内核安装过程中的最后一步,在这之后你可以重启你的电脑,然后在启动过程中选择新版本的内核。

    第二种情况就是在虚拟机内运行新的 Linux 内核,我更倾向于使用 qemu。首先我们需要为此构建初始的虚拟内存盘 - initrdinitrd 是一个临时的根文件系统,它在初始化期间被 Linux 内核使用,而那时其他的文件系统尚未被挂载。我们可以使用以下命令构建 initrd

    首先我们需要下载 busybox,然后运行 menuconfig 命令配置它:

    $ mkdir initrd
    $ cd initrd
    $ curl http://busybox.net/downloads/busybox-1.23.2.tar.bz2 | tar xjf -
    $ cd busybox-1.23.2/
    $ make menuconfig
    $ make -j4

    busybox 是一个可执行文件 - /bin/busybox,它包括了一系列类似于 coreutils 的标准工具。在 busysbox 菜单界面上我们需要启用 Build BusyBox as a static binary (no shared libs) 选项:

    busysbox menu

    我们可以按照下方的路径找到这个菜单项:

     
    1. Busybox Settings

    2. --> Build Options

    之后,我们从 busysbox 的配置菜单退出去,然后执行下面的命令来构建并安装它:

     
    1. $ make -j4

    2. $ sudo make install

    既然 busybox 已经安装完了,那么我们就可以开始构建 initrd 了。为了完成构建过程,我们需要返回到之前的 initrd 目录并且运行命令:

     
    1. $ cd ..

    2. $ mkdir -p initramfs

    3. $ cd initramfs

    4. $ mkdir -pv {bin,sbin,etc,proc,sys,usr/{bin,sbin}}

    5. $ cp -av ../busybox-1.23.2/_install/* .

    这会把 busybox 复制到 bin 目录、sbin 目录以及其他相关目录内。现在我们需要创建可执行的 init 文件,该文件将会在系统内作为第一个进程执行。我的 init 文件仅仅挂载了 procfs 和 sysfs 文件系统并且执行了 shell 程序:

    #!/bin/sh
    
    mount -t proc none /proc
    mount -t sysfs none /sys
    
    exec /bin/sh

    最后,我们创建一个归档文件,这就是我们的 initrd 了:

    $ find . -print0 | cpio --null -ov --format=newc | gzip -9 > ~/dev/initrd_x86_64.gz
    

    我们现在可以在虚拟机里运行内核了。就像我之前写过的,我偏向于使用 qemu 来完成这些工作,下面的命令可以用来运行我们的 Linux 内核:

    $ qemu-system-x86_64 -snapshot -m 8GB -serial stdio -kernel ~/dev/linux/arch/x86_64/boot/bzImage -initrd ~/dev/initrd_x86_64.gz -append "root=/dev/sda1 ignore_loglevel"
    

    qemu

    从现在起,我们就可以在虚拟机内运行 Linux 内核了,这意味着我们可以开始对内核进行修改和测试了。

    除了上面的手动过程之外,还可以考虑使用 ivandaviov/minimal 来自动生成 initrd

    Linux 内核开发入门

    这部分的核心内容主要回答了两个问题:在你发送第一个 Linux 内核补丁之前你应该做什么 (to do) 和不能做什么 (not to do)。请千万不要把应该做的事 (to do) 和待办事项 (todo) 搞混了。我无法回答你能为 Linux 内核修复什么问题,我只是想告诉你我拿 Linux 内核源代码做实验的过程。

    首先,我需要使用以下命令从 Linus 的仓库中拉取最新的更新:

     
    1. $ git checkout master

    2. $ git pull upstream master

    在这之后,我的本地 Linux 内核源代码仓库已经和主线仓库同步了。现在我们可以在源代码上做些修改了。就像我之前写的,关于从哪开始修改或者可以做些什么,我并不能给你太多建议。不过,对于新手来说最好的地方就是 staging 源码树,也就是 drivers/staging 上的驱动集合。staging 源码树的主要维护者是 Greg Kroah-Hartman,该源码树正是你的琐碎补丁可以被接受的地方。让我们看一个简单的例子,该例子描述了如何生成补丁、检查补丁以及如何将补丁发送到 Linux 内核邮件列表

    如果我们查看一下为 Digi International EPCA PCI 基础设备所写的驱动程序,在 295 行我们将会看到 dgap_sindex 函数:

    static char *dgap_sindex(char *string, char *group)
    {
        char *ptr;
    
        if (!string || !group)
            return NULL;
    
        for (; *string; string++) {
            for (ptr = group; *ptr; ptr++) {
                if (*ptr == *string)
                    return string;
            }
        }
    
        return NULL;
    }

    这个函数查找 group 和 string 共有的字符并返回其位置。在研究 Linux 内核源代码期间,我注意到 lib/string.c 文件里实现了一个 strpbrk 函数,该函数和 dgap_sinidex 函数做了同样的事。使用现存函数的另一种自定义实现并不是一个好主意,所以我们可以从drivers/staging/dgap/dgap.c 源码文件中移除 dgap_sindex 函数并使用 strpbrk 替换它。

    首先,让我们基于当前主分支创建一个新的 git 分支,该分支与 Linux 内核主仓库同步:

    $ git checkout -b "dgap-remove-dgap_sindex"
    

    然后,我们可以将 dgap_sindex 函数替换为 strpbrk。做完这些修改之后,我们需要重新编译 Linux 内核或者只重编译 dgap 目录。不要忘了在内核配置文件中启用这个驱动,你可以在如下位置找到该驱动:

     
    1. Device Drivers

    2. --> Staging drivers

    3. ----> Digi EPCA PCI products

    dgap menu

    现在是时候提交修改了,我使用下面的命令组合来完成这件事:

     
    1. $ git add .

    2. $ git commit -s -v

    最后一条命令运行后将会打开一个编辑器,该编辑器会从 $GIT_EDITOR 或 $EDITOR 环境变量中进行选择。 -s 命令行参数会在提交信息的末尾按照提交者名字加上一行 Signed-off-by。你在每一条提交信息的最后都能看到这一行,例如 - 00cc1633。这一行的主要目的是追踪谁做的修改。-v 选项按照合并格式显示 HEAD 提交和即将进行的最新提交之间的差异。这样做不是并必须的,但有时候却很有用。再来说下提交信息,实际上,一条提交信息由两部分组成:

    第一部分放在第一行,它包括了一句对所做修改的简短描述。这一行以 [PATCH] 做前缀,后面跟上子系统、驱动或架构的名字,以及在 :之后的简述信息。在我们这个例子中,这一行信息如下所示:

    [PATCH] staging/dgap: Use strpbrk() instead of dgap_sindex()
    

    在简述信息之后,我们通常空一行再加上对本次提交的详尽描述。在我们的这个例子中,这些信息如下所示:

     
    1. The <linux/string.h> provides strpbrk() function that does the same that the

    2. dgap_sindex(). Let's use already defined function instead of writing custom.

    在提交信息的最后是 Sign-off-by 这一行。注意,提交信息的每一行不能超过 80 个字符并且提交信息必须详细地描述你所做的修改。千万不要只写一条类似于 Custom function removed 这样的信息,你需要描述你做了什么以及为什么这样做。补丁的审核者必须据此知道他们正在审核什么内容,除此之外,这里的提交信息本身也非常有用。每当你不能理解一些东西的时候,我们都可以使用 git blame 命令来阅读关于修改的描述。

    提交修改之后,是时候生成补丁文件了。我们可以使用 format-patch 命令来完成:

     
    1. $ git format-patch master

    2. 0001-staging-dgap-Use-strpbrk-instead-of-dgap_sindex.patch

    我们把分支名字 (这里是master) 传递给 format-patch 命令,该命令会根据那些包括在 dgap-remove-dgap_sindex 分支但不在 master 分支的最新改动来生成补丁。你会发现, format-patch 命令生成的文件包含了最新所做的修改,该文件的名字是基于提交信息的简述来生成的。如果你想按照自定义的文件名来生成补丁,你可以使用 --stdout 选项:

    $ git format-patch master --stdout > dgap-patch-1.patch
    

    最后一步就是在我们生成补丁之后将之发送到 Linux 内核邮件列表。当然,你可以使用任意的邮件客户端,不过 git 为此提供了一个专门的命令:git send-email。在发送补丁之前,你需要知道发到哪里。虽然你可以直接把它发送到 linux-kernel@vger.kernel.org 这个邮件列表,但这很可能让你的补丁因为巨大的消息流而被忽略掉。最好的选择是将补丁发送到你的修改所属子系统的维护者那里。你可以使用 get_maintainer.pl 这个脚本来找到这些维护者的名字。你所需要做的就是将你代码所在的文件或目录作为参数传递给脚本。

     
    1. $ ./scripts/get_maintainer.pl -f drivers/staging/dgap/dgap.c

    2. Lidza Louina <lidza.louina@gmail.com> (maintainer:DIGI EPCA PCI PRODUCTS)

    3. Mark Hounschell <markh@compro.net> (maintainer:DIGI EPCA PCI PRODUCTS)

    4. Daeseok Youn <daeseok.youn@gmail.com> (maintainer:DIGI EPCA PCI PRODUCTS)

    5. Greg Kroah-Hartman <gregkh@linuxfoundation.org> (supporter:STAGING SUBSYSTEM)

    6. driverdev-devel@linuxdriverproject.org (open list:DIGI EPCA PCI PRODUCTS)

    7. devel@driverdev.osuosl.org (open list:STAGING SUBSYSTEM)

    8. linux-kernel@vger.kernel.org (open list)

    你将会看到一组姓名和与之相关的邮件地址。现在你可以通过下面的命令发送补丁了:

     
    1. $ git send-email --to "Lidza Louina <lidza.louina@gmail.com>" \

    2. --cc "Mark Hounschell <markh@compro.net>" \

    3. --cc "Daeseok Youn <daeseok.youn@gmail.com>" \

    4. --cc "Greg Kroah-Hartman <gregkh@linuxfoundation.org>" \

    5. --cc "driverdev-devel@linuxdriverproject.org" \

    6. --cc "devel@driverdev.osuosl.org" \

    7. --cc "linux-kernel@vger.kernel.org"

    这就是全部的过程。补丁被发出去了,现在你所需要做的就是等待 Linux 内核开发者的反馈。在你发送完补丁并且维护者接受它之后,你将在维护者的仓库中看到它 (例如前文你看到的补丁)。一段时间后,维护者将会向 Linus 发送一个拉取请求,之后你就会在主线仓库里看到你的补丁了。

    这就是全部内容。

    一些建议

    在该部分的最后,我想给你一些建议,这些建议大都是关于在 Linux 内核的开发过程中需要做什么以及不能做什么的:

    • 考虑,考虑,再考虑。在你决定发送补丁之前再三考虑。

    • 在你每次改完 Linux 内核源代码之后 - 试着编译它。我指的是任何修改之后,都要不断的编译。没有人喜欢那些连编译都不通过修改。

    • Linux 内核有一套代码规范指南,你需要遵守它。有一个很棒的脚本可以帮你检查所做的修改。这个脚本就是 -scripts/checkpatch.pl。只需要将被改动的源码文件传递给它即可,然后你就会看到如下输出:

     
    1. $ ./scripts/checkpatch.pl -f drivers/staging/dgap/dgap.c

    2. WARNING: Block comments use * on subsequent lines

    3. #94: FILE: drivers/staging/dgap/dgap.c:94:

    4. +/*

    5. + SUPPORTED PRODUCTS

    6.  
    7. CHECK: spaces preferred around that '|' (ctx:VxV)

    8. #143: FILE: drivers/staging/dgap/dgap.c:143:

    9. + { PPCM, PCI_DEV_XEM_NAME, 64, (T_PCXM|T_PCLITE|T_PCIBUS) },

    10.  
    11.  

    在 git diff 命令的帮助下,你也会看到一些有问题的地方:

    git diff

    • Linus 不接受 github pull requests

    • 如果你的修改是由一些不同的且不相关的改动所组成的,你需要通过分离提交来切分修改。git format-patch 命令将会为每个提交生成一个补丁,每个补丁的标题会包含一个 vN 前缀,其中 N 是补丁的编号。如果你打算发送一系列补丁,也许给 git format-patch命令传递 --cover-letter 选项会对此很有帮助。这会生成一个附加文件,该文件包括的附函可以用来描述你的补丁集所做的改动。在 git send-email 命令中使用 --in-reply-to 选项也是一个好主意,该选项允许你将补丁集作为对附函的回复发送出去。对于维护者来说,你补丁集的结构看起来就像下面这样:

     
    1. |--> cover letter

    2. |----> patch_1

    3. |----> patch_2

    你可以将 message-id 参数传递给 --in-reply-to 选项,该选项可以在 git send-email 命令的输出中找到。

    有一件非常重要的事,那就是你的邮件必须是纯文本格式。通常来说,send-email 和 format-patch 这两个命令在内核开发中都是非常有用的,所以请查阅这些命令的的相关文档,你会发现很多有用的选项,例如:git send-email 和 git format-patch

    • 如果你发完补丁之后没有得到立即答复,请不要惊讶,因为维护者们都是很忙的。

    • scripts 目录包含了很多对 Linux 内核开发有用的脚本。我们已经看过此目录中的两个脚本了:checkpatch.pl 和get_maintainer.pl。除此之外,你还可以找到 stackusage 脚本,它可以打印栈的使用情况,extract-vmlinux 脚本可以提取出未经压缩的内镜镜像,还有很多其他的脚本。在 scripts 目录之外,你也会发现很多有用的脚本,这些脚本是 Lorenzo Stoakes 为内核开发而编写的。

    • 订阅 Linux 内核邮件列表。lkml 列表中每天都会有大量的信件,但是阅读它们并了解一些类似于 Linux 内核目前开发状态的内容是很有帮助的。除了 lkml 之外,还有一些其他的邮件列表,它们分别对应于不同的 Linux 内核子系统。

    • 如果你发的补丁第一次没有被接受,你就会收到 Linux 内核开发者的反馈。请做一些修改然后以 [PATCH vN](N 是补丁版本号) 为前缀重新发送补丁,例如:

    [PATCH v2] staging/dgap: Use strpbrk() instead of dgap_sindex()
    

    同样的,这次的补丁也必须包括更新日志以便描述自上一次的补丁以来所做的修改。当然,本文并不是对 Linux 内核开发详尽无遗的指导清单,但是一些最重要的事项已经都被阐明了。

    Happy Hacking!

    总结

    我希望这篇文章能够帮助其他人加入 Linux 内核社区!如果你有其他问题或建议,可以给我写邮件或者在 Twitter 上联系

    请注意,英语并不是我的母语,对此带来的不便我感到很抱歉。如果你发现了错误,请通过邮件或发 PR 来通知我。

     

    原文:https://github.com/MintCN/linux-insides-zh/blob/master/Misc/contribute.md

    展开全文
  • 版 次:5 印刷时间:2013年06月01日 包 装:平装 国际标准书号ISBN:9787115318244 丛书名:图灵程序设计丛书 ...**专注XNU内核开发实践的图书 一线设备驱动程序开发人员现身说法 轻松理解内核开发的复杂难懂之处
  • 编写Java程序调用内核模块 功能为向内核模块虚拟设备写字符串,再从内核模块虚拟设备读出字符串长度。 编译加载内核模块 见《 Android内核开发 Linux C编程调用内核模块设备驱动》

    本文出处: http://blog.csdn.net/leytton/article/details/52738760

    本文目的为Linux系统环境下:1、编写内核模块程序并编译 2、加载内核模块 3、编写Java程序调用内核模块

    功能为向内核模块虚拟设备写字符串,再从内核模块虚拟设备读出字符串长度。


    1、编译加载内核模块

    见另文《 Android内核开发 Linux C编程调用内核模块设备驱动》http://blog.csdn.net/leytton/article/details/52738901


    2、WordCount.java文件

    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    
    public class WordCount {
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		if (args.length > 0) {
    			if (writeStringToDev(args[0])) {
    				System.out.println("写入成功");
    			} else {
    				System.out.println("写入失败");
    				return;
    			}
    			int result = readWordCountFromDev();
    			if (result > -1) {
    				System.out.println("字符串长度为:" + result);
    			} else {
    				System.out.println("读取失败");
    				return;
    			}
    		} else {
    			System.out.println("Usage .eg:java WordCount \"hello\"");
    		}
    	}
    
    	// 向/dev/wordcount设备文件中写入字符串
    	private static boolean writeStringToDev(String str) {
    		try {
    			// 打开/dev/word_count设备文件
    			FileOutputStream fos = new FileOutputStream("/dev/word_count");
    			// 写入字符串
    			fos.write(str.getBytes("iso-8859-1"));
    			fos.close();
    		} catch (Exception e) {
    			System.out.println("Error:" + e.getMessage());
    			return false;
    		}
    		return true;
    	}
    
    	// 读取/dev/wordcount设备文件中的字符串长度
    	private static int readWordCountFromDev() {
    		int word_count = -1;
    		byte[] buffer = new byte[4];
    		try {
    			// 打开/dev/wordcount设备文件
    			FileInputStream fis = new FileInputStream("/dev/word_count");
    			word_count = fis.read();
    			fis.close();
    		} catch (Exception e) {
    			System.out.println("Error:" + e.getMessage());
    			return -1;
    		}
    		return word_count;
    	}
    
    }

    3、Linux中编译并运行

    [hadoop@localhost drivers01]$ javac -encoding gbk WordCount.java 
    [hadoop@localhost drivers01]$ sudo java WordCount "I love you"
    写入成功
    字符串长度为:10
    [hadoop@localhost drivers01]$

    4、参考文章

    《使用Android NDK和Java测试Linux驱动》http://blog.csdn.net/nokiaguy/article/details/8671397

    展开全文
  • 1.由于项目需求,需要更改内核版本并搭建内核开发环境。 当前内核版本 指定内核版本:3.10.0-327.el7.x86_64 2.下载指定内核rpm安装包 下载地址:...
  • 国嵌课程4课件(内核开发 国嵌课程4课件(内核开发
  • vscode搭建linux内核开发环境

    千次阅读 2021-02-20 18:13:43
    而且没有原生linux版本,要是想在纯linux环境下进行linux驱动开发,就只能wine+Source insight,而wine版的不好用容易卡死而且cpu占用还高,我就想到用开源跨平台的vscode进行linux内核开发,体验能否和source ...
  • KmdKit(内核开发工具)KmdKit(内核开发工具)KmdKit(内核开发工具)KmdKit(内核开发工具)KmdKit(内核开发工具)KmdKit(内核开发工具)
  • Android内核开发 学习笔记

    千次阅读 2017-02-27 09:20:10
    Android内核开发:序Android内核开发:开发板选购Android内核开发:理解和掌握repo工具下载manifest仓库 repo init -u https://android.googlesource.com/platform/manifest 如果要选择特定版本的Android源码,...
  • 嵌入式系统Linux内核开发实战指南(ARM平台).pdf和配合的(嵌入式系统Linux内核开发实战指南.iso)光盘镜像.受上传所限,分3卷.这是第一卷
  • delphi 下用Chorme 内核开发的浏览器示例程序,DELPHI 7 DELPHI XE , DELPHI 10.2亲测可以用
  • 《嵌入式系统 Linux 内核开发实战指南(ARM 平台) 》凝聚了作者 12 年的工作经验和学习心得与体会,内容覆盖了嵌入式系统 Linux 内核开发的各个方面。 作者根据自己 11 年的一线工作经验,介绍了嵌入式系统的概念、...
  • Linux内核开发的特点

    千次阅读 2015-03-21 18:55:31
    Linux内核开发的特点  相对于用户空间内的应用程序开发,内核开发存在很多的不同,最重要的差异包括以下几种:  1)内核编程时不能访问C库。  2)内核编程时必须使用GNU C。  3)内核编程时缺乏像用户空间...
  • postgresql内核开发之HelloWorld入门

    千次阅读 2016-11-27 21:30:04
    postgresql内核开发从哪开始?如何在postgresql内核增加新功能?本文给大家来个postgresql版的HelloWorld!
  • 嵌入式系统Linux内核开发实战指南 ARM平台 王洪辉 2009_12176663.part1.ra 两个part 230M
  • UNIX内核(5):内核开发的特点

    千次阅读 2013-05-14 21:50:10
    内核开发不是洪水猛兽。一旦你了解到其中的规则,你就会发现,跟开发应用程序一样;两者区别在于要遵守的规则集合不一样。 Linux是UNIX家族的一员,而且其内核源代码唾手可得,因此这里用其来作说明。 规则上...
  • 嵌入式系统Linux内核开发实战指南(ARM平台),想看就看吧
  • 学完C语言之后,最终是要应用到某个领域的,比如后端开发,应用开发或者Linux内核开发等。本文将介绍一下Linux内核相关的内容,Linux内核开发是相对比较难的领域,主要是门槛相对较高。虽然门槛较高,但有它的好处,...
  • 经典嵌入式黒皮巨著《嵌入式系统Linux内核开发实战指南(ARM平台)王洪辉著.pdf》。值得一读!
  • 使用QtCreator进行Linux内核开发

    千次阅读 2016-03-09 13:02:46
    配置QtCreator进行Linux内核开发
  • 嵌入式系统Linux内核开发实战指南 ARM平台 王洪辉 2009_12176663.part2.rar 完
  • 【UEFI实战】利用QEMU搭建BIOS与内核开发环境。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 417,533
精华内容 167,013
关键字:

内核开发