नमस्ते विश्व! टर्मिनलों में गहरा विसर्जन

मुझे यह लेख सिश्नी प्रिंटफ के विश्लेषण पर एक लेख द्वारा लिखने के लिए प्रेरित किया गया था। हालांकि, टर्मिनल डिवाइस में प्रवेश करने के बाद डेटा किस तरह जाता है, इसके बारे में एक पल याद किया गया था। इस लेख में मैं इस दोष को ठीक करना चाहता हूं और टर्मिनल में डेटा पथ का विश्लेषण करना चाहता हूं। हम यह भी समझेंगे कि टर्मिनल शेल से अलग कैसे है, स्यूडोटर्मिनल क्या है, टर्मिनल एमुलेटर कैसे काम करते हैं, और बहुत कुछ।

मूल बातें

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

अंतिम

एक टर्मिनल एक डिस्प्ले और एक कीबोर्ड का संयोजन है, जो एक भौतिक उपकरण है। टर्मिनलों के इस विशेष संयोजन बनने से पहले, वे टेलीप्रिंटर (टेलेटाइप, टेलेटाइप्रिटर या संक्षेप में TTY) नामक एक प्रकार का उपकरण थे, यानी प्रिंटर और कीबोर्ड का संयोजन। आमतौर पर, कई टर्मिनल एक ही कंप्यूटर से जुड़े होते हैं। इस प्रकार, एक ही कंप्यूटर पर कई उपयोगकर्ताओं के लिए काम करना संभव था, और प्रत्येक का अपना सत्र था, दूसरों से स्वतंत्र। टर्मिनल का नाम इसलिए रखा गया क्योंकि यह टर्मिनल केबल के अंत में स्थित था।

यह टेलेटाइप है :

और यह टर्मिनल है :

कंसोल

कंसोल (कंसोल) - एक टर्मिनल जो सीधे कंप्यूटर से जुड़ा होता है। तथ्य यह है कि अधिकांश टर्मिनलों को स्पष्ट रूप से जोड़ा गया था, लेकिन कम से कम एक कंप्यूटर से सीधे जुड़ा हुआ था। कंसोल को लोगों के कड़ाई से परिभाषित सर्कल का उपयोग करने की अनुमति दी गई थी, क्योंकि यह आपको कंप्यूटर को कॉन्फ़िगर करने की अनुमति देता था।

खोल

यदि पिछले दो भौतिक उपकरण हैं, तो यह परिभाषा विशेष रूप से सॉफ्टवेयर को संदर्भित करती है।

शेल एक कमांड लाइन दुभाषिया है। अन्य कार्यक्रमों को चलाने का मुख्य उद्देश्य है। बड़ी संख्या में विभिन्न शैल हैं। सबसे आम है बैश (अंग्रेजी बॉर्न अगेन शेल से, जैसा कि विकिपीडिया सुझाव देता है, "बॉर्न अगेन" शेल के लिए एक वाक्य है, अर्थात "पुनर्जीवित" शैल)। अन्य उदाहरण: डैश (एक हल्का शेल, उपलब्ध यदि आप बाइनरी को / बिन / श) पर चलाते हैं, तो Zsh।

बेशक, टर्मिनल और कंसोल दोनों आधुनिक समय में अपना प्रतिबिंब नहीं खोज पाए। इसलिए, आगे हम ऐसी चीजों पर विचार करेंगे जैसे कि टर्मिनल एमुलेटर और वर्चुअल कंसोल ।

टर्मिनल एमुलेटर

टर्मिनल एमुलेटर - अच्छे पुराने टर्मिनल का एक एमुलेटर। एक टर्मिनल एमुलेटर उन कार्यक्रमों के लिए आवश्यक है जो एक्स विंडो सिस्टम - बैश, विम और अन्य के साथ सीधे बातचीत नहीं कर सकते हैं।

आइए पहले टर्मिनल की जिम्मेदारियों को स्थापित करें:

1. उपयोगकर्ता इनपुट को कंप्यूटर पर स्थानांतरित करें
2. डिस्प्ले में कंप्यूटर आउटपुट की डिलीवरी

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

कृपया शेल और टर्मिनल एमुलेटर को भ्रमित न करें!
टर्मिनल एमुलेटर एक जीयूआई एप्लीकेशन है, जो कि एक्स विंडो सिस्टम में एक विंडो है। शेल एक कमांड लाइन दुभाषिया है, यानी सिर्फ एक कमांड निष्पादक है, इसमें ग्राफिकल शेल नहीं है। काफी सही ढंग से बोलते हुए, आप बैश लॉन्च नहीं करते हैं , आप टर्मिनल एमुलेटर चलाते हैं, जो बैश को अपने अंदर लॉन्च करता है । टर्मिनल एमुलेटर और बैश बिल्कुल 2 अलग-अलग प्रोग्राम हैं। पहला इनपुट / आउटपुट के लिए पूरी तरह से जिम्मेदार है, दूसरा - प्रोसेसिंग कमांड के लिए।

लेख में आगे, टर्मिनल के सभी संदर्भ टर्मिनल एमुलेटर का उल्लेख करेंगे।

वर्चुअल कंसोल (वर्चुअल टर्मिनल)

Ctrl + Alt + FN दबाएं, जहां N में आमतौर पर 1 से 6. तक मान होता है, जो आपने अभी देखा है उसे वर्चुअल कंसोल (वर्चुअल कंसोल) या वर्चुअल टर्मिनल (वर्चुअल टर्मिनल) कहा जाता है। याद रखें कि मैंने पहले टर्मिनलों के बारे में क्या कहा था? कई टर्मिनल एक कंप्यूटर से जुड़े थे और प्रत्येक टर्मिनल एक अलग सत्र था, जो दूसरों से स्वतंत्र था। वर्चुअल कंसोल इस विचार को दोहराता है: आपके कंप्यूटर के अंदर कई स्वतंत्र सत्र हो सकते हैं (हालांकि, कंप्यूटर संसाधन अभी भी स्पष्ट रूप से साझा किए गए हैं)।

