1. My opinion on the kernel source code

The sheer size of the Linux kernel code makes many people "daunted". It is precisely because of this that people's understanding of Linux is only at a general level. If you want to analyze Linux and delve into the nature of the operating system, reading the kernel source code is the most effective way. We all know that becoming an excellent programmer Linux kernel source code analysis requires a lot of practice and code compilation. Programming is still important, and often people who only program can easily limit themselves to their own areas of knowledge. If we want to expand the breadth of our knowledge, we need to be more exposed to code written by others, especially code written by people who are more advanced than us. Through these ways, we can break out of the confinement of our own knowledge circle, step into the knowledge circle of others, and learn more about information that we usually find difficult to understand in the short term. The Linux kernel is carefully maintained by countless "masters" in the open source community. Those people can be called top code experts. By reading the Linux kernel code, we learn not only kernel-related knowledge, but in my opinion, what is more valuable is learning and feeling their programming methods and understanding of computers.

I also came into contact with the analysis of Linux kernel source code through a project. I have benefited a lot from the analysis of source code. Not only did I acquire relevant kernel knowledge, it also changed my past understanding of kernel code:

1. The analysis of kernel source code is not "out of reach". The difficulty of kernel source code analysis does not lie in the source code itself, but in how to use more appropriate methods and methods to analyze the code. The complexity of the kernel means that we cannot analyze it step by step starting from the main function like analyzing a normal demo program. We need a way to intervene from the middle to "break through" the kernel source code one by one. These "on demand" formats allow us to grasp the main thread of the source code instead of getting too bogged down in the specific details.

2. The design of the core is beautiful. The special status of the kernel determines that the execution efficiency of the kernel must be high enough to respond to the real-time requirements of current computer applications. Therefore, the Linux kernel uses a hybrid programming of C language and assembly. And we all know that software execution efficiency and software maintainability run counter to each other in many cases. How to improve the maintainability of the kernel while ensuring the efficiency of the kernel depends on these "beautiful" designs in the kernel.

3． Amazing programming method. In the field of general application software design, the status of coding may not be overemphasized, because developers pay more attention to the good design of software, and coding is just a matter of implementation means-just like using an ax to chop firewood, without too much thinking. And this is not established in the kernel. Good coding design not only improves maintainability, but also improves code performance.

Everyone’s understanding of the kernel will be different. As our understanding of the kernel continues to deepen, we will have more thoughts and feelings about its design and implementation. Therefore, this article hopes to guide more people who are wandering outside the Linux kernel room into the world of Linux to personally experience the magic and greatness of the kernel. And I am not an expert in kernel source code. I just hope to share my own experience and insights in analyzing source code and provide reference and help to those who need it. To put it "high-sounding", it can be regarded as for the computer industry. Especially in the operating system kernel to contribute their own modest efforts. Without further ado (it’s already too long-winded, embarrassing~), let me share my own Linux kernel source code analysis method.

2. Is it difficult to source the kernel source code?

Essentially, analyzing Linux kernel code is no different from looking at other people's code, because the code in front of you is usually not the code you wrote yourself. Let's take a simple example first. A stranger gives you a program at random and asks you to explain the functional design of the program after reading the source code. I think many people who think that their programming skills are okay must think that this is nothing, as long as I patiently read his code from beginning to end, and I would definitely find the answer, but this is indeed the case. So now let's change the assumption, if this person is Linus, and what he gives you is the code of a module of the Linux kernel, do you think it is still so easy? Many people may hesitate. Why do we feel so different about the code given to you by the same stranger (not counting if Linus knows you, haha~)? I think there are the following reasons:

1. The Linux kernel code is somewhat mysterious to the "outside world", but it is very large, and it may be difficult to get started when it is placed in front of you. For example, it may start from a very small reason-the main function cannot be found. For a simple demo program, we can analyze the meaning of the code from beginning to end, and the method of analyzing the kernel code is completely ineffective, because no one can read the Linux code from beginning to end (because it is really not necessary, and when used, Just look at it).

2. Many people have also come into contact with the code of small software, but most of them are application projects. The form and meaning of the code are related to the business logic they often come into contact with. The kernel code is different. Most of the information it processes is closely related to the bottom layer of the computer. For example, the lack of relevant knowledge about operating systems, compilers, assembly, architecture, etc. will also make reading kernel code difficult.

