歡迎光臨
每天分享高質量文章

計算機實驗室之樹莓派:課程 8 屏幕03 | Linux 中國

屏幕03 課程基於屏幕02 課程來構建,它教你如何繪製文本,和一個操作系統命令列引數上的一個小特性。

— Alex Chadwick

 

屏幕03 課程基於屏幕02 課程來構建,它教你如何繪製文本,和一個操作系統命令列引數上的一個小特性。假設你已經有了課程 7:屏幕02[1] 的操作系統代碼,我們將以它為基礎來構建。

1、字串的理論知識

是的,我們的任務是為這個操作系統繪製文本。我們有幾個問題需要去處理,最緊急的那個可能是如何去儲存文本。令人難以置信的是,文本是迄今為止在計算機上最大的缺陷之一。原本應該是簡單的資料型別卻導致了操作系統的崩潰,從而削弱其他方面的加密效果,並給使用其它字母表的用戶帶來了許多問題。儘管如此,它仍然是極其重要的資料型別,因為它將計算機和用戶很好地連接起來。文本是計算機能夠理解的非常好的結構,同時人類使用它時也有足夠的可讀性。

那麼,文本是如何儲存的呢?非常簡單,我們使用一種方法,給每個字母分配一個唯一的編號,然後我們儲存一系列的這種編號。看起來很容易吧。問題是,那個編號的數量是不固定的。一些文本段可能比其它的長。儲存普通數字,我們有一些固有的限制,即:32 位,我們不能超過這個限制,我們要添加方法去使用該長度的數字等等。“文本”這個術語,我們經常也叫它“字串”,我們希望能夠寫一個可用於可變長度字串的函式,否則就需要寫很多函式!對於一般的數字來說,這不是個問題,因為只有幾種通用的數字格式(位元組、字、半位元組、雙位元組)。

可變資料型別(比如文本)要求能夠進行很複雜的處理。

因此,如何判斷字串長度?我想顯而易見的答案是儲存字串的長度,然後去儲存組成字串的字符。這稱為長度前綴,因為長度位於字串的前面。不幸的是,計算機科學家的先驅們不同意這麼做。他們認為使用一個稱為空終止符(NULL)的特殊字符(用 \0 表示)來表示字串結束更有意義。這樣確定簡化了許多字串演算法,因為你只需要持續操作直到遇到空終止符為止。不幸的是,這成為了許多安全問題的根源。如果一個惡意用戶給你一個特別長的字串會發生什麼狀況?如果沒有足夠的空間去儲存這個特別長的字串會發生什麼狀況?你可以使用一個字串複製函式來做複製,直到遇到空終止符為止,但是因為字串特別長,而覆寫了你的程式,怎麼辦?這看上去似乎有些較真,但是,緩衝區上限溢位攻擊還是經常發生。長度前綴可以很容易地緩解這種問題,因為它可以很容易地推算出儲存這個字串所需要的緩衝區的長度。作為一個操作系統開發者,我留下這個問題,由你去決定如何才能更好地儲存文本。

緩衝區上限溢位攻擊禍害計算機由來已久。最近,Wii、Xbox 和 Playstation 2、以及大型系統如 Microsoft 的 Web 和資料庫服務器,都遭受到緩衝區上限溢位攻擊。

接下來的事情是,我們需要確定的是如何最好地將字符映射到數字。幸運的是,這是高度標準化的,我們有兩個主要的選擇,Unicode 和 ASCII。Unicode 幾乎將每個有用的符號都映射為數字,作為代價,我們需要有很多很多的數字,和一個更複雜的編碼方法。ASCII 為每個字符使用一個位元組,因此它僅儲存拉丁字母、數字、少數符號和少數特殊字符。因此,ASCII 是非常易於實現的,與之相比,Unicode 的每個字符占用的空間並不相同,這使得字串演算法更棘手。通常,操作系統上字符使用 ASCII,並不是為了顯示給最終用戶的(開發者和專家用戶除外),給終端用戶顯示信息使用 Unicode,因為 Unicode 能夠支持像日語字符這樣的東西,並且因此可以實現本地化。

幸運的是,在這裡我們不需要去做選擇,因為它們的前 128 個字符是完全相同的,並且編碼也是完全一樣的。

表 1.1 ASCII/Unicode 符號 0-127