आप इस इकाई को वर्चुअल कंसोल और वर्चुअल टर्मिनल दोनों का नाम दे सकते हैं, क्योंकि परिभाषा के अनुसार, कंसोल एक कंप्यूटर से सीधे जुड़ा हुआ टर्मिनल है, लेकिन सभी वर्चुअल टर्मिनल एक अर्थ में, सीधे कंप्यूटर से जुड़े होते हैं।

TTY डिवाइस

प्रत्येक टर्मिनल को अपना खुद का TTY डिवाइस (टर्मिनल डिवाइस) सौंपा जाता है, जो कंसोल प्रदान करता है। हालांकि टेलेटाइप्स आपको मिलने की संभावना नहीं है, लेकिन टीटीवाई में कमी आज तक बरकरार है।

TTY डिवाइस में दो मूलभूत घटक होते हैं:

1. डिवाइस ड्राइवर वह कार्यक्रम में कीबोर्ड इनपुट देने और स्क्रीन पर प्रोग्राम आउटपुट प्रदर्शित करने के लिए जिम्मेदार है।
2. TTY लाइन अनुशासन (रूसी लाइन अनुशासन)। लाइन अनुशासन ड्राइवर एक्सेस इंटरफ़ेस है, जो हालांकि, TTY डिवाइस में बहुत सारे तर्क लाता है। हम कह सकते हैं कि लाइन अनुशासन प्रॉक्सी ड्राइवर को कॉल करता है। इस घटक की जिम्मेदारी का क्षेत्र क्या है, हम लेख के दौरान पता लगाएंगे।

TTY डिवाइस बनाएँ:

TTY उपकरणों के 3 प्रकार हैं:

1. कंसोल डिवाइस - वर्चुअल कंसोल ऑपरेशन प्रदान करता है। इस डिवाइस का इनपुट और आउटपुट पूरी तरह से कर्नेल द्वारा नियंत्रित होता है।
2. PTY डिवाइस (छद्म टर्मिनल) - विंडो इंटरफ़ेस में टर्मिनल ऑपरेशन प्रदान करते हैं। इस उपकरण का इनपुट और आउटपुट एक टर्मिनल एमुलेटर द्वारा नियंत्रित किया जाता है जो उपयोगकर्ता अंतरिक्ष में संचालित होता है।
3. सीरियल डिवाइस - सीधे हार्डवेयर के साथ संचार करता है। यह आमतौर पर सीधे उपयोग नहीं किया जाता है, लेकिन एक टर्मिनल डिवाइस की वास्तुकला के संगठन में निम्नतम स्तर के रूप में मौजूद है।

इस लेख में, हम विशेष रूप से दूसरे प्रकार के TTY उपकरणों के बारे में बात करेंगे - छद्म-टर्मिनल।

TTY लाइन अनुशासन

हम TTY डिवाइस लाइन के अनुशासन की जांच करना शुरू करते हैं।

एक पंक्ति अनुशासन की पहली महत्वपूर्ण विशेषता यह है कि यह I / O प्रसंस्करण के लिए जिम्मेदार है। इसमें शामिल हैं, उदाहरण के लिए, प्रसंस्करण नियंत्रण वर्ण ( नियंत्रण वर्ण देखें) और आउटपुट स्वरूपण। उदाहरण के लिए, आप किसी भी पाठ में प्रवेश करते हैं, लेकिन अचानक आपको एहसास होता है कि आपसे कुछ लिखने में गलती हुई थी और इसे मिटाना चाहते हैं - यह वह जगह है जहाँ लाइन अनुशासन खेलने में आता है।

हम विस्तार से विश्लेषण करेंगे कि वास्तव में क्या होता है जब हम टर्मिनल में चलने वाले बैश में काम करते हैं। डिफ़ॉल्ट रूप से, एक TTY डिवाइस इको सक्षम के साथ कैनोनिकल मोड में काम करता है। एक गूंज स्क्रीन पर आपके द्वारा दर्ज किए गए वर्णों का प्रदर्शन है।

जब हम प्रवेश करते हैं, उदाहरण के लिए, वर्ण a , यह वर्ण TTY डिवाइस को भेजा जाता है, लेकिन डिवाइस के TTY लाइन के अनुशासन से बाधित होता है। वह अपने आंतरिक बफर में एक चरित्र पढ़ती है, देखती है कि echo मोड चालू है, और स्क्रीन पर चरित्र प्रदर्शित करता है। इस समय, उस कार्यक्रम में पढ़ने के लिए अभी भी कुछ भी उपलब्ध नहीं है जिस पर टर्मिनल डिवाइस संलग्न है। हमें कीबोर्ड पर backspace दबाएं। प्रतीक ^? फिर से लाइन डिसिप्लिन द्वारा इंटरसेप्ट किया गया, और बाद में, यह महसूस करते हुए कि उपयोगकर्ता अंतिम दर्ज किए गए चरित्र को मिटाना चाहता है, इस चरित्र को उसके आंतरिक बफर से हटा देता है और इस चरित्र को भी स्क्रीन से मिटा देता है। अब, यदि हम Enter दबाते हैं, तो TTY लाइन अनुशासन अंततः टर्मिनल डिवाइस के रीड बफर को सब कुछ भेज देता है जो कि एलएफ सहित अनुशासन के आंतरिक बफर को पहले लिखा गया था। उसी समय, कर्सर को एक नई रेखा पर ले जाने के लिए स्क्रीन पर CR और LF अक्षर दिखाई देते हैं - यह आउटपुट का स्वरूपण है।