3． The way to analyze the kernel code is not reasonable enough. Faced with a large amount of complex kernel code, if you don't start with Linux Mint from a global perspective, it is easy to get stuck in the quagmire of code details. After all, the kernel code is huge, and it also has its design principles and architecture, otherwise maintaining it would be a nightmare for anyone! If we clarify the overall design idea of ??the code module and then analyze the implementation of the code, it may be easy and happy to analyze the source code.

This is my personal understanding of those issues. If you have never been exposed to small software projects, analyzing Linux kernel code may be a good opportunity to accumulate experience in small projects (indeed, Linux code is the largest project I have been exposed to so far!). If you don’t understand the underlying aspects of computers thoroughly enough, we can choose to accumulate underlying knowledge by analyzing and learning at the same time. The progress of analyzing the code may be a little slow at first, but as knowledge continues to accumulate, our understanding of the "business logic" of the Linux kernel will gradually become clearer. The last point is how to master the source code of analysis from a global perspective. This is also the experience I want to share with you.

3. Kernel source code analysis method

Step one: data collection

From the perspective of people understanding new things, before exploring the essence of things, there must be a process of understanding new things. This process allows us to form a preliminary concept of new things. For example, if we want to learn guitar, we need to first understand that playing guitar requires us to learn basic sight-singing, simplified notation, staff and other basic knowledge, and then learn the methods and fingerings of erhu playing, and finally start practicing guitar.

The same is true for analyzing kernel code. First, we need to locate the content involved in the code to be analyzed. Is it the code for process synchronization and scheduling, the code for video memory management, the code for device management, the code for system startup, etc. The complexity of the kernel determines that we cannot analyze all the kernel code at once, so we need to give ourselves a reasonable division of labor. As algorithm design tells us, to solve a big problem, we must first solve the sub-problems it involves.

After locating the code range to be analyzed, we can use all the resources at hand to understand the overall structure and general functions of this part of the code as comprehensively as possible.

All the resources mentioned here refer to Baidu, Google small online search engine, operating system principle textbooks and professional books, or experience and information provided by others, or even documents, comments and source code provided by Linux source code The name of the identifier (don't underestimate the naming of identifiers in the code, sometimes they can provide key information). In fact, all the resources here refer to all the available resources you can think of. In fact, it is unlikely that we can obtain all the information we want through these methods of information collection. We just want to be as comprehensive as possible. Because the more comprehensive the information is collected, the more information can be used in the process of analyzing the code, and the difficulty of the analysis process will be smaller.

Here is a simple counterexample. Suppose we want to analyze the code implemented by Linux's frequency conversion mechanism. So far we only know this term. From the literal meaning, we can roughly infer that it should be related to the frequency adjustment of the CPU. Through information collection, we should be able to obtain the following relevant information:

1. CPUFreq mechanism.

2. performance, powersave, userspace, ondemand, conservative frequency regulation strategies.

3. /driver/cpufreq/.

4. /documention/cpufreq.

5. Pstate and Cstate.

……

If you can collect this kind of information when analyzing the Linux kernel code, you should be said to be very "lucky". Although the information about the Linux kernel is indeed not as rich as .NET and JQuery, compared with more than ten years ago, when there were no powerful search engines and no relevant research materials, it should be called a "big harvest" era! Through a simple "search" (which may take one to seven days), we even found the source code file directory where this part of the code is located. I have to say that this kind of information is simply "priceless"!

Step 2: Source code location

From the data collection, we were "lucky" to find the source code directory related to the source code. And this does not mean that we are actually analyzing the source code in this directory. Sometimes the directories we find may be scattered, and sometimes the directories we find contain a lot of code related to specific machines, and we are more concerned about the main mechanism of the code to be analyzed rather than the specialized code related to the machine ( This will help us understand the nature of the kernel more). To this end, we need to carefully select the information involving code files in the information. In fact, this step is unlikely to be completed at once, and no one can guarantee that all source code files to be analyzed can be selected at one time and none of them will be missed. And we don’t need to be afraid. As long as we can grasp the core source files related to most modules, we can naturally find them all through detailed analysis of the code later.

上記の例に戻り、/documention/cpufreq にあるドキュメントを注意深く読みます?，F(xiàn)在の Linux ソース コードでは、モジュール関連のドキュメントがソース コード ディレクトリのドキュメント フォルダーに保存されます。分析対象のモジュールにドキュメントがない場(chǎng)合、これにより、主要なソース コード ファイルを見(jiàn)つける難しさがいくらか軽減され、問(wèn)題が発生することはありません。解析したいソースコードが見(jiàn)つからない。ドキュメントを読むことで、少なくともソース ファイル /driver/cpufreq/cpufreq.c に注目することができます。このソース ファイルのドキュメントと、以前に収集した周波數(shù)変調(diào)戦略を組み合わせることで、5 つのソース ファイル cpufreq_performance.c、cpufreq_powersave.c、cpufreq_userspace.c、cpufreq_ondemand、および cpufreq_conservative.c に簡(jiǎn)単に注目できます。関係する書類はすべて見(jiàn)つかったでしょうか?恐れることなく、それらから分析を開始してください。遅かれ早かれ、他のソース ファイルが見(jiàn)つかるでしょう。 Windows で SourceInsight を使用してカーネル ソース コードを読み取る場(chǎng)合、コード分析と組み合わせた関數(shù)呼び出しやシンボル?yún)⒄栅螚仕鳏胜嗓螜C(jī)能を通じて、他のファイル freq_table.c、cpufreq_stats.c、および /include/linux/cpufreq を簡(jiǎn)単に見(jiàn)つけることができます。 h.

