लिनक्स कर्नेल 5.0 - blk-mq के तहत सरल ब्लॉक डिवाइस लिखना

खुशखबरी, हर कोई!

लिनक्स कर्नेल 5.0 पहले से ही यहां है और प्रयोगात्मक वितरण जैसे आर्क, ओपनसैब टम्बलवीड, फेडोरा में दिखाई देता है।



और अगर आप उबंटू डिस्को डिंगो और रेड हैट 8 के आरसी वितरण को देखते हैं, तो यह स्पष्ट हो जाता है: जल्द ही कर्नेल 5.0 भी प्रशंसक डेस्कटॉप से ​​गंभीर सर्वर में स्थानांतरित हो जाएगा।
कोई कहेगा - तो क्या। अगली रिलीज, कुछ खास नहीं। लिनुस टोरवाल्ड्स ने खुद कहा:

मैं इंगित करना चाहता हूं (अभी तक फिर से) कि हम फीचर-आधारित रिलीज़ नहीं करते हैं, और "5.0" का इससे अधिक मतलब नहीं है कि 4.x संख्याएं इतनी बड़ी होने लगीं कि मैं उंगलियों से बाहर भाग गया और पैर की उंगलियों।

( एक बार फिर मैं दोहराता हूं - हमारी रिलीज़ किसी भी विशिष्ट सुविधाओं से जुड़ी नहीं हैं, इसलिए नए संस्करण 5.0 की संख्या का मतलब केवल यह है कि नंबरिंग संस्करणों के लिए 4.x मेरे पास पहले से ही पर्याप्त उंगलियां और पैर की उंगलियां नहीं हैं )

हालांकि, फ्लॉपी डिस्क के लिए मॉड्यूल (जो नहीं जानता है - ये 1.44 एमबी की क्षमता के साथ एक स्तन जेब शर्ट के आकार के डिस्क हैं) - सही ...
और यहाँ क्यों है:

यह बहु-कतार ब्लॉक लेयर (blk-mq) के बारे में है। इंटरनेट पर उनके बारे में बहुत सारे परिचयात्मक लेख हैं, तो चलो बिंदु पर सही हो जाते हैं। Blk-mq के लिए संक्रमण बहुत पहले शुरू किया गया था और धीरे-धीरे आगे बढ़ रहा था। मल्टी-कतार scsi (कर्नेल पैरामीटर scsi_mod.use_blk_mq) दिखाई दिया, नए शेड्यूलर mq-deadline, bfq और इतने पर ...

[root@fedora-29 sblkdev]# cat /sys/block/sda/queue/scheduler [mq-deadline] none 

वैसे, तुम्हारा क्या है?

पुराने फैशन का काम करने वाले ब्लॉक डिवाइस ड्राइवरों की संख्या कम हो गई थी। और 5.0 में, blk_init_queue () फ़ंक्शन को अनावश्यक के रूप में हटा दिया गया था। और अब 2003 के पुराने शानदार कोड lwn.net/Articles/58720 से न केवल जाना जा रहा है, बल्कि खोया हुआ महत्व भी है। इसके अलावा, नए वितरण, जो इस वर्ष रिलीज के लिए तैयार किए जा रहे हैं, डिफ़ॉल्ट कॉन्फ़िगरेशन में एक बहु-कतार ब्लॉक परत का उपयोग करते हैं। उदाहरण के लिए, 18 वें मंज़रो पर, कर्नेल, हालांकि संस्करण 4.19, डिफ़ॉल्ट रूप से ब्लेक-एमके है।

इसलिए, हम मान सकते हैं कि कर्नेल 5.0 में blk-mq के लिए संक्रमण पूरा हो गया है। और मेरे लिए यह एक महत्वपूर्ण घटना है जिसे कोड को फिर से लिखना और अतिरिक्त परीक्षण की आवश्यकता होगी। जो अपने आप में बड़े और छोटे, साथ ही कई दुर्घटनाग्रस्त सर्वरों की उपस्थिति का वादा करता है (यह आवश्यक है, फेडिया, यह आवश्यक है! (सी))।