यह है कि कैनोनिकल मोड कैसे काम करता है - यह Enter दबाने के बाद ही सभी दर्ज किए गए वर्णों को डिवाइस में स्थानांतरित करता है, नियंत्रण वर्णों को संसाधित करता है और आउटपुट स्वरूपित करता है।

TTY लाइन संपादन

TTY लाइन एडिटिंग वह घटक है जो लाइन अनुशासन में इनपुट प्रोसेसिंग के लिए जिम्मेदार है। यह कहा जाना चाहिए कि लाइन एडिटिंग एक सामान्य अवधारणा है और इनपुट प्रोसेसिंग से संबंधित है। उदाहरण के लिए, बैश और विम का अपना लाइन एडिटिंग है।

हम स्टटी प्रोग्राम का उपयोग करके वर्तमान TTY डिवाइस की लाइन की अनुशासन सेटिंग्स को नियंत्रित कर सकते हैं। थोड़ा प्रयोग करते हैं।

बैश या किसी अन्य शेल को खोलें और टाइप करें:

 stty icanon -echo 

अब कुछ टाइप करने का प्रयास करें और आपको अपना इनपुट दिखाई नहीं देगा (आप चिंता न करें, आप अभी भी प्रोग्राम में इनपुट पास कर सकते हैं)। आपने सिर्फ इको को निष्क्रिय कर दिया है - अर्थात, स्क्रीन पर दर्ज किए गए वर्णों का प्रदर्शन। अब दर्ज करें:

 stty raw echo 

कुछ टाइप करने की कोशिश करें। आप देखें कि निष्कर्ष कैसे टूटा है। लेकिन अधिक प्रभाव के लिए, आइए डैश - टाइप /bin/sh । अब विशेष वर्ण दर्ज करने का प्रयास करें (कीबोर्ड पर कोई भी अक्षर Ctrl ) या बस Enter दबाएँ। आप हैरान हैं - स्क्रीन पर ये अजीब चरित्र क्या हैं? तथ्य यह है कि, अनुशासन के लाइन एडिटिंग के अलावा, हमने सबसे सरल शेल में प्रवेश किया है, हमने लाइन एडिटिंग बैश को भी अक्षम कर दिया है, और अब हम लाइन के अनुशासन के कच्चे मोड को शामिल करने का प्रभाव और मुख्य रूप से देख सकते हैं। यह मोड इनपुट को बिल्कुल प्रोसेस नहीं करता है और आउटपुट को फॉर्मेट नहीं करता है। कच्चे मोड की आवश्यकता क्यों है? उदाहरण के लिए, विम के लिए : यह संपूर्ण टर्मिनल विंडो में खुलता है और इनपुट को स्वयं संसाधित करता है, कम से कम ताकि लाइन अनुशासन के विशेष प्रतीक स्वयं विम के विशेष प्रतीकों के साथ प्रतिच्छेद न करें।

और भी अधिक समझ के लिए, आइए नियंत्रण पात्रों को अनुकूलित करते हुए देखें। stty <control-character> <string> कमांड हमें इसमें मदद करेगा।
बैश में दर्ज करें:

 stty erase 0 

अब erase कंट्रोल कैरेक्टर 0 को सौंपा जाएगा। backspace बटन आमतौर पर ^? मायने रखता है ^? , लेकिन अब इस विशेष चरित्र को शाब्दिक रूप से पीटीएस रीड बफर में भेजा जाएगा - इसे स्वयं आज़माएं। अब आप कीबोर्ड पर 0 बटन का उपयोग करके वर्णों को मिटा सकते हैं, क्योंकि आपने स्वयं tty लाइन अनुशासन से एक चिह्नित नियंत्रण वर्ण के रूप में दर्ज चरित्र को पहचानने के लिए कहा था। आप कमांड stty erase ^\? का उपयोग करके सेटिंग वापस कर सकते हैं stty erase ^\? या बस टर्मिनल को बंद करना, क्योंकि हमने केवल वर्तमान टटी डिवाइस को प्रभावित किया है।

आप मैन स्ट्टी में अधिक जानकारी पा सकते हैं।

टर्मिनल एमुलेटर और स्यूडोटर्मिनल

हर बार जब हम X विंडो सिस्टम में एक नया टर्मिनल खोलते हैं, GNOME टर्मिनल सर्वर एक नई प्रक्रिया को जन्म देता है और इसमें डिफ़ॉल्ट प्रोग्राम लॉन्च करता है। आमतौर पर, यह किसी प्रकार का शेल (उदाहरण के लिए, बैश) है।

चल रहे कार्यक्रम के साथ संचार तथाकथित स्यूडोटर्मिनल (छद्म टर्मिनल, पीटीवाई) के माध्यम से होता है। छद्म-टर्मिनल स्वयं कर्नेल में मौजूद है, हालांकि, यह टर्मिनल एमुलेटर से - उपयोगकर्ता स्थान से इनपुट प्राप्त करता है।

छद्म टर्मिनल में निम्नलिखित दो आभासी TTY उपकरण शामिल हैं :
1) PTY मास्टर (PTM) - छद्म टर्मिनल का प्रमुख हिस्सा। गनोम टर्मिनल सर्वर द्वारा टर्मिनल के अंदर चल रहे प्रोग्राम में कीबोर्ड इनपुट को स्थानांतरित करने के लिए उपयोग किया जाता है, साथ ही प्रोग्राम आउटपुट और डिस्प्ले आउटपुट को पढ़ने के लिए। गनोम टर्मिनल सर्वर, बदले में, एक्स प्रोटोकॉल के माध्यम से एक्स विंडो सिस्टम के साथ संचार करता है।
2) PTY गुलाम (PTS) - छद्म टर्मिनल का गुलाम हिस्सा। स्क्रीन पर कीबोर्ड इनपुट और डिस्प्ले आउटपुट को पढ़ने के लिए टर्मिनल के अंदर चल रहे प्रोग्राम द्वारा उपयोग किया जाता है। कम से कम, कार्यक्रम खुद ही ऐसा सोचता है (मैं इसका मतलब समझाऊंगा, थोड़ा और आगे)।