検索された情報(bào)の流れの方向に従って、分析が必要なソースコードファイルを完全に見(jiàn)つけることができます。すべてのソース コード ファイルを見(jiàn)つける必要はなく、作業(yè)の一部をコードの分析プロセスに延期できるため、ソース コードを見(jiàn)つける手順はそれほど重要ではありません。ソース コード ファイルの一部を見(jiàn)つけることも、ソース コードを分析するための基礎(chǔ)となります。

ステップ 3: 簡(jiǎn)単なコメント

見(jiàn)つかったソース コード ファイルで、各変數(shù)、マクロ、関數(shù)、構(gòu)造、その他のコード要素の一般的な意味と機(jī)能を分析します。これを単純なコメントと呼ぶのは、この部分のコメント作業(yè)が非常に単純であるという意味ではなく、この部分のコメントは、大まかに意味を説明するものであれば、あまり詳しく説明する必要はないという意味です。関連するコード要素。それどころか、ここでの作業(yè)は、分析プロセス全體の中で最も難しいステップであることは言うまでもありません。カーネル コードを深く掘り下げるのは初めてなので、特に初めてカーネル ソース コードを分析する人にとっては、多くのなじみのない GNU C 文パターンと圧倒的なマクロ定義に非常にがっかりするでしょう。この時(shí)點(diǎn)で、落ち著いてそれぞれの重要な困難を理解していれば、將來(lái)同じような困難に遭遇したときに退卻を余儀なくされることはありません。さらに、カーネルに関連する他の知識(shí)も木のように拡大し続けます。

たとえば、「DEFINE_PER_CPU」マクロの使用は、cpufreq.c ファイルの先頭に表示されます。この情報(bào)を參照することで、このマクロの意味と機(jī)能を基本的に理解できます。ここで使用する方法は、以前にデータを収集するために使用した方法と基本的に同じです。また、sourceinsight が提供する転送定義やその他の機(jī)能を使用してその定義を確認(rèn)したり、LKML (LinuxKernelMailList) を使用して確認(rèn)したりすることもできます。動(dòng)作しない場(chǎng)合は、質(zhì)問(wèn)して答えを求めることもできます (LKML と stackoverflow について知りたいですか? 情報(bào)を収集してください)。実際、あらゆる手段を講じれば、このマクロの意味を常に取得できます。CPU ごとに獨(dú)立して使用される変數(shù)を定義します。

コメントを一度に正確に記述できることに固執(zhí)することはありません (各関數(shù)の具體的な実裝プロセスを理解する必要さえありません。一般的な機(jī)能の意味を理解するだけです)。収集した情報(bào)と上記のコードの分析 コメントの意味を継続的に確立します (ここでは、ソース コード內(nèi)の元のコメントと識(shí)別子の名前が非常に役に立ちます)。絶え間ない注釈、情報(bào)への絶え間ない參照、そして注釈の意味の絶え間ない変化によって。