< 如顯示不全,請左右滑動 >
0 1 2 3 4 5 6 7 8 9 a b c d e f
00 NUL SOH STX ETX EOT ENQ ACK BEL BS HT LF VT FF CR SO SI
10 DLE DC1 DC2 DC3 DC4 NAK SYN ETB CAN EM SUB ESC FS GS RS US
20 ! # $ % & . ( ) * + , . /
30 0 1 2 3 4 5 6 7 8 9 : ; < = > ?
40 @ A B C D E F G H I J K L M N O
50 P Q R S T U V W X Y Z [ \ ] ^ _
60 ` a b c d e f g h i j k l m n o
70 p q r s t u v w x y z { } ~ DEL

這個表顯示了前 128 個符號。一個符號的十六進製表示是行的值加上列的值,比如 A 是 4116。你可以驚奇地發現前兩行和最後的值。這 33 個特殊字符是不可打印字符。事實上,許多人都忽略了它們。它們之所以存在是因為 ASCII 最初設計是基於計算機網絡來傳輸資料的一種方法。因此它要發送的信息不僅僅是符號。你應該學習的重要的特殊字符是 NUL,它就是我們前面提到的空終止符。HT 水平製表符就是我們經常說的 tab,而 LF 換行符用於生成一個新行。你可能想研究和使用其它特殊字符在你的操行系統中的意義。

2、字符

到目前為止,我們已經知道了一些關於字串的知識,我們可以開始想想它們是如何顯示的。為了顯示一個字串,我們需要做的最基礎的事情是能夠顯示一個字符。我們的第一個任務是編寫一個 DrawCharacter 函式,給它一個要繪製的字符和一個位置,然後它將這個字符繪製出來。

這就很自然地引出關於字體的討論。我們已經知道有許多方式去按照選定的字體去顯示任何給定的字母。那麼字體又是如何工作的呢?在計算機科學的早期階段,字體就是所有字母的一系列小圖片而已,這種字體稱為位圖字體,而所有的字符繪製方法就是將圖片複製到屏幕上。當人們想去調整字體大小時就出問題了。有時我們需要大的字母,而有時我們需要的是小的字母。儘管我們可以為每個字體、每種大小、每個字符都繪製新圖片,但這種作法過於單調乏味。所以,發明瞭矢量字體。矢量字體不包含字體的圖像,它包含的是如何去繪製字符的描述,即:一個 o 可能是最大字母高度的一半為半徑繪製的圓。現代操作系統都幾乎僅使用這種字體,因為這種字體在任何解析度下都很完美。

在許多操作系統中使用的 TrueType 字體格式是很強大的,它內置有它自己的彙編語言,以確保在任何解析度下字母看起來都是正確的。

不幸的是,雖然我很想包含一個矢量字體的格式的實現,但它的內容太多了,將占用這個網站的剩餘部分。所以,我們將去實現一個位圖字體,可是,如果你想去做一個像樣的圖形操作系統,那麼矢量字體將是很有用的。

在下載頁面上的字體節中,我們提供了幾個 .bin 檔案。這些只是字體的原始二進制資料檔案。為完成本教程,從等寬、單色、8×16 節中挑選你喜歡的字體。然後下載它並儲存到 source 目錄中並命名為 font.bin 檔案。這些檔案只是每個字母的單色圖片,它們每個字母剛好是 8 x 16 個像素。所以,每個字母占用 16 位元組,第一個位元組是第一行,第二個位元組是第二行,依此類推。

這個示意圖展示了等寬、單色、8×16 的字符 A 的 “Bitstream Vera Sans Mono” 字體。在這個檔案中,我們可以找到,它從第 4116 × 1016 = 41016 位元組開始的十六進制序列:

  1. 00, 00, 00, 10, 28, 28, 28, 44, 44, 7C, C6, 82, 00, 00, 00, 00

在這裡我們將使用等寬字體,因為等寬字體的每個字符大小是相同的。不幸的是,大多數字體的複雜之處就是因為它的寬度不同,從而導致它的顯示代碼更複雜。在下載頁面上還包含有幾個其它的字體,並包含了這種字體的儲存格式介紹。

我們回到正題。複製下列代碼到 drawing.s 中的 graphicsAddress 的 .int 0 之後。

  1. .align 4
  2. font:
  3. .incbin "font.bin"

.incbin "file" 插入來自檔案 “file” 中的二進制資料。

這段代碼複製檔案中的字體資料到標簽為 font 的地址。我們在這裡使用了一個 .align 4去確保每個字符都是從 16 位元組的倍數開始,這是一個以後經常用到的用於加快訪問速度的技巧。

現在我們去寫繪製字符的方法。我在下麵給出了偽代碼,你可以嘗試自己去實現它。按慣例 >>的意思是邏輯右移。

  1. function drawCharacter(r0 is character, r1 is x, r2 is y)
  2. if character > 127 then exit
  3. set charAddress to font + character × 16
  4. for row = 0 to 15
  5. set bits to readByte(charAddress + row)
  6. for bit = 0 to 7
  7. if test(bits >> bit, 0x1)
  8. then setPixel(x + bit, y + row)
  9. next
  10. next
  11. return r0 = 8, r1 = 16
  12. end function

如果直接去實現它,這顯然不是個高效率的做法。像繪製字符這樣的事情,效率是最重要的。因為我們要頻繁使用它。我們來探索一些改善的方法,使其成為最優化的彙編代碼。首先,因為我們有一個 × 16,你應該會馬上想到它等價於邏輯左移 4 位。緊接著我們有一個變數 row,它只與 charAddress 和 y 相加。所以,我們可以通過增加替代變數來消除它。現在唯一的問題是如何判斷我們何時完成。這時,一個很好用的 .align 4 上場了。我們知道,charAddress 將從包含 0 的低位半位元組開始。這意味著我們可以通過檢查低位半位元組來看到進入字符資料的程度。

雖然我們可以消除對 bit 的需求,但我們必須要引入新的變數才能實現,因此最好還是保留它。剩下唯一的改進就是去除嵌套的 bits >> bit

  1. function drawCharacter(r0 is character, r1 is x, r2 is y)
  2. if character > 127 then exit
  3. set charAddress to font + character << 4
  4. loop
  5. set bits to readByte(charAddress)
  6. set bit to 8
  7. loop
  8. set bits to bits << 1
  9. set bit to bit - 1
  10. if test(bits, 0x100)
  11. then setPixel(x + bit, y)
  12. until bit = 0
  13. set y to y + 1
  14. set chadAddress to chadAddress + 1
  15. until charAddress AND 0b1111 = 0
  16. return r0 = 8, r1 = 16
  17. end function

現在,我們已經得到了非常接近彙編代碼的代碼了,並且代碼也是經過優化的。下麵就是上述代碼用彙編寫出來的代碼。

  1. .globl DrawCharacter
  2. DrawCharacter:
  3. cmp r0,#127
  4. movhi r0,#0
  5. movhi r1,#0
  6. movhi pc,lr
  7. push {r4,r5,r6,r7,r8,lr}
  8. x .req r4
  9. y .req r5
  10. charAddr .req r6
  11. mov x,r1
  12. mov y,r2
  13. ldr charAddr,=font
  14. add charAddr, r0,lsl #4
  15. lineLoop$:
  16. bits .req r7
  17. bit .req r8
  18. ldrb bits,[charAddr]
  19. mov bit,#8
  20. charPixelLoop$:
  21. subs bit,#1
  22. blt charPixelLoopEnd$
  23. lsl bits,#1
  24. tst bits,#0x100
  25. beq charPixelLoop$
  26. add r0,x,bit
  27. mov r1,y
  28. bl DrawPixel
  29. teq bit,#0
  30. bne charPixelLoop$
  31. charPixelLoopEnd$:
  32. .unreq bit
  33. .unreq bits
  34. add y,#1
  35. add charAddr,#1
  36. tst charAddr,#0b1111
  37. bne lineLoop$
  38. .unreq x
  39. .unreq y
  40. .unreq charAddr
  41. width .req r0
  42. height .req r1
  43. mov width,#8
  44. mov height,#16
  45. pop {r4,r5,r6,r7,r8,pc}
  46. .unreq width
  47. .unreq height

3、字串

現在,我們可以繪製字符了,我們可以繪製文本了。我們需要去寫一個方法,給它一個字串為輸入,它通過遞增位置來繪製出每個字符。為了做的更好,我們應該去實現新的行和製表符。是時候決定關於空終止符的問題了,如果你想讓你的操作系統使用它們,可以按需來修改下麵的代碼。為避免這個問題,我將給 DrawString 函式傳遞一個字串長度,以及字串的地址,和 x 和 y 的坐標作為引數。

  1. function drawString(r0 is string, r1 is length, r2 is x, r3 is y)
  2. set x0 to x
  3. for pos = 0 to length - 1
  4. set char to loadByte(string + pos)
  5. set (cwidth, cheight) to DrawCharacter(char, x, y)
  6. if char = '\n' then
  7. set x to x0
  8. set y to y + cheight
  9. otherwise if char = '\t' then
  10. set x1 to x
  11. until x1 > x0
  12. set x1 to x1 + 5 × cwidth
  13. loop
  14. set x to x1
  15. otherwise
  16. set x to x + cwidth
  17. end if
  18. next
  19. end function

同樣,這個函式與彙編代碼還有很大的差距。你可以隨意去嘗試實現它,即可以直接實現它,也可以簡化它。我在下麵給出了簡化後的函式和彙編代碼。

很明顯,寫這個函式的人並不很有效率(感到奇怪嗎?它就是我寫的)。再說一次,我們有一個 pos 變數,它用於遞增及與其它東西相加,這是完全沒有必要的。我們可以去掉它,而同時進行長度遞減,直到減到 0 為止,這樣就少用了一個暫存器。除了那個煩人的乘以 5 以外,函式的其餘部分還不錯。在這裡要做的一個重要事情是,將乘法移到迴圈外面;即便使用位移運算,乘法仍然是很慢的,由於我們總是加一個乘以 5 的相同的常數,因此沒有必要重新計算它。實際上,在彙編代碼中它可以在一個運算元中通過引數移位來實現,因此我將代碼改變為下麵這樣。

  1. function drawString(r0 is string, r1 is length, r2 is x, r3 is y)
  2. set x0 to x
  3. until length = 0
  4. set length to length - 1
  5. set char to loadByte(string)
  6. set (cwidth, cheight) to DrawCharacter(char, x, y)
  7. if char = '\n' then
  8. set x to x0
  9. set y to y + cheight
  10. otherwise if char = '\t' then
  11. set x1 to x
  12. set cwidth to cwidth + cwidth << 2
  13. until x1 > x0
  14. set x1 to x1 + cwidth
  15. loop
  16. set x to x1
  17. otherwise
  18. set x to x + cwidth
  19. end if
  20. set string to string + 1
  21. loop
  22. end function

以下是它的彙編代碼:

  1. .globl DrawString
  2. DrawString:
  3. x .req r4
  4. y .req r5
  5. x0 .req r6
  6. string .req r7
  7. length .req r8
  8. char .req r9
  9. push {r4,r5,r6,r7,r8,r9,lr}
  10. mov string,r0
  11. mov x,r2
  12. mov x0,x
  13. mov y,r3
  14. mov length,r1
  15. stringLoop$:
  16. subs length,#1
  17. blt stringLoopEnd$
  18. ldrb char,[string]
  19. add string,#1
  20. mov r0,char
  21. mov r1,x
  22. mov r2,y
  23. bl DrawCharacter
  24. cwidth .req r0
  25. cheight .req r1
  26. teq char,#'\n'
  27. moveq x,x0
  28. addeq y,cheight
  29. beq stringLoop$
  30. teq char,#'\t'
  31. addne x,cwidth
  32. bne stringLoop$
  33. add cwidth, cwidth,lsl #2
  34. x1 .req r1
  35. mov x1,x0
  36. stringLoopTab$:
  37. add x1,cwidth
  38. cmp x,x1
  39. bge stringLoopTab$
  40. mov x,x1
  41. .unreq x1
  42. b stringLoop$
  43. stringLoopEnd$:
  44. .unreq cwidth
  45. .unreq cheight
  46. pop {r4,r5,r6,r7,r8,r9,pc}
  47. .unreq x
  48. .unreq y
  49. .unreq x0
  50. .unreq string
  51. .unreq length

這個代碼中非常聰明地使用了一個新運算,subs 是從一個運算元中減去另一個數,儲存結果,然後將結果與 0 進行比較。實現上,所有的比較都可以實現為減法後的結果與 0 進行比較,但是結果通常會丟棄。這意味著這個操作與 cmp 一樣快。

subs reg,#val 從暫存器 reg 中減去 val,然後將結果與 0 進行比較。

4、你的意願是我的命令列

現在,我們可以輸出字串了,而挑戰是找到一個有意思的字串去繪製。一般在這樣的教程中,人們都希望去繪製 “Hello World!”,但是到目前為止,雖然我們已經能做到了,我覺得這有點“君臨天下”的感覺(如果喜歡這種感覺,請隨意!)。因此,作為替代,我們去繼續繪製我們的命令列。

有一個限制是我們所做的操作系統是用在 ARM 架構的計算機上。最關鍵的是,在它們引導時,給它一些信息告訴它有哪些可用資源。幾乎所有的處理器都有某些方式來確定這些信息,而在 ARM 上,它是通過位於地址 10016 處的資料來確定的,這個資料的格式如下:

  1. 1. 資料是可分解的一系列的標簽。
  2. 2. 這裡有九種型別的標簽:`core``mem``videotext``ramdisk``initrd2``serial``revision``videolfb``cmdline`
  3. 3. 每個標簽只能出現一次,除了 `core` 標簽是必不可少的之外,其它的都是可有可無的。
  4. 4. 所有標簽都依次放置在地址 `0x100` 處。
  5. 5. 標簽串列的結束處總是有兩個<ruby>字<rt>word</rt>ruby>,它們全為 0
  6. 6. 每個標簽的位元組數都是 4 的倍數。
  7. 7. 每個標簽都是以標簽中(以字為單位)的標簽大小開始(標簽包含這個數字)。
  8. 8. 緊接著是包含標簽編號的一個半字。編號是按上面列出的順序,從 1 開始(`core` 1`cmdline` 9)。
  9. 9. 緊接著是一個包含 5441<sub>16sub> 的半字。
  10. 10. 之後是標簽的資料,它根據標簽不同是可變的。資料大小(以字為單位)+ 2 的和總是與前面提到的長度相同。
  11. 11. 一個 `core` 標簽的長度可以是 2 個字也可以是 5 個字。如果是 2 個字,表示沒有資料,如果是 5 個字,表示它有 3 個字的資料。
  12. 12. 一個 `mem` 標簽總是 4 個字的長度。資料是記憶體塊的第一個地址,和記憶體塊的長度。
  13. 13. 一個 `cmdline` 標簽包含一個 `null` 終止符字串,它是個內核引數。

在目前的樹莓派版本中,只提供了 coremem 和 cmdline 標簽。你可以在後面找到它們的用法,更全面的參考資料在樹莓派的參考頁面上。現在,我們感興趣的是 cmdline 標簽,因為它包含一個字串。我們繼續寫一些搜索這個命令列(cmdline)標簽的代碼,如果找到了,以每個條目一個新行的形式輸出它。命令列只是圖形處理器或用戶認為操作系統應該知道的東西的一個串列。在樹莓派上,這包含了 MAC 地址、序列號和屏幕解析度。字串本身也是一個由空格隔開的運算式(像 key.subkey=value 這樣的)的串列。

幾乎所有的操作系統都支持一個“命令列”的程式。它的想法是為選擇一個程式所期望的行為而提供一個通用的機制。

我們從查找 cmdline 標簽開始。將下列的代碼複製到一個名為 tags.s 的新檔案中。

  1. .section .data
  2. tag_core: .int 0
  3. tag_mem: .int 0
  4. tag_videotext: .int 0
  5. tag_ramdisk: .int 0
  6. tag_initrd2: .int 0
  7. tag_serial: .int 0
  8. tag_revision: .int 0
  9. tag_videolfb: .int 0
  10. tag_cmdline: .int 0

通過標簽串列來查找是一個很慢的操作,因為這涉及到許多記憶體訪問。因此,我們只想做一次。代碼創建一些資料,用於儲存每個型別的第一個標簽的記憶體地址。接下來,用下麵的偽代碼就可以找到一個標簽了。

  1. function FindTag(r0 is tag)
  2. if tag > 9 or tag = 0 then return 0
  3. set tagAddr to loadWord(tag_core + (tag - 1) × 4)
  4. if not tagAddr = 0 then return tagAddr
  5. if readWord(tag_core) = 0 then return 0
  6. set tagAddr to 0x100
  7. loop forever
  8. set tagIndex to readHalfWord(tagAddr + 4)
  9. if tagIndex = 0 then return FindTag(tag)
  10. if readWord(tag_core+(tagIndex-14) = 0
  11. then storeWord(tagAddr, tag_core+(tagIndex-14)
  12. set tagAddr to tagAddr + loadWord(tagAddr) × 4
  13. end loop
  14. end function

這段代碼已經是優化過的,並且很接近彙編了。它嘗試直接加載標簽,第一次這樣做是有些樂觀的,但是除了第一次之外的其它所有情況都是可以這樣做的。如果失敗了,它將去檢查 core 標簽是否有地址。因為 core 標簽是必不可少的,如果它沒有地址,唯一可能的原因就是它不存在。如果它有地址,那就是我們沒有找到我們要找的標簽。如果沒有找到,那我們就需要查找所有標簽的地址。這是通過讀取標簽編號來做的。如果標簽編號為 0,意味著已經到了標簽串列的結束位置。這意味著我們已經查找了目錄中所有的標簽。所以,如果我們再次運行我們的函式,現在它應該能夠給出一個答案。如果標簽編號不為 0,我們檢查這個標簽型別是否已經有一個地址。如果沒有,我們在目錄中儲存這個標簽的地址。然後增加這個標簽的長度(以位元組為單位)到標簽地址中,然後去查找下一個標簽。

嘗試去用彙編實現這段代碼。你將需要簡化它。如果被卡住了,下麵是我的答案。不要忘了 .section .text

  1. .section .text
  2. .globl FindTag
  3. FindTag:
  4. tag .req r0
  5. tagList .req r1
  6. tagAddr .req r2
  7. sub tag,#1
  8. cmp tag,#8
  9. movhi tag,#0
  10. movhi pc,lr
  11. ldr tagList,=tag_core
  12. tagReturn$:
  13. add tagAddr,tagList, tag,lsl #2
  14. ldr tagAddr,[tagAddr]
  15. teq tagAddr,#0
  16. movne r0,tagAddr
  17. movne pc,lr
  18. ldr tagAddr,[tagList]
  19. teq tagAddr,#0
  20. movne r0,#0
  21. movne pc,lr
  22. mov tagAddr,#0x100
  23. push {r4}
  24. tagIndex .req r3
  25. oldAddr .req r4
  26. tagLoop$:
  27. ldrh tagIndex,[tagAddr,#4]
  28. subs tagIndex,#1
  29. poplt {r4}
  30. blt tagReturn$
  31. add tagIndex,tagList, tagIndex,lsl #2
  32. ldr oldAddr,[tagIndex]
  33. teq oldAddr,#0
  34. .unreq oldAddr
  35. streq tagAddr,[tagIndex]
  36. ldr tagIndex,[tagAddr]
  37. add tagAddr, tagIndex,lsl #2
  38. b tagLoop$
  39. .unreq tag
  40. .unreq tagList
  41. .unreq tagAddr
  42. .unreq tagIndex

5、Hello World

現在,我們已經萬事俱備了,我們可以去繪製我們的第一個字串了。在 main.s 檔案中刪除 bl SetGraphicsAddress 之後的所有代碼,然後將下麵的代碼放進去:

  1. mov r0,#9
  2. bl FindTag
  3. ldr r1,[r0]
  4. lsl r1,#2
  5. sub r1,#8
  6. add r0,#8
  7. mov r2,#0
  8. mov r3,#0
  9. bl DrawString
  10. loop$:
  11. b loop$

這段代碼簡單地使用了我們的 FindTag 方法去查找第 9 個標簽(cmdline),然後計算它的長度,然後傳遞命令和長度給 DrawString 方法,告訴它在 0,0 處繪製字串。現在可以在樹莓派上測試它了。你應該會在屏幕上看到一行文本。如果沒有,請查看我們的排錯頁面。

如果一切正常,恭喜你已經能夠繪製文本了。但它還有很大的改進空間。如果想去寫了一個數字,或記憶體的一部分,或操作我們的命令列,該怎麼做呢?在 課程 9:屏幕04[2] 中,我們將學習如何操作文本和顯示有用的數字和信息。

 

赞(0)

分享創造快樂