पीटीएस डिवाइस में दर्ज कोई भी डेटा पीटीएम डिवाइस का इनपुट है, यानी यह पीटीएम डिवाइस पर आसानी से पढ़ा जा सकता है। और इसके विपरीत: पीटीएम डिवाइस में दर्ज कोई भी डेटा पीटीएस डिवाइस का इनपुट है। यह कैसे गनोम टर्मिनल सर्वर और टर्मिनल के अंदर चलने वाला प्रोग्राम है। प्रत्येक पीटीएम डिवाइस अपने स्वयं के पीटीएस डिवाइस के साथ जुड़ा हुआ है।

एक नया टर्मिनल शुरू करने की प्रक्रिया कुछ इस प्रकार है:
1) GNOME टर्मिनल सर्वर एक विशेष उपकरण / देव / ptmx पर खुले () फ़ंक्शन को कॉल करके मास्टर और दास डिवाइस बनाता है। खुले () कॉल से बनाई गई PTM डिवाइस का फाइल डिस्क्रिप्टर - master_fd वापस आ जाता है ।
2) GNOME टर्मिनल सर्वर fork() कॉल करके एक नई प्रक्रिया बनाता है। यह प्रक्रिया नया टर्मिनल होगा।
3) पीटीएस टर्मिनल में, डिवाइस फ़ाइल डिस्क्रिप्टर 0, 1, 2 (क्रमशः, स्टडआउट और स्टडर,) पर खुलता है। अब, मानक टर्मिनल I / O इस उपकरण पर बहता है।
4) exec() फ़ंक्शन को कॉल करके वांछित प्रोग्राम को टर्मिनल में लॉन्च किया जाता है। कुछ शैल आमतौर पर शुरू होते हैं (उदाहरण के लिए, बैश)। बाद में बैश से लॉन्च किए गए किसी भी प्रोग्राम में बैश के रूप में एक ही फाइल डिस्क्रिप्टर होगा, यानी प्रोग्राम फ्लो को पीटीएस डिवाइस को निर्देशित किया जाएगा।

आप अपने लिए देख सकते हैं कि ls -la /proc/self/fd का उपयोग करते हुए मानक टर्मिनल आउटपुट प्रवाह कैसे निर्देशित किए जाते हैं:

पीटीएस डिवाइस पथ / देव / पीटीएस / एन पर स्थित है, और पीटीएम डिवाइस के लिए पथ हमें बिल्कुल भी रुचि नहीं देता है। तथ्य यह है कि गनोम टर्मिनल सर्वर में पहले से ही खुले पीटीएम डिवाइस के लिए एक फाइल डिस्क्रिप्टर है और इसे इसके लिए एक पथ की आवश्यकता नहीं है, हालांकि, बच्चे की प्रक्रिया में, हमें open() फ़ंक्शन को कॉल करके मानक आउटपुट धाराओं पर पीटीएस डिवाइस को खोलना होगा, जिसके लिए एक फ़ाइल पथ की आवश्यकता होती है।

याद रखें, मैंने कहा कि एक पीटीएस डिवाइस का उपयोग करने वाला एक प्रोग्राम केवल यह सोचता है कि यह टर्मिनल के साथ सीधे संवाद करता है? तथ्य यह है कि पीटीएस भी एक टर्मिनल डिवाइस (टीटीवाई डिवाइस) है, लेकिन पीटीएस डिवाइस और वास्तविक टीटीवाई डिवाइस के बीच अंतर यह है कि पीटीएस डिवाइस कीबोर्ड से इनपुट नहीं, बल्कि मास्टर डिवाइस से प्राप्त करता है, और आउटपुट डिस्प्ले में नहीं जाता है, लेकिन मास्टर डिवाइस। इसीलिए छद्म टर्मिनल को इस तरह नाम दिया गया है - छद्म टर्मिनल केवल (फिर से ??) टर्मिनल की नकल करता है। टर्मिनल एमुलेटर और छद्म टर्मिनल के बीच का अंतर यह है कि टर्मिनल एमुलेटर सिर्फ एक ग्राफिकल प्रोग्राम है जो आपको टर्मिनल को सीधे विंडो इंटरफेस के अंदर चलाने की अनुमति देता है, लेकिन यह सुविधा छद्म टर्मिनल का उपयोग करके कार्यान्वित की जाती है।

तथ्य यह है कि पीटीएस डिवाइस एक TTY डिवाइस है बहुत महत्वपूर्ण है। यहाँ क्यों है:

1. जिस प्रोग्राम के लिए टर्मिनल डिवाइस संलग्न है, उसमें पारंपरिक टर्मिनल की सभी क्षमताएं हैं। उदाहरण के लिए: निष्क्रिय गूंज, अक्षम / सक्षम विहित दृश्य।
2. प्रोग्राम, यह जानते हुए कि एक टर्मिनल डिवाइस इसके साथ जुड़ा हुआ है (यह कहा जाता है कि प्रोग्राम में एक नियंत्रण टर्मिनल है), अंतःक्रियात्मक रूप से काम कर सकता है और इनपुट के लिए उपयोगकर्ता से पूछ सकता है। उदाहरण के लिए, उपयोगकर्ता नाम और पासवर्ड के लिए पूछें।
3. टीटीवाई लाइन अनुशासन भी है, इसलिए हमारे पास कार्यक्रम तक पहुंचने से पहले नियंत्रण पात्रों को संसाधित करने की क्षमता है, साथ ही साथ कार्यक्रम के आउटपुट को प्रारूपित करते हैं।