関係するすべてのソース コード ファイルに注釈を付けるだけで、次のような効果が得られます。

以前に収集した情報(bào)とデータに基づいて分析するコードの全體的または構(gòu)造的な説明と組み合わせることで、分析結(jié)果とデータを比較して、コードの理解を決定および修正できます。このように、簡(jiǎn)単なコメントを通じて、ソースコードモジュール全體の主な構(gòu)造を把握することができます。これにより、単純なアノテーションの基本的な目的も達(dá)成されます。

ステップ 4: 詳細(xì)なメモ

コードの簡(jiǎn)単なコメントを完了すると、モジュールの分析が半分終わったと感じることができ、殘りの內(nèi)容は詳細(xì)な分析とコードの完全な理解です。単純なコメントではコード要素の特定の意味を必ずしも正確に説明できるとは限らないため、詳細(xì)なコメントが非常に必要です。このステップでは、次のことを明確にする必要があります:

1.変數(shù)定義を使用する場(chǎng)合。

2.マクロで定義したコードを使用する場(chǎng)合。

3．関數(shù)のパラメータと戻り値の意味。

4．関數(shù)の実行フローと呼び出し関係。

5．構(gòu)造體配列の具體的な意味と使用條件。

関數(shù)の外側(cè)のコード要素の意味は基本的に単純なコメントで明らかであるため、このステップを詳細(xì)関數(shù)アノテーションと呼ぶこともできます。関數(shù)自體の実行フローとアルゴリズムが、この部分のアノテーションと分析の主なタスクです。

たとえば、cpufreq_ondemand ポリシーの実裝アルゴリズム (関數(shù) dbs_check_cpu 內(nèi)) がどのように実裝されるか。アルゴリズムの詳細(xì)を理解するには、関數(shù)で使用される変數(shù)と呼び出される関數(shù)を徐々に分析する必要があります。最良の結(jié)果を得るには、この複雑な関數(shù)の実行フローチャートと関數(shù)呼び出し関係図が必要です。これは最も直観的な表現(xiàn)形式です。

このステップのコメントを通じて、基本的に、分析対象のコードの全體的な実裝メカニズムを完全に把握できます。そして、すべての分析作業(yè)は 80% 完了したと感じられます。このステップは特に重要であり、分析対象のコードの內(nèi)部モジュールの定義をよりよく理解できるように、アノテーション情報(bào)を十分に正確にするように努める必要があります。実際、Linux カーネルは、マクロ文型「module_init」および「module_exit」を使用してモジュール ファイルを宣言し、モジュールの內(nèi)部サブ関數(shù)の定義は、モジュールの機(jī)能の完全な理解に基づいています。モジュールが正しく定義されている限り、モジュールが提供する外部関數(shù)と変數(shù)を把握できます (EXPORT_SYMBOL_GPL または EXPORT_SYMBOL によってインポートされたシンボルを使用)。モジュール內(nèi)の識(shí)別子の依存関係を分析する次のステップに進(jìn)むことができます。

ステップ 5: モジュールの內(nèi)部識(shí)別子の依存関係

4番目のステップでコードモジュールを定義することで、モジュールを1つずつ「簡(jiǎn)単に」分析できます。通常、ファイルの先頭にあるモジュールの入口関數(shù)と出口関數(shù)から開始できます (「module_init」と「module_exit」で宣言された関數(shù)は通常、ファイルの最後にあります) Linux カーネル ソース コード分析 によれば、それらが呼び出す関數(shù) (自己定義またはモジュールの他の関數(shù)) と使用される主要な変數(shù) (このファイル內(nèi)のグローバル変數(shù)または他のモジュールの外部変數(shù)) は、「関數(shù)-変數(shù)-関數(shù)」依存関係図を描畫します。これを識(shí)別子と呼びます。依存関係図。

実際、モジュール內(nèi)の識(shí)別子の依存関係は単純なツリー構(gòu)造ではなく、多くの場(chǎng)合、複雑なネットワーク関係になります。この時(shí)點(diǎn)で、コードに対する詳細(xì)なコメントの役割が明らかになります。関數(shù)自體の意味に従ってモジュールのサブ関數(shù)を定義し、各サブ関數(shù)の識(shí)別子依存ツリーを抽出します。

