好不容易結束了sd_spinup_disk(),馬上我們就遇到了三座大山.它們是sd_read_capacity(),sd_read_write_protect_flag(),sd_read_cache_type(),要繼續往下看,我們不得不先推翻這三座大山.舊的三座大山已經在毛主席的英明領導下成功推翻了,但是今天我們的人民卻身處新三座大山的壓迫之下,眼前這三個函式堪比臭名昭著的房改醫改教改.要知道整個sd.c這個檔案也不過是1900行,可是光這三個函式就佔了360行,你不服不行啊!

第一座大山,sd_read_capacity.    1130 /*    1131 * read disk capacity    1132 */    1133 static void    1134 sd_read_capacity(struct scsi_disk *sdkp, unsigned char *buffer)    1135 {    1136         unsigned char cmd[16];    1137         int the_result, retries;    1138         int sector_size = 0;    1139         int longrc = 0;    1140         struct scsi_sense_hdr sshdr;    1141         int sense_valid = 0;    1142         struct scsi_device *sdp = sdkp->device;    1143    1144 repeat:    1145         retries = 3;    1146         do {    1147                 if (longrc) {    1148                         memset((void *) cmd, 0, 16);    1149                         cmd[0] = SERVICE_ACTION_IN;    1150                         cmd[1] = SAI_READ_CAPACITY_16;    1151                         cmd[13] = 12;    1152                         memset((void *) buffer, 0, 12);    1153                 } else {    1154                         cmd[0] = READ_CAPACITY;    1155                         memset((void *) &cmd[1], 0, 9);    1156                         memset((void *) buffer, 0, 8);    1157                 }    1158    1159                 the_result = scsi_execute_req(sdp, cmd, DMA_FROM_DEVICE,    1160                                               buffer, longrc ? 12 : 8, &sshdr,    1161                                               SD_TIMEOUT, SD_MAX_RETRIES);    1162    1163                 if (media_not_present(sdkp, &sshdr))    1164                         return;    1165    1166                 if (the_result)    1167                         sense_valid = scsi_sense_valid(&sshdr);    1168                 retries--;    1169    1170         } while (the_result && retries);    1171    1172         if (the_result && !longrc) {    1173                 sd_printk(KERN_NOTICE, sdkp, "READ CAPACITY failed/n");    1174                 sd_print_result(sdkp, the_result);    1175                 if (driver_byte(the_result) & DRIVER_SENSE)    1176                         sd_print_sense_hdr(sdkp, &sshdr);    1177                 else    1178                         sd_printk(KERN_NOTICE, sdkp, "Sense not available./n");    1179    1180                 /* Set dirty bit for removable devices if not ready -    1181                  * sometimes drives will not report this properly. */    1182                 if (sdp->removable &&    1183                     sense_valid && sshdr.sense_key == NOT_READY)    1184                         sdp->changed = 1;    1185    1186                 /* Either no media are present but the drive didn't tell us,    1187                    or they are present but the read capacity command fails */    1188                 /* sdkp->media_present = 0; -- not always correct */    1189                 sdkp->capacity = 0; /* unknown mapped to zero - as usual */    1190    1191                 return;    1192         } else if (the_result && longrc) {    1193                 /* READ CAPACITY(16) has been failed */    1194                 sd_printk(KERN_NOTICE, sdkp, "READ CAPACITY(16) failed/n");    1195                 sd_print_result(sdkp, the_result);    1196                 sd_printk(KERN_NOTICE, sdkp, "Use 0xffffffff as device size/n");    1197    1198                 sdkp->capacity = 1 + (sector_t) 0xffffffff;    1199                 goto got_data;    1200         }    1201    1202         if (!longrc) {    1203                 sector_size = (buffer[4] << 24) |    1204                         (buffer[5] << 16) | (buffer[6] << 8) | buffer[7];    1205                 if (buffer[0] == 0xff && buffer[1] == 0xff &&    1206                     buffer[2] == 0xff && buffer[3] == 0xff) {    1207                         if(sizeof(sdkp->capacity) > 4) {    1208                                 sd_printk(KERN_NOTICE, sdkp, "Very big device. "    1209                                           "Trying to use READ CAPACITY(16)./n");    1210                                 longrc = 1;    1211                                 goto repeat;    1212                         }    1213                         sd_printk(KERN_ERR, sdkp, "Too big for this kernel. Use "    1214                                   "a kernel compiled with support for large "    1215                                   "block devices./n");    1216                         sdkp->capacity = 0;    1217                         goto got_data;    1218                 }    1219                 sdkp->capacity = 1 + (((sector_t)buffer[0] << 24) |    1220                         (buffer[1] << 16) |    1221                         (buffer[2] << 8) |    1222                         buffer[3]);    1223         } else {    1224                 sdkp->capacity = 1 + (((u64)buffer[0] << 56) |    1225                         ((u64)buffer[1] << 48) |    1226                         ((u64)buffer[2] << 40) |    1227                         ((u64)buffer[3] << 32) |    1228                         ((sector_t)buffer[4] << 24) |    1229                         ((sector_t)buffer[5] << 16) |    1230                         ((sector_t)buffer[6] << 8) |    1231                         (sector_t)buffer[7]);    1232    1233                 sector_size = (buffer[8] << 24) |    1234                         (buffer[9] << 16) | (buffer[10] << 8) | buffer[11];    1235         }    1236    1237         /* Some devices return the total number of sectors, not the    1238          * highest sector number. Make the necessary adjustment. */    1239         if (sdp->fix_capacity) {    1240                 --sdkp->capacity;    1241    1242         /* Some devices have version which report the correct sizes    1243          * and others which do not. We guess size according to a heuristic    1244          * and err on the side of lowering the capacity. */    1245         } else {    1246                 if (sdp->guess_capacity)    1247                         if (sdkp->capacity & 0x01) /* odd sizes are odd */    1248                                 --sdkp->capacity;    1249         }    1250    1251 got_data:    1252         if (sector_size == 0) {    1253                 sector_size = 512;    1254                 sd_printk(KERN_NOTICE, sdkp, "Sector size 0 reported, "    1255                           "assuming 512./n");    1256         }    1257    1258         if (sector_size != 512 &&    1259             sector_size != 1024 &&    1260             sector_size != 2048 &&    1261             sector_size != 4096 &&    1262             sector_size != 256) {    1263                 sd_printk(KERN_NOTICE, sdkp, "Unsupported sector size %d./n",    1264                           sector_size);    1265                 /*    1266                  * The user might want to re-format the drive with    1267                  * a supported sectorsize. Once this happens, it    1268                  * would be relatively trivial to set the thing up.    1269                  * For this reason, we leave the thing in the table.    1270                  */    1271                 sdkp->capacity = 0;    1272                 /*    1273                  * set a bogus sector size so the normal read/write    1274                  * logic in the block layer will eventually refuse any    1275                  * request on this device without tripping over power    1276                  * of two sector size assumptions    1277                  */    1278                 sector_size = 512;    1279         }    1280         {    1281                /*    1282                  * The msdos fs needs to know the hardware sector size    1283                  * So I have created this table. See ll_rw_blk.c    1284                  * Jacques Gelinas ([email protected])    1285                  */    1286                 int hard_sector = sector_size;    1287                 sector_t sz = (sdkp->capacity/2) * (hard_sector/256);    1288                 request_queue_t *queue = sdp->request_queue;    1289                 sector_t mb = sz;   1290    1291                 blk_queue_hardsect_size(queue, hard_sector);    1292                 /* avoid 64-bit division on 32-bit platforms */    1293                 sector_div(sz, 625);    1294                 mb -= sz - 974;    1295                 sector_div(mb, 1950);    1296    1297                 sd_printk(KERN_NOTICE, sdkp,    1298                           "%llu %d-byte hardware sectors (%llu MB)/n",    1299                           (unsigned long long)sdkp->capacity,    1300                           hard_sector, (unsigned long long)mb);    1301         }    1302    1303         /* Rescale capacity to 512-byte units */    1304         if (sector_size == 4096)    1305                 sdkp->capacity <<= 3;    1306         else if (sector_size == 2048)    1307                 sdkp->capacity <<= 2;    1308         else if (sector_size == 1024)    1309                 sdkp->capacity <<= 1;    1310         else if (sector_size == 256)    1311                 sdkp->capacity >>= 1;    1312    1313         sdkp->device->sector_size = sector_size;    1314 } 洋洋灑灑200餘行.簡而言之,這個函式用一句話來表達就是知道這個磁碟的容量,或者專業一點說,傳送READ CAPACITY命令.而熟悉SCSI命令集的兄弟們應該知道,很多SCSI命令都有至少兩種版本,不同版本的命令格式會不一樣,當然返回的資訊量也不盡相同,比如READ CAPACITY命令就有10個位元組的和16個位元組的兩個版本.在SBC-2的5.10節和5.11節分別介紹的是READ CAPACITY(10) command和READ CAPACITY(16) command.後者比前者多一個保護資訊.但是在我們讀之前我們並不知道該用哪個命令,所以這裡的基本思路就是先用短命令,如果失敗了就試一下長命令,這就是1211行goto repeat的目的.在goto repeat之前1210行設定了longrc為1.我們這裡先給出來自SBC-2中對READ CAPACITY命令的格式定義: 我們可以用一個例項來描述這個命令,sg_readcap可以手工傳送READ CAPACITY命令.下面是針對我的一個號稱128M的U盤傳送這個命令的結果. [[email protected] ~]# sg_readcap /dev/sdc Read Capacity results:    Last logical block address=257535 (0x3edff), Number of blocks=257536    Logical block length=512 bytes Hence:    Device size: 131858432 bytes, 125.8 MiB, 0.13 GB 與此同時,我們結合程式碼來看,這個函式實際上比較麻煩的地方在於對buffer陣列的判斷.實際上buffer陣列裝載了READ CAPACITY命令的返回資訊.而我們從1203行開始判斷,首先我們知道這個buffer是我們在sd_revalidate_disk()中申請的.其大小為SD_BUF_SIZE,即512個位元組.那麼這個buffer的資料究竟是什麼模樣呢?SBC-2中Table-35對READ CAPACITY(10)的返回資料給出瞭如圖的格式, 這裡byte4,byte5,byte6,byte7共同描述了Block的大小.即所謂的扇區大小,或者說程式碼中的sector_size,大多數情況下我們看到的都是512bytes.這裡我的這個U盤當然也屬於這種情況. RETURNED LOGICAL BLOCK ADDRESS就是告訴你這個裝置有多少個Block,或者通俗點說,有多少個扇區.當然,更準確地說,如果你這個磁碟有N個Block,那麼這裡返回的是最後一個Block的編號,因為編號是從0開始,所以最後一個Block的編號就是N-1.所以這裡返回的是N-1.而SBC-2規定,倘若byte0,byte1,byte2,byte3如果全為FF,那麼說明READ CAPACITY(10)不足以讀取這塊磁碟的容量.這有點類似於傳說中的緩衝區溢位.這種情況下再判斷一下,如果sizeof(sdkp->capacity)確實大於4,那麼這裡溢位了我們goto repeat,改而傳送READ CAPACITY(16).實際上,因為capacity是sector_t型別的,而在include/linux/types.h中,sector_t是這麼定義的,     140 #ifdef CONFIG_LBD     141 typedef u64 sector_t;     142 #else     143 typedef unsigned long sector_t;     144 #endif 所以,sector_t的size有可能是是大於4的,也有可能是等於4的.如果等於4那就沒辦法了.只能設定capacity為0.我們沒有辦法記錄下究竟有多少個扇區,那麼我們大不了就不記錄.(同時我們下面也可以看到幾處我們設定了capacity為0,其目的都是一樣,只做力所能及的事情,而不是強人所難,畢竟強扭的瓜不甜.) 當然如果沒有溢位,那麼就執行1219行,設定sdkp的capacity,剛才說了,它和byte0,byte1,byte2,byte3的共同作用的區別就是N和N-1的關係,所以這裡我們看到需要加上1.因此sdkp->capacity記錄的就是磁碟有多少個扇區. 而1223行這個else這一段,就是針對長命令的buffer進行處理的,因為SBC-2規定了,長命令的返回結果是下面這幅圖這樣的: 可以看出,這次byte0,byte1,…,byte7這8個byte共同作用來表示了Block數.而byte8,byte9,byte10,byte11共同作用表示了block的大小,或者說扇區大小. 1239行說的也就是N和N-1的那件事,有些裝置不按常理出牌,它彙報的時候已經把那個1給包括進來了,所以這裡咱們只能再減一,凡是有這種特殊需求的裝置會設定fix_capacity. 1245行又是針對另外一些不按常理出牌的裝置的應對措施.這個咱就飄過了.畢竟連磁碟的大小都要別人去猜這廠家也太無恥了. 1252行,對於那些內向的裝置,我們只能假設它們是遵守遊戲規則的,我們假設它們的扇區大小是大眾化的512. 另一方面,1258行這一段,眾所周知,扇區大小總是512,1024,2048,4096,最次的也是256.除此之外的裝置基本上就可以去參加裝置殘奧會了,沒必要拿出來丟人現眼. 1280行至1301行的目的在註釋裡說得很清楚,咱們可以飄過不理.只是需要注意1291行呼叫了blk_queue_hardsect_size(),這個函式非常的短,就是一句話,即把一個struct request_queue_t指標的成員hardsect_size的值設定為這裡的引數hard_sector.還是那句話,基本上也就是設定成512,畢竟這是絕對主流.如果你的裝置非要顯示一下80後的與眾不同的個性,那我也沒辦法.只是莊子曾經曰過:”莫裝吊,裝吊遭狗咬!” 1304行開始的這一段if-else if,就是針對sector_size調整一下capacity,因為capacity應該用來記錄有多少個扇區,而我們希望在程式碼中統一使用512位元組的扇區,(這也是Linux中的一貫規矩)所以這裡需要按比例調整一下.即原本讀出來是說有100個扇區,但是每個扇區比如是4096個位元組,那麼如果我們要以從軟體角度來說以512位元組進行訪問,那麼我就可以記錄說這個磁碟有800個扇區. 最後,1313行,把sector_size也記錄在sdkp的成員struct scsi_device指標device的sector_size內. 原文見：http://blog.csdn.net/fudan_abc/article/details/1927932