PTM डिवाइस भी TTY डिवाइस है, लेकिन यह किसी भी भूमिका को नहीं निभाता है, क्योंकि इसका उपयोग नियंत्रण टर्मिनल के रूप में नहीं किया जाता है। इसके अलावा, PTM डिवाइस का लाइन अनुशासन कच्चे मोड पर सेट किया जाता है, इसलिए, PTS से PTM डिवाइस में डेटा ट्रांसफर करते समय प्रोसेसिंग नहीं की जाती है। हालाँकि, उपयोगकर्ता स्थान से read() और write() लिए कॉल अभी भी पहली बार दोनों उपकरणों पर लाइन अनुशासन द्वारा परोसा जाता है। यह क्षण और भी बड़ी भूमिका निभाएगा, जैसा कि हम बाद में देखेंगे।

गनोम टर्मिनल सर्वर और टर्मिनल के अंदर चल रहे प्रोग्राम के बीच संचार की प्रक्रिया इस प्रकार है:

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

आभासी उपकरण

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

इन फ़ाइलों को नियमित पाठ फ़ाइलों के रूप में खोलने का प्रयास न करें। हालाँकि, आप इन डिवाइस का उपयोग write() और read() ऑपरेशंस के माध्यम से कर सकते हैं, जिसकी कॉल डिवाइस ड्राइवर द्वारा दी जाएगी। चलो इसे करने की कोशिश करते हैं।

दो टर्मिनल विंडो खोलें और प्रत्येक कमांड में tty दर्ज करें। यह कमांड दिखाएगा कि कौन से TTY डिवाइस वर्तमान में सक्रिय टर्मिनल की सेवा दे रहा है। अब echo "Hello, World!" > /dev/pts/N दर्ज करें echo "Hello, World!" > /dev/pts/N echo "Hello, World!" > /dev/pts/N पहले टर्मिनल विंडो में echo "Hello, World!" > /dev/pts/N पीटीएस echo "Hello, World!" > /dev/pts/N , जहां एन दूसरी विंडो डिवाइस का पीटीएस इंडेक्स है, दूसरी विंडो पर स्विच करें और आप पहली विंडो से अपना इनपुट देखेंगे। अब आपने दूसरी विंडो के पीटीएस डिवाइस को डेटा लिखा है, जैसे कि यह उस टर्मिनल में चल रहे प्रोग्राम द्वारा किया गया हो ।

छद्म टर्मिनल डिवाइस

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

शुरू करने से पहले, हम तथाकथित "घटक टोकरी" का परिचय देते हैं। जैसा कि हम कोर के साथ आगे बढ़ते हैं, हम इसमें अधिक से अधिक घटक जोड़ेंगे और उनके बीच एक संबंध खोजेंगे। मुझे उम्मीद है कि यह आपको छद्म टर्मिनल डिवाइस को बेहतर ढंग से समझने में मदद करेगा। चलिए शुरू करते हैं।

जब लिनक्स शुरू होता है, तो यह आवश्यक डिवाइस ड्राइवरों को लोड करता है। हमारे छद्म टर्मिनल में भी ऐसा ड्राइवर है। इसका पंजीकरण इस फ़ंक्शन के लिए कॉल के साथ शुरू होता है:

 static int __init pty_init(void) { legacy_pty_init(); unix98_pty_init(); // <- ,    return 0; } device_initcall(pty_init); // ,       

सभी आधुनिक प्रणालियों के लिए, unix98_pty_init() फ़ंक्शन को बुलाया जाएगा:

 static void __init unix98_pty_init(void) { ptm_driver = tty_alloc_driver(NR_UNIX98_PTY_MAX, TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV | TTY_DRIVER_DEVPTS_MEM | TTY_DRIVER_DYNAMIC_ALLOC); if (IS_ERR(ptm_driver)) panic("Couldn't allocate Unix98 ptm driver"); pts_driver = tty_alloc_driver(NR_UNIX98_PTY_MAX, TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV | TTY_DRIVER_DEVPTS_MEM | TTY_DRIVER_DYNAMIC_ALLOC); if (IS_ERR(pts_driver)) panic("Couldn't allocate Unix98 pts driver"); ptm_driver->driver_name = "pty_master"; ptm_driver->name = "ptm"; ptm_driver->major = UNIX98_PTY_MASTER_MAJOR; ptm_driver->minor_start = 0; ptm_driver->type = TTY_DRIVER_TYPE_PTY; ptm_driver->subtype = PTY_TYPE_MASTER; ptm_driver->init_termios = tty_std_termios; ptm_driver->init_termios.c_iflag = 0; ptm_driver->init_termios.c_oflag = 0; ptm_driver->init_termios.c_cflag = B38400 | CS8 | CREAD; ptm_driver->init_termios.c_lflag = 0; ptm_driver->init_termios.c_ispeed = 38400; ptm_driver->init_termios.c_ospeed = 38400; ptm_driver->other = pts_driver; tty_set_operations(ptm_driver, &ptm_unix98_ops); pts_driver->driver_name = "pty_slave"; pts_driver->name = "pts"; pts_driver->major = UNIX98_PTY_SLAVE_MAJOR; pts_driver->minor_start = 0; pts_driver->type = TTY_DRIVER_TYPE_PTY; pts_driver->subtype = PTY_TYPE_SLAVE; pts_driver->init_termios = tty_std_termios; pts_driver->init_termios.c_cflag = B38400 | CS8 | CREAD; pts_driver->init_termios.c_ispeed = 38400; pts_driver->init_termios.c_ospeed = 38400; pts_driver->other = ptm_driver; tty_set_operations(pts_driver, &pty_unix98_ops); if (tty_register_driver(ptm_driver)) panic("Couldn't register Unix98 ptm driver"); if (tty_register_driver(pts_driver)) panic("Couldn't register Unix98 pts driver"); /* Now create the /dev/ptmx special device */ tty_default_fops(&ptmx_fops); ptmx_fops.open = ptmx_open; cdev_init(&ptmx_cdev, &ptmx_fops); if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) || register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0) panic("Couldn't register /dev/ptmx driver"); device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx"); 