識(shí)別子の依存関係分析を通じて、モジュールによって定義された関數(shù)がこれらの関數(shù)を呼び出していること、どの変數(shù)が使用されているか、モジュールのサブ関數(shù)間の依存関係 (どの関數(shù)と変數(shù)が共有されているかなど) を明確に示すことができます。

ステップ 6: モジュール間の相互依存性

すべてのモジュールの內(nèi)部識(shí)別子の依存関係図が整理されると、モジュールが使用する他のモジュールの変數(shù)や関數(shù)に基づいてモジュール間の依存関係を簡(jiǎn)単に取得できます。

cpufreqコードのモジュール依存関係は以下の関係で表すことができます。

ステップ 7: モジュールアーキテクチャ図

モジュール間の依存関係図により、解析対象のコード全體におけるモジュールの狀態(tài)や機(jī)能を明確に表現(xiàn)できます。これに基づいて、モジュールを分類し、コードのアーキテクチャ上の関係を整理できます。

cpufreq のモジュール依存関係図に示されているように、すべての周波數(shù)変調(diào)戦略モジュールがコア モジュール cpufreq、cpufreq_stats、および freq_table に依存していることが明確にわかります。 3 つの依存モジュールをコードのコア フレームワークとして視覚化すると、これらの周波數(shù)変調(diào)戦略モジュールはこのフレームワーク上に構(gòu)築され、ユーザー層との対話を擔(dān)當(dāng)します。コア モジュール cpufreq は、基礎(chǔ)となるシステムとの対話を擔(dān)當(dāng)するドライバーおよびその他の関連ソケットを提供します。したがって、次のモジュール アーキテクチャ図が得られます。

実際、アーキテクチャ図はモジュールを無(wú)機(jī)的につなぎ合わせたものではなく、アーキテクチャ図の意味を豊かにするために參照するデータを組み合わせる必要もあります。したがって、ここでのアーキテクチャ図の詳細(xì)は、さまざまな人々の理解によって異なります。また、アーキテクチャ図本體の意味も基本的に同じです。これで、解析対象となるカーネルコードの解析作業(yè)はすべて完了しました。

4.まとめ

記事の冒頭で述べたように、カーネル コード全體を分析することは不可能です。したがって、分析対象のコードから情報(bào)を収集し、上記のプロセスに従ってコードの元ネタを分析することは、カーネルの本質(zhì)を理解するために有効な方法です。特定のニーズに応じてカーネル コードを分析するこれらの方法により、Linux カーネルの世界にすぐに參入できる可能性が得られます。これらの方法を通じて、カーネルの他のモジュールの分析を続け、最終的には Linux カーネルについての獨(dú)自の理解を包括的に取得し、Linux カーネルを?qū)W習(xí)するという目的を達(dá)成します。

最後に、カーネルを?qū)W習(xí)するための參考書を 2 冊(cè)お?jiǎng)幛幛筏蓼埂?1 つは「Linux カーネルの設(shè)計(jì)と実裝」で、読者に Linux カーネルの主な機(jī)能と実裝について手早く簡(jiǎn)潔に紹介します。ただし、読者を Linux カーネル コードの深淵に導(dǎo)くものではありません。この本は、カーネル アーキテクチャを理解し、Linux カーネル コードを始めるのに特に優(yōu)れた參考書です。同時(shí)に、読者のカーネル コードへの関心も高まります。もう 1 つは、「Linux カーネルの徹底理解」です。なぜこの本の傑作についてもっと説明する必要があるのでしょうか。この本をよりよく學(xué)びたい場(chǎng)合は、カーネル コードと併せて読むのが最善であることをお?jiǎng)幛幛筏蓼?。本書はカーネルコードについて詳しく解説しているので、コードと合わせて読むとカーネルコードの理解が深まります。同時(shí)に、カーネルコードを解析する過(guò)程で、參考となる情報(bào)も本書で見(jiàn)つけることができます。最後に、皆さんができるだけ早くカーネルの世界に入り、Linux がもたらす驚きを體験してほしいと願(yuàn)っています。

The above is the detailed content of In-depth analysis of the Linux kernel source code and exploration of the essence of the operating system. For more information, please follow other related articles on the PHP Chinese website!