वैसे, अगर किसी को लगता है कि rhel8 के लिए यह मोड़ नहीं आया था, क्योंकि कर्नेल को "फ़्लैश" किया गया था, जो कि 4.18 संस्करण था, तो आप गलत हैं। Rhel8 पर नए आरसी में, 5.0 से नए उत्पाद पहले ही माइग्रेट हो गए थे, और blk_init_queue () फ़ंक्शन भी कट गया था (शायद जब एक और चेक-इन github.com/torvalds/linux को अपने स्रोतों से खींच रहा हो)।
सामान्य तौर पर, SUSE और Red Hat जैसे लिनक्स वितरकों के लिए कर्नेल का "फ्रीज" संस्करण लंबे समय से एक विपणन अवधारणा है। प्रणाली रिपोर्ट करती है कि संस्करण, उदाहरण के लिए, 4.4 है, और वास्तव में कार्यक्षमता ताजे 4.8 वेनिला से है। इसी समय, एक शिलालेख आधिकारिक वेबसाइट पर दिखाती है जैसे: "नए वितरण में, हमने आपके लिए एक स्थिर 4.4 कर्नेल रखा है।"

लेकिन हम विचलित थे ...

तो यहाँ है। हमें यह स्पष्ट करने के लिए एक नए सरल ब्लॉक डिवाइस ड्राइवर की आवश्यकता है कि यह कैसे काम करता है।
तो, स्रोत github.com/CodeImp/sblkdev पर। मैं चर्चा करने का प्रस्ताव करता हूं, पुल अनुरोध करें, मुद्दा शुरू करें - मैं इसे ठीक कर दूंगा। क्यूए ने अभी तक परीक्षण नहीं किया है।

बाद में लेख में मैं यह बताने की कोशिश करूंगा कि ऐसा क्यों है इसलिए, बहुत कोड है।
मैं तुरंत माफी माँगता हूँ कि लिनक्स कर्नेल कोडिंग शैली पूरी तरह से सम्मानित नहीं है, और हाँ - मुझे गोटो पसंद नहीं है।

तो, चलो प्रवेश बिंदुओं से शुरू करते हैं।

 static int __init sblkdev_init(void) { int ret = SUCCESS; _sblkdev_major = register_blkdev(_sblkdev_major, _sblkdev_name); if (_sblkdev_major <= 0){ printk(KERN_WARNING "sblkdev: unable to get major number\n"); return -EBUSY; } ret = sblkdev_add_device(); if (ret) unregister_blkdev(_sblkdev_major, _sblkdev_name); return ret; } static void __exit sblkdev_exit(void) { sblkdev_remove_device(); if (_sblkdev_major > 0) unregister_blkdev(_sblkdev_major, _sblkdev_name); } module_init(sblkdev_init); module_exit(sblkdev_exit); 

जाहिर है, जब मॉड्यूल लोड किया जाता है, तो sblkdev_init () फ़ंक्शन लॉन्च किया जाता है, जब sblkdev_exit () अनलोड होता है।
Register_blkdev () फ़ंक्शन एक ब्लॉक डिवाइस को पंजीकृत करता है। उन्हें एक बड़ी संख्या आवंटित की जाती है। unregister_blkdev () - इस संख्या को मुक्त करता है।

हमारे मॉड्यूल की मुख्य संरचना sblkdev_device_t है।

 // The internal representation of our device typedef struct sblkdev_device_s { sector_t capacity; // Device size in bytes u8* data; // The data aray. u8 - 8 bytes atomic_t open_counter; // How many openers struct blk_mq_tag_set tag_set; struct request_queue *queue; // For mutual exclusion struct gendisk *disk; // The gendisk structure } sblkdev_device_t; 

इसमें विशेष रूप से कर्नेल मॉड्यूल के लिए आवश्यक डिवाइस के बारे में सभी जानकारी होती है: ब्लॉक डिवाइस की क्षमता, स्वयं डेटा (यह सरल है), डिस्क और कतार को इंगित करता है।