यहाँ हम 3 चीजों में रुचि रखते हैं:

1. Pty मास्टर ड्राइवर और pty गुलाम उपकरणों के लिए tty_set_operatons को कॉल tty_set_operatons है।
2. ptmx_open फ़ंक्शन, जो विशेष उपकरण / देव / ptmx खोलने पर छद्म टर्मिनल के दोनों हिस्सों को बनाने के लिए जिम्मेदार है। महत्वपूर्ण: / dev / ptmx एक PTM डिवाइस नहीं है, बल्कि एक नया छद्म टर्मिनल बनाने के लिए एक इंटरफ़ेस है।
3. पीटीएम और पीटीएस डिवाइस ड्राइवरों को पंजीकृत करें।

आइए जाने क्रम में:

1. tty_set_operations

Tty_set_operations () फ़ंक्शन वर्तमान ड्राइवर के लिए फ़ंक्शन तालिका सेट करता है:

 void tty_set_operations(struct tty_driver *driver, const struct tty_operations *op) { driver->ops = op; }; 

Tty_operations संरचना एक फ़ंक्शन तालिका है जिसका उपयोग डिवाइस TTY ड्राइवर फ़ंक्शन तक पहुंचने के लिए किया जाता है।

मैं संरचनाओं pty_unix98_ops और ptm_unix98_ops में सबसे महत्वपूर्ण चीज को बाहर निकाल ptm_unix98_ops , जो छद्म टर्मिनल के संबंधित भागों के लिए कार्यों की तालिका हैं:

 static const struct tty_operations ptm_unix98_ops = { .install = pty_unix98_install, .remove = pty_unix98_remove, .open = pty_open, .close = pty_close, .write = pty_write, // ... }; static const struct tty_operations pty_unix98_ops = { .install = pty_unix98_install, .remove = pty_unix98_remove, .open = pty_open, .close = pty_close, .write = pty_write, // ... }; 

यहां आप pty_write फ़ंक्शन का अवलोकन कर सकते हैं, pty_write पहले से ही Sishny printf के लेख से परिचित है - हम इसे थोड़ी देर बाद वापस कर देंगे।

आइए इस संरचना को हमारी घटक टोकरी में जोड़ें:

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

2. ptmx_open

अब ptmx_open () पर चलते हैं:

 static int ptmx_open(struct inode *inode, struct file *filp) { struct tty_struct *tty; //    -   ! fsi = devpts_acquire(filp); //     devpts index = devpts_new_index(fsi); //       /dev/pts // ... tty = tty_init_dev(ptm_driver, index); // ... devpts_pty_new(fsi, index, tty->link); //     /dev/pts retval = ptm_driver->ops->open(tty, filp); //  PTM ,   } 

हम tty_init_dev() फ़ंक्शन में रुचि रखते हैं, जहां पहला तर्क PTM डिवाइस ड्राइवर है, और दूसरा डिवाइस इंडेक्स है। यहां हम पीटीवाई चालक की जिम्मेदारी के क्षेत्र को छोड़ देते हैं और फाइल पर जाते हैं, जो केवल सामान्य टीटीवाई उपकरणों के लिए जिम्मेदार है और हमारे छद्म टर्मिनल के बारे में कुछ भी नहीं जानता है।

 struct tty_struct *tty_init_dev(struct tty_driver *driver, int idx) { struct tty_struct *tty; tty = alloc_tty_struct(driver, idx); retval = tty_driver_install_tty(driver, tty); /* * Structures all installed ... call the ldisc open routines. */ retval = tty_ldisc_setup(tty, tty->link); //  ,       return tty; } 

सबसे पहले, हम alloc_tty_struct() फ़ंक्शन alloc_tty_struct() करेंगे

 struct tty_struct *alloc_tty_struct(struct tty_driver *driver, int idx) { struct tty_struct *tty; tty = kzalloc(sizeof(*tty), GFP_KERNEL); //  tty_struct tty_ldisc_init(tty) //      tty_struct tty->driver = driver; //       tty_struct tty->ops = driver->ops; //        tty_struct.     tty->index = idx; //   tty  return tty; } 

केवल एक चीज जो हमारे यहाँ दिलचस्पी tty_ldisc_init() है वह है tty_ldisc_init() फ़ंक्शन:

 int tty_ldisc_init(struct tty_struct *tty) { struct tty_ldisc *ld = tty_ldisc_get(tty, N_TTY); if (IS_ERR(ld)) return PTR_ERR(ld); tty->ldisc = ld; //        tty_struct return 0; } 

जिसे tty_ldisc_get() :

 static struct tty_ldisc *tty_ldisc_get(struct tty_struct *tty, int disc) { struct tty_ldisc *ld; //    struct tty_ldisc_ops *ldops; //     ldops = get_ldops(disc); //      .   ,       .   - N_TTY ld = kmalloc(sizeof(struct tty_ldisc), GFP_KERNEL | __GFP_NOFAIL); ld->ops = ldops; //       ld->tty = tty; //    tty_struct   .          return ld; } 

इसलिए, हमने कॉल को alloc_tty_struct() फ़ंक्शन के लिए जांच की, जो लाइन अनुशासन के साथ मिलकर tty_struct संरचना बनाता है - tty_ldisc संरचना। दोनों संरचनाओं के एक-दूसरे से संबंध हैं। आइए इन संरचनाओं पर करीब से नज़र डालें।

• tty_struct TTY डिवाइस ड्राइवर और कुछ अन्य क्षेत्रों तक पहुँचने के लिए एक संरचना है। यह इस तरह दिखता है:

 struct tty_struct { struct tty_driver *driver; //  TTY  const struct tty_operations *ops; //  .    ,   driver->ops,       int index; //   struct tty_ldisc *ldisc; //     struct tty_struct *link; //     PTY // ... } 

• tty_ldisc डिवाइस के TTY लाइन के अनुशासन के लिए संरचना है। इसमें केवल दो फ़ील्ड होते हैं और निम्नानुसार दिखाई देते हैं:

 struct tty_ldisc { struct tty_ldisc_ops *ops; //    struct tty_struct *tty; //   tty_struct  .       }; 

यह कुछ भी जटिल नहीं लगता है? आइए इस बिंदु पर विचार की गई सभी संरचनाओं को हमारी टोकरी में जोड़ें और उन्हें उसी तरह से लिंक करें जैसे वे कोड में जुड़े हुए हैं:

लेकिन हमने केवल PTM डिवाइस के लिए tty_struct बनाया। पीटीएस डिवाइस के बारे में क्या? ऐसा करने के लिए, हम tty_init_dev() फ़ंक्शन पर वापस लौटते हैं और याद करते हैं कि हमें तब tty_driver_install_tty() फ़ंक्शन को कॉल करने की उम्मीद है:

 /** * This method is responsible * for ensuring any need additional structures are allocated and configured. */ static int tty_driver_install_tty(struct tty_driver *driver, struct tty_struct *tty) { return driver->ops->install ? driver->ops->install(driver, tty) : tty_standard_install(driver, tty); } 

टिप्पणी हमें बताती है कि यह विधि विभिन्न अतिरिक्त संरचनाओं को बनाने के लिए जिम्मेदार है। पीटीएस डिवाइस और हमारी अतिरिक्त संरचना होगी। मैं मानता हूं, यह मेरे लिए बेहद आश्चर्यजनक था, क्योंकि यह नर्क है, पूरी डिवाइस है, न कि किसी तरह का अतिरिक्त ढांचा! लेकिन हम सभी समझते हैं कि सभी डिवाइस किसी न किसी प्रकार की संरचना हैं, इसलिए आगे बढ़ें। ठीक है, ड्राइवर क्या है-> ops-> यहाँ स्थापित करें ? ऐसा करने के लिए, PTM ड्राइवर के लिए फ़ंक्शन तालिका को फिर से देखें:

 static const struct tty_operations ptm_unix98_ops = { .install = pty_unix98_install, // ... 

और हम समझते हैं कि हम pty_unix98_install() फ़ंक्शन में रुचि रखते हैं:

 static int pty_unix98_install(struct tty_driver *driver, struct tty_struct *tty) { return pty_common_install(driver, tty, false); } 

जो pty_common_install() फ़ंक्शन को कॉल करता है:

 static int pty_common_install(struct tty_driver *driver, struct tty_struct *tty, bool legacy) { struct tty_struct *o_tty; // tty_struct    PTY -    PTS  //    ,       install.   ,   PTM     tty_struct,        if (driver->subtype != PTY_TYPE_MASTER) return -EIO; o_tty = alloc_tty_struct(driver->other, idx); tty->link = o_tty; o_tty->link = tty; } 

, PTS tty_struct , PTS . . tty_struct PTS .

, TTY ( - ?).
— , PTM, PTS :

 static const struct file_operations tty_fops = { .llseek = no_llseek, .read = tty_read, .write = tty_write, .poll = tty_poll, .unlocked_ioctl = tty_ioctl, .compat_ioctl = tty_compat_ioctl, .open = tty_open, .release = tty_release, .fasync = tty_fasync, .show_fdinfo = tty_show_fdinfo, }; 

, TTY .

. , /dev/ptmx . , PTS , , PTM , :

नमस्ते विश्व!

. "Hello, World!", .

 #include <stdio.h> void main() { printf("Hello, World!\n"); } 

, "Hello, World!" . , , , . , . stdout /dev/null — . , Linux.

Unix write() , read() , close() , write() /dev/pts/0 __vfs_write() :

 ssize_t __vfs_write(struct file *file, const char __user *buf, size_t count, loff_t *pos) { ssize_t ret; //... ret = file->f_op->write(file, buf, count, pos); //... return ret; } 

write() . , :

 static const struct file_operations tty_fops = { // ... .write = tty_write, // ... 

tty_write() :

 static ssize_t tty_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos) { struct tty_struct *tty = file_tty(file); struct tty_ldisc *ld; ssize_t ret; ld = tty_ldisc_ref_wait(tty); ret = do_tty_write(ld->ops->write, tty, file, buf, count); tty_ldisc_deref(ld); return ret; } 

tty_struct TTY , write() . :

 static struct tty_ldisc_ops n_tty_ops = { .write = n_tty_write, // ... }; 

n_tty_write() :

 /** * n_tty_write - write function for tty * @tty: tty device * @file: file object * @buf: userspace buffer pointer * @nr: size of I/O */ static ssize_t n_tty_write(struct tty_struct *tty, struct file *file, const unsigned char *buf, size_t nr) { const unsigned char *b = buf; // b - ,       "Hello, World!".          int c; //    //     PTS ,  write()    0,  ,     while (nr > 0) { c = tty->ops->write(tty, b, nr); //  write()       TTY  if (!c) break; b += c; //     nr -= c; //      :  -  -  -  } } 

, "Hello, World!" write() PTS . :

 static const struct tty_operations pty_unix98_ops = { .write = pty_write, // ... } 

pty_write() :

 static int pty_write(struct tty_struct *tty, const unsigned char *buf, int c) { struct tty_struct *to = tty->link; //      PTY.    -  PTM  if (c > 0) { //    PTM  c = tty_insert_flip_string(to->port, buf, c); //     ,       if (c) { tty_flip_buffer_push(to->port); tty_wakeup(tty); } } return c; } 

:

  __vfs_write() -> // 1- :   tty_write() -> do_tty_write() -> n_tty_write() -> // 2- :   pty_write() // 3- :  

. , PTM . , .

, flip buffer . Flip buffer — , . tty driver , . , . , , . , , . - flip buffer — (, - , flip).

, . tty_insert_flip_string() tty_insert_flip_string_fixed_flag() , PTM :

 int tty_insert_flip_string_fixed_flag(struct tty_port *port, const unsigned char *chars, char flag, size_t size) { int copied = 0; do { int goal = min_t(size_t, size - copied, TTY_BUFFER_PAGE); //      int space = __tty_buffer_request_room(port, goal, flags); //     struct tty_buffer *tb = port->buf.tail; //       if (unlikely(space == 0)) break; memcpy(char_buf_ptr(tb, tb->used), chars, space); //      tb->used += space; copied += space; chars += space; /* There is a small chance that we need to split the data over several buffers. If this is the case we must loop */ } while (unlikely(size > copied)); return copied; } 

, flip buffer , , . , — PTM , .

, "Hello, World!" PTM . GNOME Terminal Server poll() ( I/O) master . , ? कोई फर्क नहीं पड़ता कि कैसे। , , — .

tty_flip_buffer_push() ( pty_write):

 /** * tty_flip_buffer_push - terminal * @port: tty port to push * * Queue a push of the terminal flip buffers to the line discipline. * Can be called from IRQ/atomic context. * * In the event of the queue being busy for flipping the work will be * held off and retried later. */ void tty_flip_buffer_push(struct tty_port *port) { tty_schedule_flip(port); } 

tty_schedule_flip() , , :

 /** * tty_schedule_flip - push characters to ldisc * @port: tty port to push from * * Takes any pending buffers and transfers their ownership to the * ldisc side of the queue. It then schedules those characters for * processing by the line discipline. */ void tty_schedule_flip(struct tty_port *port) { struct tty_bufhead *buf = &port->buf; /* paired w/ acquire in flush_to_ldisc(); ensures * flush_to_ldisc() sees buffer data. */ smp_store_release(&buf->tail->commit, buf->tail->used); queue_work(system_unbound_wq, &buf->work); } 

, work (, - ) , — , flush_to_ldisc() :

 static void flush_to_ldisc(struct work_struct *work) { struct tty_port *port = container_of(work, struct tty_port, buf.work); //   tty_port PTM . tty_port -       TTY  struct tty_bufhead *buf = &port->buf; struct tty_buffer *head = buf->head; // ... receive_buf(port, head); // ... } 

receive_buf() __receive_buf() , :

 static void __receive_buf(struct tty_struct *tty, const unsigned char *cp, char *fp, int count) { struct n_tty_data *ldata = tty->disc_data; bool preops = I_ISTRIP(tty) || (I_IUCLC(tty) && L_IEXTEN(tty)); if (ldata->real_raw) n_tty_receive_buf_real_raw(tty, cp, fp, count); else if (ldata->raw || (L_EXTPROC(tty) && !preops)) n_tty_receive_buf_raw(tty, cp, fp, count); else if (tty->closing && !L_EXTPROC(tty)) n_tty_receive_buf_closing(tty, cp, fp, count); else { if (ldata->lnext) { char flag = TTY_NORMAL; if (fp) flag = *fp++; n_tty_receive_char_lnext(tty, *cp++, flag); count--; } if (!preops && !I_PARMRK(tty)) n_tty_receive_buf_fast(tty, cp, fp, count); else n_tty_receive_buf_standard(tty, cp, fp, count); } if (read_cnt(ldata)) { kill_fasync(&tty->fasync, SIGIO, POLL_IN); wake_up_interruptible_poll(&tty->read_wait, EPOLLIN); } } 

, n_tty_receive_buf ( , _raw) read_buf , TTY . PTM raw , read_buf. , PTM PTS , .

, :

  ... pty_write() -> // 3- :  PTS  tty_insert_flip_string + tty_flip_buffer_push() -> tty_schedule_flip() -> --- //    PTM  flush_to_ldisc() -> // 2- :   PTM  receive_buf() -> n_tty_receive_buf -> n_tty_receive_buf_common -> __receive_buf() 

, PTM — PTS .

: PTM . GNOME Terminal Server "Hello, World!", read() PTM . read() write() — n_tty_read() . , , — read_buf — . GNOME Terminal Server X Server, .

, "Hello, World!" :

  -> PTY slave -> PTY master -> GNOME-TERMINAl-SERVER -> X Server -> ->  

निष्कर्ष

. :

3. TTY
5. ,

, ! - — , !

सूत्रों का कहना है

• Linux man pages
• https://unix.stackexchange.com/q/96694/346664
• https://unix.stackexchange.com/q/93531/346664
• https://unix.stackexchange.com/q/117981/346664
• https://askubuntu.com/q/506510
• www.linusakesson.net/programming/tty/
• https://spin0r.wordpress.com/2012/12/28/terminally-confused-part-seven/
• https://habr.com/ru/company/neobit/blog/330764/
• Advanced Programming in the UNIX Environment, 3rd Edition