सभी ब्लॉक डिवाइस इनिशियलाइज़ेशन sblkdev_add_device () फ़ंक्शन में किया जाता है।

 static int sblkdev_add_device(void) { int ret = SUCCESS; sblkdev_device_t* dev = kzalloc(sizeof(sblkdev_device_t), GFP_KERNEL); if (dev == NULL) { printk(KERN_WARNING "sblkdev: unable to allocate %ld bytes\n", sizeof(sblkdev_device_t)); return -ENOMEM; } _sblkdev_device = dev; do{ ret = sblkdev_allocate_buffer(dev); if(ret) break; #if 0 //simply variant with helper function blk_mq_init_sq_queue. It`s available from kernel 4.20 (vanilla). {//configure tag_set struct request_queue *queue; dev->tag_set.cmd_size = sizeof(sblkdev_cmd_t); dev->tag_set.driver_data = dev; queue = blk_mq_init_sq_queue(&dev->tag_set, &_mq_ops, 128, BLK_MQ_F_SHOULD_MERGE | BLK_MQ_F_SG_MERGE); if (IS_ERR(queue)) { ret = PTR_ERR(queue); printk(KERN_WARNING "sblkdev: unable to allocate and initialize tag set\n"); break; } dev->queue = queue; } #else // more flexible variant {//configure tag_set dev->tag_set.ops = &_mq_ops; dev->tag_set.nr_hw_queues = 1; dev->tag_set.queue_depth = 128; dev->tag_set.numa_node = NUMA_NO_NODE; dev->tag_set.cmd_size = sizeof(sblkdev_cmd_t); dev->tag_set.flags = BLK_MQ_F_SHOULD_MERGE | BLK_MQ_F_SG_MERGE; dev->tag_set.driver_data = dev; ret = blk_mq_alloc_tag_set(&dev->tag_set); if (ret) { printk(KERN_WARNING "sblkdev: unable to allocate tag set\n"); break; } } {//configure queue struct request_queue *queue = blk_mq_init_queue(&dev->tag_set); if (IS_ERR(queue)) { ret = PTR_ERR(queue); printk(KERN_WARNING "sblkdev: Failed to allocate queue\n"); break; } dev->queue = queue; } #endif dev->queue->queuedata = dev; {// configure disk struct gendisk *disk = alloc_disk(1); //only one partition if (disk == NULL) { printk(KERN_WARNING "sblkdev: Failed to allocate disk\n"); ret = -ENOMEM; break; } disk->flags |= GENHD_FL_NO_PART_SCAN; //only one partition //disk->flags |= GENHD_FL_EXT_DEVT; disk->flags |= GENHD_FL_REMOVABLE; disk->major = _sblkdev_major; disk->first_minor = 0; disk->fops = &_fops; disk->private_data = dev; disk->queue = dev->queue; sprintf(disk->disk_name, "sblkdev%d", 0); set_capacity(disk, dev->capacity); dev->disk = disk; add_disk(disk); } printk(KERN_WARNING "sblkdev: simple block device was created\n"); }while(false); if (ret){ sblkdev_remove_device(); printk(KERN_WARNING "sblkdev: Failed add block device\n"); } return ret; } 

हम संरचना के लिए मेमोरी आवंटित करते हैं, डेटा संग्रहीत करने के लिए एक बफर आवंटित करते हैं। यहां कुछ खास नहीं।
इसके बाद, हम अनुरोध प्रसंस्करण प्रक्रिया को या तो एक blk_mq_init_sq_queue () फ़ंक्शन, या दो को एक साथ: blk_mq_alloc_tag_set () + blk_mq_init_queue () के साथ आरंभ करते हैं।

वैसे, यदि आप blk_mq_init_sq_queue () फ़ंक्शन के स्रोतों को देखते हैं, तो आप देखेंगे कि यह blk_mq_alloc_tag_set () और blk_mq_init_queue () फ़ंक्शंस पर एक आवरण है, जो 4.20 कर्नेल में दिखाई दिया था। इसके अलावा, यह हमें कतार के कई मापदंडों को छुपाता है, लेकिन यह बहुत सरल दिखता है। आपको चुनना होगा कि कौन सा विकल्प बेहतर है, लेकिन मैं अधिक स्पष्ट पसंद करता हूं।

इस कोड की कुंजी वैश्विक चर _mq_ops है।

 static struct blk_mq_ops _mq_ops = { .queue_rq = queue_rq, }; 

यह वह जगह है जहां अनुरोधों के प्रसंस्करण प्रदान करने वाला फ़ंक्शन स्थित है, लेकिन इसके बारे में थोड़ी देर बाद। मुख्य बात यह है कि हमने प्रवेश बिंदु को अनुरोध प्रोसेसर में निर्दिष्ट किया है।

अब जब हमने कतार बना ली है, तो हम डिस्क का एक उदाहरण बना सकते हैं।

कोई बड़ा बदलाव नहीं हुआ है। डिस्क को आवंटित किया जाता है, पैरामीटर सेट किए जाते हैं, और डिस्क को सिस्टम में जोड़ा जाता है। मैं पैरामीटर डिस्क के बारे में व्याख्या करना चाहता हूं-> झंडे। यह आपको सिस्टम को यह बताने की अनुमति देता है कि डिस्क हटाने योग्य है, या, उदाहरण के लिए, कि इसमें विभाजन नहीं हैं और आपको वहां उनकी तलाश करने की आवश्यकता नहीं है।

डिस्क प्रबंधन के लिए एक _fops संरचना है।

 static const struct block_device_operations _fops = { .owner = THIS_MODULE, .open = _open, .release = _release, .ioctl = _ioctl, #ifdef CONFIG_COMPAT .compat_ioctl = _compat_ioctl, #endif }; 

एक सरल ब्लॉक डिवाइस मॉड्यूल के लिए हमारे लिए प्रवेश बिंदु _open और _release अभी तक बहुत दिलचस्प नहीं हैं। परमाणु वृद्धि और गिरावट काउंटर के अलावा, वहाँ कुछ भी नहीं है। मैंने कार्यान्वयन के बिना भी हम कुछ भी नहीं छोड़ा, क्योंकि 64-बिट कर्नेल और 32-बिट उपयोगकर्ता-स्थान वातावरण वाला सिस्टम का संस्करण मुझे आशाजनक नहीं लगता।

लेकिन _ioctl आपको इस ड्राइव के लिए सिस्टम अनुरोधों को संसाधित करने की अनुमति देता है। जब एक डिस्क दिखाई देती है, तो सिस्टम इसके बारे में अधिक जानने की कोशिश करता है। आप कुछ प्रश्नों का उत्तर दे सकते हैं जैसा कि आप फिट देखते हैं (उदाहरण के लिए, एक नई सीडी होने का ढोंग करने के लिए), लेकिन सामान्य नियम यह है: यदि आप ऐसे प्रश्नों का उत्तर नहीं देना चाहते हैं जो आपके हित में नहीं हैं, तो बस त्रुटि कोड -ENOTTY लौटाएं। वैसे, यदि आवश्यक हो, तो यहां आप इस विशेष ड्राइव के बारे में अपने अनुरोध हैंडलर जोड़ सकते हैं।

इसलिए, हमने डिवाइस को जोड़ा - हमें संसाधनों की रिहाई का ध्यान रखना चाहिए। जंग यहाँ तुम्हारे लिए नहीं है ।

 static void sblkdev_remove_device(void) { sblkdev_device_t* dev = _sblkdev_device; if (dev){ if (dev->disk) del_gendisk(dev->disk); if (dev->queue) { blk_cleanup_queue(dev->queue); dev->queue = NULL; } if (dev->tag_set.tags) blk_mq_free_tag_set(&dev->tag_set); if (dev->disk) { put_disk(dev->disk); dev->disk = NULL; } sblkdev_free_buffer(dev); kfree(dev); _sblkdev_device = NULL; printk(KERN_WARNING "sblkdev: simple block device was removed\n"); } } 

सिद्धांत रूप में, सब कुछ स्पष्ट है: हम डिस्क ऑब्जेक्ट को सिस्टम से हटाते हैं और कतार को मुक्त करते हैं, जिसके बाद हम अपने बफ़र्स (डेटा क्षेत्र) को भी मुक्त करते हैं।

और अब सबसे महत्वपूर्ण बात यह है कि queue_rq () फ़ंक्शन में क्वेरी प्रोसेसिंग।

 static blk_status_t queue_rq(struct blk_mq_hw_ctx *hctx, const struct blk_mq_queue_data* bd) { blk_status_t status = BLK_STS_OK; struct request *rq = bd->rq; blk_mq_start_request(rq); //we cannot use any locks that make the thread sleep { unsigned int nr_bytes = 0; if (do_simple_request(rq, &nr_bytes) != SUCCESS) status = BLK_STS_IOERR; printk(KERN_WARNING "sblkdev: request process %d bytes\n", nr_bytes); #if 0 //simply and can be called from proprietary module blk_mq_end_request(rq, status); #else //can set real processed bytes count if (blk_update_request(rq, status, nr_bytes)) //GPL-only symbol BUG(); __blk_mq_end_request(rq, status); #endif } return BLK_STS_OK;//always return ok } 

सबसे पहले, मापदंडों पर विचार करें। पहली संरचना blk_mq_hw_ctx * hctx - हार्डवेयर कतार की स्थिति है। हमारे मामले में, हम हार्डवेयर कतार के बिना करते हैं, इसलिए अप्रयुक्त।

दूसरा पैरामीटर है const संरचना blk_mq_queue_data * bd - बहुत संक्षिप्त संरचना वाला एक पैरामीटर, जिसे मैं संपूर्णता में आपके ध्यान में प्रस्तुत करने से नहीं डरता:

 struct blk_mq_queue_data { struct request *rq; bool last; }; 

यह पता चला है कि संक्षेप में, यह वही अनुरोध है जो हमारे पास कई बार आया था कि क्रॉसलर elixir.bootlin.com अब याद नहीं करता है। इसलिए हम अनुरोध लेते हैं और इसे संसाधित करना शुरू करते हैं, जिसके बारे में हम blk_mq_start_request () को कॉल करके सूचित करते हैं। अनुरोध की प्रक्रिया पूरी होने पर, हम इस बारे में कर्नेल को blk_mq_end_request () फ़ंक्शन पर कॉल करके सूचित करेंगे।

यहाँ एक छोटा सा नोट है: blk_mq_end_request () फ़ंक्शन अनिवार्य रूप से blk_update_request () + __blk_mq_end_request () पर कॉल पर एक आवरण है। Blk_mq_end_request () फ़ंक्शन का उपयोग करते समय, आप यह निर्दिष्ट नहीं कर सकते कि वास्तव में कितने बाइट्स संसाधित किए गए थे। मानता है कि सब कुछ संसाधित है।

वैकल्पिक विकल्प में एक और विशेषता है: blk_update_request फ़ंक्शन केवल GPL- केवल मॉड्यूल के लिए निर्यात किया जाता है। यही है, यदि आप एक मालिकाना कर्नेल मॉड्यूल बनाना चाहते हैं (पीएम आपको इस कंटीले रास्ते से बचाने के लिए), तो आप blk_update_request () का उपयोग नहीं कर सकते। तो चुनाव आपका है।

सीधे बाइट को बफ़र के अनुरोध से स्थानांतरित करना और इसके विपरीत मैं do_simple_request () फ़ंक्शन में डाल देता हूं।

 static int do_simple_request(struct request *rq, unsigned int *nr_bytes) { int ret = SUCCESS; struct bio_vec bvec; struct req_iterator iter; sblkdev_device_t *dev = rq->q->queuedata; loff_t pos = blk_rq_pos(rq) << SECTOR_SHIFT; loff_t dev_size = (loff_t)(dev->capacity << SECTOR_SHIFT); printk(KERN_WARNING "sblkdev: request start from sector %ld \n", blk_rq_pos(rq)); rq_for_each_segment(bvec, rq, iter) { unsigned long b_len = bvec.bv_len; void* b_buf = page_address(bvec.bv_page) + bvec.bv_offset; if ((pos + b_len) > dev_size) b_len = (unsigned long)(dev_size - pos); if (rq_data_dir(rq))//WRITE memcpy(dev->data + pos, b_buf, b_len); else//READ memcpy(b_buf, dev->data + pos, b_len); pos += b_len; *nr_bytes += b_len; } return ret; } 

नया कुछ भी नहीं है: rq_for_each_segment सब कुछ बायो पर निर्भर करता है, और इन सभी में बायोवेक संरचनाएं हैं, जो हमें अनुरोध डेटा के साथ पृष्ठों पर पहुंचने की अनुमति देती हैं।

आपके इंप्रेशन क्या हैं? सब कुछ सरल लगता है? सामान्य रूप से अनुरोध प्रसंस्करण केवल अनुरोध के पृष्ठों और आंतरिक बफर के बीच डेटा की प्रतिलिपि बना रहा है। एक साधारण ब्लॉक डिवाइस ड्राइवर के लिए काफी योग्य है, है ना?

लेकिन एक समस्या है: यह वास्तविक उपयोग के लिए नहीं है!

समस्या का सार यह है कि queue_rq () अनुरोध प्रसंस्करण फ़ंक्शन को लूप में कहा जाता है जो सूची से अनुरोधों को संसाधित करता है। मुझे नहीं पता है कि इस सूची के लिए कौन सा लॉक उपयोग किया गया है, स्पिन या RCU (मैं झूठ नहीं बोलना चाहता हूं - जो जानता है, मुझे सही करें), लेकिन जब आप उपयोग करने का प्रयास करते हैं, उदाहरण के लिए, अनुरोध प्रसंस्करण कार्य में म्यूटेक्स, डिबगिंग कर्नेल शपथ और चेतावनी: डोज़ यहाँ यह असंभव है। यही है, पारंपरिक तुल्यकालन उपकरण या आभासी सन्निहित स्मृति का उपयोग करना - जो कि vmalloc का उपयोग करके आवंटित किया गया है और सभी के साथ स्वैप में गिर सकता है जिसका अर्थ है कि यह असंभव है - चूंकि प्रक्रिया स्टैंडबाय स्थिति में नहीं जा सकती है।

इसलिए, या तो केवल स्पिन या RCU लॉक और पृष्ठों की एक सरणी के रूप में एक बफर, या एक सूची, या एक पेड़, के रूप में .. \ linux \ driver \ block \ brd.c में लागू किया गया, या एक और धागे में प्रसंस्करण में देरी, जैसा कि .. में लागू \ linux \ ड्राइवर \ block \ loop.c.

मुझे लगता है कि मॉड्यूल को कैसे इकट्ठा करना है, इसे सिस्टम में कैसे लोड करना है और कैसे अनलोड करना है, इसका वर्णन करने की कोई आवश्यकता नहीं है। इस मोर्चे पर कोई नए उत्पाद नहीं हैं, और इसके लिए धन्यवाद :) तो अगर कोई इसे आज़माना चाहता है, तो मुझे यह पता लगाना ज़रूरी है। बस अपने पसंदीदा लैपटॉप पर इसे अभी मत करो! एक वर्चुअलोका उठाएं या कम से कम एक गेंद पर बैकअप बनाएं।

वैसे, लिनक्स 3.0.1.1046 के लिए वीम बैकअप पहले से ही उपलब्ध है। बस एक कर्नेल 5.0 या बाद में वैल 3.0.1.1046 चलाने की कोशिश न करें। veeamsnap इकट्ठा नहीं होगा। और कुछ बहु-कतार नवाचार अभी भी परीक्षण के स्तर पर हैं।