செஃப் மூல குறியீடு பகுப்பாய்வு: படிக்க மற்றும் எழுதும் செயல்முறை

Ceph Source Code Analysis

1. OSD தொகுதிக்கான அறிமுகம்

1.1 செய்தி இணைத்தல் : OSD பற்றிய தகவல்களை அனுப்பவும் பெறவும்.

cluster_messenger- பிற OSD கள் மற்றும் மானிட்டர்களுடன் தொடர்பு கொள்ளுங்கள்
client_messenger- கிளையனுடன் தொடர்பு கொள்ளுங்கள்

1.2 செய்தி திட்டமிடல் :

செய்தி வகைப்படுத்தலுக்கு முக்கியமாக பொறுப்பான டிஸ்பாட்சர் வகுப்பு

1.3 பணி வரிசை:

1.3.1 OpWQ: ஆப்கள் (கிளையண்டிலிருந்து) மற்றும் துணை ஆப்கள் (பிற OSD களில் இருந்து) கையாளவும். Op_tp நூல் குளத்தில் இயக்கவும்.

1.3.2 PeeringWQ: பியரிங் பணிகளைச் செயலாக்குதல், op_tp நூல் குளத்தில் இயங்குகிறது.

1.3.3 CommandWQ: செயல்முறை cmd கட்டளை, command_tp இல் இயக்கவும்.

1.3.4 மீட்பு WQ: தரவு மீட்பு, மீட்டெடுப்பு_டிபியில் இயக்கவும்.

1.3.5 SnapTrimWQ: ஸ்னாப்ஷாட் தொடர்பானது, வட்டு_டிபியில் இயக்கவும்.

1.3.6 ஸ்க்ரப் டபிள்யூ க்யூ: ஸ்க்ரப், டிஸ்க்_டிபியில் இயங்குகிறது.

1.3.7 ScrubFinalizeWQ: ஸ்க்ரப், வட்டு_டிபியில் இயங்குகிறது.

1.3.8 RepScrubWQ: ஸ்க்ரப், வட்டு_டிபியில் இயங்குகிறது.

1.3.9 RemoveWQ: பழைய pg கோப்பகத்தை நீக்கு. Disk_tp இல் இயக்கவும்.

1.4 நூல் குளம்:

OSD நூல் குளங்களில் 4 வகைகள் உள்ளன:

1.4.1 op_tp: ஒப்ஸ் மற்றும் சப் ஆப்களைக் கையாளவும்

1.4.2 recovery_tp: பழுதுபார்க்கும் பணிகளைக் கையாளுங்கள்

1.4.3 வட்டு_டிபி: வட்டு-தீவிர பணிகளைக் கையாளவும்

1.4.4 command_tp: செயல்முறை கட்டளைகள்

1.5 முக்கிய பொருள்கள்:

ஆப்ஜெக்ட்ஸ்டோர் * ஸ்டோர்

OSDSuperblock சூப்பர் பிளாக் முக்கியமாக பதிப்பு எண் போன்ற தகவல்கள்

OSDMapRef osdmap

1.6 முக்கிய செயல்பாட்டு செயல்முறை: குறிப்பு கட்டுரை

1.6.1 வாடிக்கையாளர் கோரிக்கை செயல்முறையைத் தொடங்குகிறார்

1.6.2 op_tp நூல் தரவு வாசிப்பைக் கையாளுகிறது

1.6.3 பொருள் செயல்பாட்டின் செயல்முறை

1.6.4 மாற்றியமைக்கும் நடவடிக்கைகளின் செயலாக்கம்

1.6.5 பதிவு எழுதுதல்

1.6.6 செயல்பாட்டு செயலாக்கத்தை எழுதுங்கள்

1.6.7 ஒரு பரிவர்த்தனையின் ஒத்திசைவு செயல்முறை

1.6.8 பதிவு மீட்பு

1.7 ஒட்டுமொத்த செயல்முறை வரைபடம்

இரண்டாவதாக, கிளையன்ட் மற்றும் சேமிப்பக படிவத்தில் தரவை எழுதும் பொதுவான செயல்முறை

2.1 படித்தல் மற்றும் எழுதுதல் கட்டமைப்பு

2.2 கிளையண்ட் எழுதும் செயல்முறை

கிளையண்டில் rbd ஐப் பயன்படுத்த பொதுவாக இரண்டு வழிகள் உள்ளன:

• முதலாவது கர்னல் ஆர்.பி.டி. Rbd சாதனத்தை உருவாக்கிய பிறகு, மெய்நிகர் தொகுதி சாதனத்தை உருவாக்க rbd சாதனத்தை கர்னலில் வரைபடமாக்கவும். இந்த நேரத்தில், இந்த தொகுதி சாதனம் மற்ற பொது தொகுதி சாதனங்களைப் போன்றது. பொதுவான சாதன கோப்பு / dev / rbd0, மற்றும் தொகுதி சாதனம் எதிர்காலத்தில் நேரடியாக பயன்படுத்தப்படுகிறது. ஒரு கோப்பு போதுமானது. ஒரு கோப்பகத்தை வடிவமைத்த பின் நீங்கள் / dev / rbd0 ஐ ஏற்றலாம் அல்லது நேரடியாக மூல சாதனமாகப் பயன்படுத்தலாம். இந்த நேரத்தில், rbd சாதனத்தின் செயல்பாடு கர்னல் rbd செயல்பாட்டு முறை மூலம் செய்யப்படுகிறது. அ
• இரண்டாவது முறை librbd. Rbd சாதனத்தை உருவாக்கிய பிறகு, மேலாண்மை தொகுதி சாதனத்தை அணுக நீங்கள் librbd மற்றும் librados நூலகங்களைப் பயன்படுத்தலாம். இந்த முறை கர்னலுடன் வரைபடமாக இருக்காது, மேலும் librbd வழங்கிய இடைமுகத்தை நேரடியாக அழைக்கவும், இது rbd சாதனங்களின் அணுகல் மற்றும் நிர்வாகத்தை அடைய முடியும், ஆனால் கிளையண்டில் தடுப்பு சாதன கோப்புகளை உருவாக்காது.

RBD தொகுதி சாதனத்திற்கு எழுதும் செயல்முறை:

1. பயன்பாடு librbd இடைமுகத்தை அழைக்கிறது அல்லது லினக்ஸ் கர்னல் மெய்நிகர் தொகுதி சாதனத்திற்கு பைனரி தொகுதியை எழுதுகிறது. Librbd ஐ உதாரணமாக எடுத்துக் கொள்வோம்.
2. librbd பைனரி தொகுதியை தொகுதிகளாக பிரிக்கிறது, இயல்புநிலை தொகுதி அளவு 4M, ஒவ்வொரு தொகுதிக்கும் ஒரு பெயர் உள்ளது மற்றும் ஒரு பொருளாகிறது
3. செஃப் கிளஸ்டருக்கு பொருட்களை எழுத லிபிராடோஸை லிப்ராப்ட் அழைக்கிறது
4. லிப்ராடோஸ் பிரிக்கப்பட்ட பைனரி தரவுத் தொகுதிகளை பிரதான OSD க்கு எழுதுகிறார் (முதலில் ஒரு TCP / IP இணைப்பை நிறுவுகிறது, பின்னர் OSD க்கு ஒரு செய்தியை அனுப்புகிறது, மேலும் OSD அதைப் பெற்று அதை வட்டில் எழுதுகிறது)
5. ஒரே நேரத்தில் ஒன்று அல்லது அதற்கு மேற்பட்ட இரண்டாம் நிலை OSD களுக்கு நகல்களை எழுதுவதற்கு முதன்மை OSD பொறுப்பாகும். திரும்புவதற்கு இங்கே ஜர்னலுக்கு (ஜர்னல்) எழுதப்பட்டுள்ளது என்பதை நினைவில் கொள்க, எனவே எஸ்.எஸ்.டி.யை ஜர்னலாகப் பயன்படுத்துவதன் மூலம், நீங்கள் மறுமொழி வேகத்தை மேம்படுத்தலாம், இதன்மூலம் சேவையகம் விரைவாக கிளையண்டை ஒத்திசைத்து எழுதும் முடிவை (அக்) தருகிறது.
6. முதன்மை மற்றும் இரண்டாம் நிலை OSD களின் எழுத்து முடிந்ததும், முதன்மை OSD எழுத்து வெற்றிகரமாக இருந்தது என்று வாடிக்கையாளருக்குத் திரும்புகிறது.
7. ஒரு குறிப்பிட்ட காலத்திற்குப் பிறகு (சில வினாடிகள்), ஜர்னலில் உள்ள தரவு வெற்றிகரமாக வட்டில் எழுதப்பட்ட பிறகு, ஒரு நிகழ்வின் மூலம் தரவு வெற்றிகரமாக வட்டுக்கு (உறுதி) எழுதப்பட்டிருப்பதை வாடிக்கையாளருக்கு அறிவிக்கிறது. இந்த நேரத்தில், கிளையன்ட் எழுதப்பட்ட தற்காலிக சேமிப்பில் தரவை முழுமையாக எழுத முடியும்.
8. முன்னிருப்பாக, செஃப் கிளையன்ட் எழுதப்பட்ட தரவை கிளஸ்டரின் உறுதி அறிவிப்பைப் பெறும் வரை கேச் செய்யும். இந்த கட்டத்தில் OSD தோல்வியுற்றால் (உறுதி அறிவிப்பின் ரசீதுக்குத் திரும்பும் எழுத்து முறைக்கு இடையில்) மற்றும் கோப்பு முறைமைக்கு தரவு எழுதுவது தோல்வியுற்றால், Ceph கிளையன்ட் அனுமதிக்கப்படாத செயல்பாட்டை (மறுதொடக்கம்) மீண்டும் செய்ய அனுமதிக்கும். ஆகையால், பி.ஜி.க்கு ரீப்ளே என்று ஒரு நிலை உள்ளது: 'ஓ.எஸ்.டி செயலிழந்த பின்னர் வாடிக்கையாளர்களுக்கு செயல்பாடுகளை மீண்டும் இயக்க இடமளிக்கும் குழு காத்திருக்கிறது.'

அதாவது, கோப்பு செயலாக்கத்திற்கு கோப்பு முறைமை பொறுப்பு, தொகுதி செயலாக்கத்திற்கு librbd பொறுப்பு, பொருள் செயலாக்கத்திற்கு librados பொறுப்பு, மற்றும் ஜர்னல் மற்றும் வட்டில் தரவை எழுதுவதற்கு OSD பொறுப்பு.

2.3 RBD சேமிப்பு வடிவம்

கீழேயுள்ள படத்தில் காட்டப்பட்டுள்ளபடி, செஃப் அமைப்பில் வெவ்வேறு நிலை கூறுகள் / பயனர்கள் காணும் தரவின் வடிவம் வேறுபட்டது:

• செஃப் கிளையன்ட் பார்ப்பது ஒரு முழுமையான தொடர்ச்சியான பைனரி தரவுத் தொகுதி ஆகும், இதன் அளவு உருவாக்கப்பட்ட RBD படத்தின் தொகுப்பு அளவு அல்லது மறுஅளவாக்குதல் ஆகும், மேலும் கிளையண்ட் பைனரி தரவை ஆரம்பத்தில் இருந்தோ அல்லது ஒரு குறிப்பிட்ட இடத்திலிருந்தோ எழுத முடியும்.
• ரேடோஸில் பொருட்களை உருவாக்குவதற்கு லிபிரடோஸ் பொறுப்பு, அதன் அளவு குளத்தின் வரிசையால் தீர்மானிக்கப்படுகிறது. இயல்பாக, ஆர்டர் = 22 மற்றும் பொருளின் அளவு 4MB மற்றும் கிளையன்ட் அனுப்பிய பைனரி தொகுதிகளை பல கீற்றுகளாக அகற்றுவதற்கு பொறுப்பாகும். (கோடு).
• எந்த ஓ.எஸ்.டி (பட்டை --- இது எழுதப்பட்டுள்ளது ----> பொருள் ---- இது ----> ஓ.எஸ்.டி)
• கோப்பு முறைமையில் கோப்புகளை உருவாக்குவதற்கும், லிப்ராடோஸ் அனுப்பிய தரவை தரவுக்கு எழுதுவதற்கும் OSD பொறுப்பாகும்.

செஃப் கிளையன்ட் பைனரி தரவை ஒரு RBD படத்திற்கு எழுதுகிறார் (பூல் பிரதிகளின் எண்ணிக்கை 3 என்று கருதி):

(1) ஒரு RBD படத்தை உருவாக்க செஃப் கிளையன்ட் லிப்ராடோஸை அழைக்கிறார். இந்த நேரத்தில், சேமிப்பக இடம் ஒதுக்கப்படவில்லை, ஆனால் மெட்டாடேட்டா தகவல்களைச் சேமிக்க பல மெட்டாடேட்டா பொருள்கள் உருவாக்கப்படுகின்றன.

(2) தரவு எழுதத் தொடங்க செஃப் கிளையண்ட் லிப்ராடோஸை அழைக்கிறார். லிப்ராடோஸ் கோடுகள், பொருள்கள் போன்றவற்றைக் கணக்கிடுகிறது, பின்னர் ஒரு குறிப்பிட்ட இலக்கு பொருளுக்கு முதல் பட்டை எழுதத் தொடங்குகிறது.

(3) CRUSH வழிமுறையின்படி, லிப்ராடோஸ் பொருளுடன் தொடர்புடைய முக்கிய OSD ஐடியைக் கணக்கிட்டு அதற்கு பைனரி தரவை அனுப்புகிறது.

(4) வட்டில் உள்ள ஒரு கோப்பிற்கு பைனரி தரவை எழுத கோப்பு முறைமை இடைமுகத்தை அழைப்பதற்கு முக்கிய OSD பொறுப்பாகும் (ஒவ்வொரு பொருளும் ஒரு கோப்பிற்கு ஒத்திருக்கிறது, மேலும் கோப்பின் உள்ளடக்கம் ஒன்று அல்லது அதற்கு மேற்பட்ட கோடுகள்).

(5) முக்கிய ODS தரவை எழுதுவதை முடித்த பிறகு, இது இரண்டாவது OSD (இரண்டாம் நிலை OSD) மற்றும் மூன்றாவது OSD (மூன்றாம் நிலை OSD) ஆகியவற்றின் நிலையை கணக்கிட CRUSH ஐப் பயன்படுத்துகிறது, பின்னர் இந்த இரண்டு OSD களுக்கும் பொருட்களை நகலெடுக்கிறது. அனைத்தும் முடிந்ததும், பொருள் சேமிக்கப்பட்டதாக அது செஃப் கிளையண்டிற்குத் தெரிவிக்கிறது.

(6) பின்னர் அனைத்து எழுத்துக்களும் முடியும் வரை இரண்டாவது பட்டை எழுதுங்கள். அனைத்தும் முடிந்ததும், புதிய அளவை எழுதுவது போன்ற மெட்டாடேட்டாவையும் லிப்ராடோஸ் புதுப்பிக்க வேண்டும்.

முழுமையான செயல்முறை ( மூல ):

இந்த செயல்முறை வலுவான நிலைத்தன்மையின் பண்புகளைக் கொண்டுள்ளது:

• செஃப் முதன்மை-பிரதி மாதிரியை படிக்க மற்றும் எழுத செயல்பாடுகளுக்கு பயன்படுத்துகிறது. கிளையண்ட் பொருளுடன் தொடர்புடைய OSD தொகுப்பின் முதன்மைக்கு படிக்க மற்றும் எழுத கோரிக்கைகளை மட்டுமே தொடங்குகிறார், இது வலுவான தரவு நிலைத்தன்மையை உறுதி செய்கிறது.
• ஒவ்வொரு பொருளுக்கும் ஒரே ஒரு முதன்மை OSD மட்டுமே இருப்பதால், பொருளின் புதுப்பிப்புகள் தொடர்ச்சியானது, மேலும் ஒத்திசைவு சிக்கல் இல்லை.
• முதன்மை பொருள் எழுதும் கோரிக்கையைப் பெறும்போது, ​​தரவை பிற பிரதிகளுக்கு அனுப்புவது பொறுப்பு. அனைத்து OSD களில் தரவு சேமிக்கப்படும் வரை, முதன்மை பொருள் எழுதும் கோரிக்கைக்கு பதிலளிக்கும், இது நகலின் நிலைத்தன்மையை உறுதி செய்கிறது. இது சில பக்க விளைவுகளையும் தருகிறது. ஸ்விஃப்ட் போன்ற இறுதி நிலைத்தன்மையை மட்டுமே அடையக்கூடிய அந்த சேமிப்பக அமைப்புகளுடன் ஒப்பிடும்போது, ​​மூன்று பிரதிகள் எழுதப்பட்ட பின்னரே செஃப் எழுதுகிறார், இது ஒரு எழுத்து நிறைவு என்று கருதப்படுகிறது, இது வட்டு ஊழல் நிகழும்போது எழுதும் தாமதத்தை அதிகரிக்கும்.
• OSD இல், தரவு சேமிப்பக வழிமுறைகளைப் பெற்ற பிறகு, இது 2 ~ 3 வட்டு தேடும் செயல்பாடுகளை உருவாக்கும்:

• • OSD இன் ஜர்னல் கோப்பில் எழுதும் செயல்பாட்டை எழுதுங்கள் (எழுதுதல் செயல்பாட்டின் அணுத்தன்மையை உறுதி செய்வதே ஜர்னல்).
  • எழுதும் செயல்பாட்டை பொருளுடன் தொடர்புடைய கோப்பில் புதுப்பிக்கவும்.
  • எழுதும் செயல்பாட்டை பிஜி பதிவு கோப்பில் எழுதவும்.

மூன்றாவதாக, கிளையன்ட் கோரிக்கை செயல்முறை (பரிமாற்றம் ஒரு சிறிய நதி வலைப்பதிவு இடுகை, நன்கு எழுதப்பட்டுள்ளது)

ரேடோஸ் பொருள் ஓட்டத்தைப் படித்தார்

ரேடோஸ் பொருள் செயல்பாட்டு ஓட்டத்தை எழுதுங்கள்

உதாரணமாக:

#! / usr / bin / env python
இறக்குமதி sys, rados, rbd
def connectceph ():
க்ளஸ்டர் = ரேடோஸ்.ராடோஸ் (conffile = '/root/xuyanjiangtest/ceph-0.94.3/src/ceph.conf')
cluster.connect ()
ioctx = cluster.open_ioctx ('mypool')
rbd_inst = rbd.RBD ()
அளவு = 4 * 1024 ** 3 # 4 ஜிபி
rbd_inst.create (ioctx, 'myimage', அளவு)
image = rbd.Image (ioctx, 'myimage')
தரவு = 'foo' * 200
image.write (தரவு, 0)
image.close ()
ioctx.close ()
cluster.shutdown ()

__name__ == '__main__' என்றால்:
connectceph ()

1. முதலில், க்ளஸ்டர் = ரேடோஸ்.ராடோஸ் (conffile = 'ceph.conf'), ஒரு ரேடோக்களை உருவாக்க தற்போதைய செஃப் உள்ளமைவு கோப்பைப் பயன்படுத்தவும், இங்கே முக்கியமாக ceph.conf இல் கிளஸ்டர் உள்ளமைவு அளவுருக்களை அலச வேண்டும். இந்த அளவுருக்களின் மதிப்புகளை ரேடோக்களில் சேமிக்கவும்.

2. க்ளஸ்டர்.கனெக்ட் (), ஒரு ரேடோஸ் கிளையண்ட் கட்டமைப்பு இங்கே உருவாக்கப்படும், மேலும் இந்த கட்டமைப்பில் முக்கியமாக பல செயல்பாட்டு தொகுதிகள் இருக்கும்: செய்தி மேலாண்மை தொகுதி செய்தி, தரவு செயலாக்க தொகுதி ஆப்ஜெக்டர், ஃபினிஷர் நூல் தொகுதி.

3. ioctx = cluster.open_ioctx ('mypool'), மைபூல் என்ற சேமிப்பக குளத்திற்கு ஒரு ioctx ஐ உருவாக்கவும். அயோக்டெக்ஸ் ரேடோஸ்கிளைண்ட் மற்றும் ஆப்ஜெக்டர் தொகுதிக்கூறுகளைக் குறிக்கும், மேலும் பூலின் அளவுருக்கள் உட்பட மைபூலின் தகவல்களையும் பதிவு செய்யும்.

4. rbd_inst.create (ioctx, 'myimage', size), myimage என்ற பெயரில் ஒரு rbd சாதனத்தை உருவாக்கி, பின்னர் இந்த சாதனத்திற்கு தரவை எழுதவும்.

5. image = rbd.Image (ioctx, 'myimage'), ஒரு படக் கட்டமைப்பை உருவாக்கவும், இந்த அமைப்பு myimage மற்றும் ioctx ஐ இணைக்கிறது, மேலும் iocx ஐ பின்னர் பட அமைப்பு மூலம் நேரடியாகக் காணலாம். இங்கே iocx இரண்டாக நகலெடுக்கப்படும், அவை data_ioctx மற்றும் md_ctx என பிரிக்கப்படுகின்றன. அறிதல் மற்றும் அறிவைப் பாருங்கள், ஒன்று rbd இன் சேமிப்பக தரவை செயலாக்கப் பயன்படுகிறது, மற்றொன்று rbd இன் மேலாண்மை தரவை செயலாக்குவது.

ஓட்ட விளக்கப்படம்:

1. image.write (தரவு, 0), எழுதும் கோரிக்கையின் வாழ்க்கையின் ஆரம்பம் படம் மூலம் தொடங்கப்படுகிறது. கோரிக்கையின் இரண்டு அடிப்படை கூறுகள் இங்கே குறிப்பிடப்பட்டுள்ளன இடையக = தரவு மற்றும் ஆஃப்செட் = 0. இங்கிருந்து செஃப் உலகிலும், சி ++ உலகிலும் நுழையத் தொடங்கியது.

Image.write (data, 0) இலிருந்து Image :: write () librbd.cc கோப்பில் செயல்படுவதற்கு, இந்த செயல்பாட்டின் முக்கிய செயல்பாட்டைப் பார்ப்போம்

ssize_t Image::write(uint64_t ofs, size_t len, bufferlist& bl) { ImageCtx *ictx = (ImageCtx *)ctx int r = librbd::write(ictx, ofs, len, bl.c_str(), 0) return r }

2. இந்த செயல்பாடு நேரடியாக librbd :: wrte செயல்பாட்டிற்கு விநியோகிக்கப்படுகிறது. Librbd :: எழுத்தில் செயல்படுத்துவதைப் பார்ப்போம். இந்த செயல்பாட்டின் குறிப்பிட்ட செயல்படுத்தல் internal.cc கோப்பில் உள்ளது.

ssize_t write(ImageCtx *ictx, uint64_t off, size_t len, const char *buf, int op_flags) { Context *ctx = new C_SafeCond(&mylock, &cond, &done, &ret) //---a AioCompletion *c = aio_create_completion_internal(ctx, rbd_ctx_cb)//---b r = aio_write(ictx, off, mylen, buf, c, op_flags) //---c while (!done) cond.Wait(mylock) // ---d }

--- அ. இந்தச் செயல்பாட்டிற்கான அழைப்பு நடவடிக்கைக்கு இந்த வாக்கியம் விண்ணப்பிக்க வேண்டும். கால்பேக் என்று அழைக்கப்படுவது சில முடிக்கும் வேலை, சமிக்ஞை எழுப்புதல் செயலாக்கம்.

--- ஆ. இந்த வாக்கியம் io முடிந்ததும் செய்யப்பட வேண்டிய அறுவை சிகிச்சைக்கு விண்ணப்பிக்க வேண்டும். Io முடிந்ததும், rbd_ctx_cb செயல்பாடு அழைக்கப்படும், மேலும் செயல்பாடு தொடர்ந்து ctx-> complete () என அழைக்கப்படும்.

--- சி. Aio_write செயல்பாடு இந்த கோரிக்கையை தொடர்ந்து செயல்படுத்தும்.

--- டி. சி வாக்கியம் இந்த io ஐ osd க்கு அனுப்பும்போது, ​​மற்றும் osd இன்னும் கோரிக்கை செயலாக்கத்தை முடிக்கவில்லை என்றால், கீழ் அடுக்கு கோரிக்கையைச் செயலாக்குவது முடியும் வரை காத்திருக்கும், b ஆல் பயன்படுத்தப்படும் AioCompletion ஐ திரும்பப்பெறுங்கள், மேலும் ctx- ஐ ஒரு> முழுமையான (), இங்கே காத்திருப்பு சமிக்ஞையை எழுப்புங்கள், பின்னர் நிரல் கீழ்நோக்கி இயங்குகிறது.

3. கோரப்பட்ட ஆஃப்செட் மற்றும் இடையகத்தைப் பெறும்போது aio_write என்ன செய்யும் என்பதைப் பார்ப்போம்.

int aio_write(ImageCtx *ictx, uint64_t off, size_t len, const char *buf, AioCompletion *c, int op_flags) {// The request will be split according to the object vector extents if (len> 0) If (len> 0) Striper::file_to_extents(ictx->cct, ictx->format_string, ​​​​extents) //---a} //Process the request data on each object for (vector::iterator p = extents.begin() p != extents.end() ++p) {_AioWrite *req_comp = new C_AioWrite(cct, c) //----b AioWrite *req = new AioWrite(ictx, p->oid.name, p->objectno, p->offset,bl,... , req_comp) //---c c r = req->send() //---d} }

கோரிக்கையின் அளவைப் பொறுத்தவரை, இந்த கோரிக்கையை பொருளின் படி பிரிக்க வேண்டும், இது file_to_extents செயல்பாட்டால் செயலாக்கப்படுகிறது. செயலாக்கம் முடிந்தபின், அது பொருளின் படி நீட்டிப்புகளில் சேமிக்கப்படுகிறது. File_to_extents () இல் ஒரே பெயரில் பல செயல்பாடுகள் உள்ளன. இந்த செயல்பாடுகளின் முக்கிய உள்ளடக்கம் ஒரு காரியத்தைச் செய்கிறது, அதாவது அசல் கோரிக்கையின் பிளவு.

ஒரு ஆர்.பி.டி சாதனம் பல பொருள்களால் ஆனது, அதாவது, ஆர்.பி.டி சாதனம் தொகுதிகளாக வெட்டப்படுகிறது, ஒவ்வொரு தொகுதியும் ஒரு பொருள் என்று அழைக்கப்படுகிறது, மேலும் ஒவ்வொரு பொருளின் அளவும் முன்னிருப்பாக 4 எம் ஆகும், அல்லது அதை நீங்களே குறிப்பிடலாம். File_to_extents செயல்பாடு இந்த பெரிய கோரிக்கையை பொருளுக்கு வரைபடமாக்குகிறது, மேலும் கீழே காட்டப்பட்டுள்ளபடி பல சிறிய கோரிக்கைகளாக அதைப் பிரிக்கிறது. இறுதி மேப்பிங்கின் முடிவு ObjectExtent இல் சேமிக்கப்படுகிறது.

அசல் ஆஃப்செட் rbd க்குள் உள்ள ஆஃப்செட்டைக் குறிக்கிறது (rbd எழுதப்பட்ட இடம்). File_to_extents க்குப் பிறகு, இது ஒன்று அல்லது அதற்கு மேற்பட்ட பொருட்களின் உள் ஆஃப்செட் ஆஃப்செட் 0 ஆக மாற்றப்படுகிறது. இந்த மாற்றத்திற்குப் பிறகு, இந்த பொருளில் ஒரு தொகுதி கோரிக்கைகள் செயலாக்கப்படும்.

4. aio_write செயல்பாட்டிற்குத் திரும்புகையில், பிளவுக்குப் பிறகு ஒவ்வொரு பொருள் கோரிக்கையும் செயல்படுத்தப்பட வேண்டும்.

--- ஆ. எழுதும் கோரிக்கைகளுக்கு கால்பேக் ஹேண்ட்லரைப் பயன்படுத்துங்கள்.

--- சி. பொருளின் உள் கோரிக்கையின் அடிப்படையில் AioWrite எனப்படும் கட்டமைப்பை உருவாக்கவும்.

--- டி. அனுப்ப () அனுப்ப இந்த AioWrite req ஐ அனுப்பவும்.

5. இங்கே AioWrite ஆனது சுருக்கம் எழுத்தில் இருந்து பெறுகிறது, சுருக்கம் எழுதுதல் AioRequest வகுப்பிலிருந்து பெறுகிறது, சுருக்கம் எழுதும் வகுப்பில் அனுப்பும் முறையை வரையறுக்கிறது, அனுப்பும் குறிப்பிட்ட உள்ளடக்கத்தைக் காண்க.

int AbstractWrite::send() { if (send_pre()) //---a } #Enter the send_pre() function bool AbstractWrite::send_pre() { m_state = LIBRBD_AIO_WRITE_PRE // ----a FunctionContext *ctx = //----b new FunctionContext( boost::bind(&AioRequest::complete, this, _1)) m_ictx->object_map.aio_update（ctx） //-----c }

--- அ. M_state நிலையை LIBRBD_AIO_WRITE_PRE ஆக மாற்றவும்.

--- ஆ. திரும்ப அழைக்கும் செயல்பாட்டிற்கு விண்ணப்பிக்கவும், உண்மையில் AioRequest :: ஐ அழைக்கவும்

--- சி. Object_map.aio_update கோரிக்கையை வழங்கத் தொடங்குங்கள். இது ஒரு நிலை புதுப்பிப்பு செயல்பாடு, மிக முக்கியமான இணைப்பு அல்ல. புதுப்பிப்பு கோரிக்கை முடிந்ததும், அது தானாகவே b ஆல் பயன்படுத்தப்படும் கால்பேக் செயல்பாட்டிற்கு திரும்ப அழைக்கும்.

6. AioRequest :: முழுமையான () செயல்பாட்டை உள்ளிடவும்.

void AioRequest::complete(int r) { if (should_complete(r)) //---a }

--- a.should_complete செயல்பாடு என்பது ஒரு தூய்மையான மெய்நிகர் செயல்பாடாகும், இது பரம்பரை வர்க்கமான சுருக்கம் எழுத்தில் செயல்படுத்தப்பட வேண்டும், வாருங்கள் 7. சுருக்கம் எழுதுதலைப் பாருங்கள் :: should_complete ()

bool AbstractWrite::should_complete(int r) { switch (m_state) { case LIBRBD_AIO_WRITE_PRE: //----a { send_write() //----b

---- அ. Send_pre இல் m_state இன் நிலை LIBRBD_AIO_WRITE_PRE என அமைக்கப்பட்டுள்ளது, எனவே இந்த கிளை எடுக்கப்படும்.

---- ஆ. Send_write () செயல்பாட்டில், செயலாக்கம் தொடரும்,

7.1. இந்த send_write செயல்பாட்டைப் பார்ப்போம்

void AbstractWrite::send_write() { m_state = LIBRBD_AIO_WRITE_FLAT //----a add_write_ops(&m_write) // ----b int r = m_ictx->data_ctx.aio_operate(m_oid, rados_completion, &m_write) }

--- அ. M_state நிலையை LIBRBD_AIO_WRITE_FLAT க்கு மீட்டமைக்கவும்.

--- ஆ. M_write ஐ நிரப்பி, கோரிக்கையை m_write ஆக மாற்றவும்.

--- சி. M_write ஐ அனுப்பவும் மற்றும் செயலாக்க data_ctx.aio_operat செயல்பாட்டைப் பயன்படுத்தவும். Io_ctx_impl-> aio_operat () செயல்பாட்டை தொடர்ந்து அழைக்கவும், ஆப்ஜெக்டர்-> பிறழ்வு () ஐ அழைக்கவும்.

8.object-> விகாரி ()

ceph_tid_t mutate(……..) { Op *o = prepare_mutate_op(oid, oloc, op, snapc, mtime, flags, onack, oncommit, objver) //----d return op_submit(o) }

--- டி. கோரிக்கையை ஒப் கோரிக்கையாக மாற்றவும், கோரிக்கையை வழங்க op_submit ஐப் பயன்படுத்தவும். கோரிக்கையைச் செயல்படுத்த op_submit இல் _op_submit_with_budget ஐ அழைப்பதைத் தொடரவும். _Op_submit செயலாக்கத்தை தொடர்ந்து அழைக்கவும்.

8.1 _op_submit இன் செயலாக்கம். இங்கே ஒரு நெருக்கமான பார்வை மதிப்பு

ceph_tid_t Objecter::_op_submit(Op *op, RWLock::Context& lc) { check_for_latest_map = _calc_target(&op->target, &op->last_force_resend)； //---a int r = _get_session(op->target.osd, &s, lc) //---b _session_op_assign(s, op) //----c _send_op(op, m) //----d

}

---- அ. _calc_target, தற்போதைய பொருளின் சேமிக்கப்பட்ட osd ஐக் கணக்கிடுவதன் மூலம், பின்னர் இலக்கில் முக்கிய osd ஐச் சேமிப்பதன் மூலம், rbd எழுதும் தரவு முதலில் பிரதான osd க்கு அனுப்பப்படும், பிரதான osd பின்னர் தரவை மற்ற நகல் osd க்கு அனுப்புகிறது. Osd தொகுப்புக்கும் பிரதான osd க்கும் இடையிலான உறவை எவ்வாறு தேர்வு செய்வது என்பது பற்றி மேலும் பேச முடியாது. இந்த செயல்முறையின் கொள்கை 'தரவு சேமிப்பிற்கான செஃப் சாலையில் (3)' விவரிக்கப்பட்டுள்ளது, மேலும் குறியீடு பகுதியை புரிந்து கொள்வது கடினம் அல்ல.

---- ஆ. _get_session, இந்த செயல்பாடு முக்கிய osd உடன் தகவல்தொடர்பு நிறுவ பயன்படுகிறது. தகவல்தொடர்பு நிறுவப்பட்ட பிறகு, இந்த சேனலின் மூலம் அதை பிரதான OSD க்கு அனுப்பலாம். இந்த செயல்பாடு எவ்வாறு கையாளப்படுகிறது என்பதைப் பார்ப்போம்

9. _ஜெட்_செஷன்

int Objecter::_get_session(int osd, OSDSession **session, RWLock::Context& lc) { map::iterator p = osd_sessions.find(osd) //----a OSDSession *s = new OSDSession(cct, osd) //----b osd_sessions[osd] = s//--c s->con = messenger->get_connection(osdmap->get_inst(osd))//-d

}

---- அ. Osd_session இல் ஏற்கனவே நேரடியாகப் பயன்படுத்தக்கூடிய இணைப்பு இருக்கிறதா என்பதை முதலில் கண்டுபிடிக்கவும், முதல் தொடர்பு இல்லை.

---- ஆ. OSDSession க்கு மீண்டும் விண்ணப்பிக்கவும், துவக்க osd மற்றும் பிற தகவல்களைப் பயன்படுத்தவும்.

--- சி. Osd_session இல் புதிதாகப் பயன்படுத்தப்படும் OSDSession ஐச் சேர்த்து எதிர்கால பயன்பாட்டிற்காக சேமிக்கவும்.

---- டி. செய்தியின் get_connection முறையை அழைக்கவும். இந்த முறையில், இலக்கு osd உடன் இணைப்பை நிறுவ ஒரு வழியைத் தொடர்ந்து கண்டறியவும்.

10. மெசேஜர் சிம்பிள் மெசேஜர் துணைப்பிரிவால் செயல்படுத்தப்படுகிறது. சிம்பிள் மெசேஜரில் get_connection ஐ செயல்படுத்துவதைப் பார்ப்போம்

ConnectionRef SimpleMessenger::get_connection(const entity_inst_t& dest) { Pipe *pipe = _lookup_pipe(dest.addr) //-----a if (pipe) { } else { pipe = connect_rank(dest.addr, dest.name.type(), NULL, NULL) //----b }

}

---- அ. முதலில், இந்த குழாயை நாம் கண்டுபிடிக்க வேண்டும். முதல் தொடர்பு, இயற்கையாகவே இந்த குழாய் இல்லை.

---- ஆ. இந்த இலக்கு osd இன் addr இன் படி connect_rank உருவாக்கப்படும். Connect_rank என்ன செய்தது என்று பாருங்கள்.

11. சிம்பிள்மெசெஞ்சர் :: connect_rank

Pipe *SimpleMessenger::connect_rank(const entity_addr_t& addr, int type, PipeConnection *con, Message *first) { Pipe *pipe = new Pipe(this, Pipe::STATE_CONNECTING, static_cast(con)) //----a pipe->set_peer_type(type) //----b pipe->set_peer_addr(addr) //----c pipe->policy = get_policy(type) //----d pipe->start_writer() //----e return pipe //----f }

---- அ. முதலில் நீங்கள் இந்த குழாயை உருவாக்க வேண்டும், மற்றும் குழாய் பைப்கானுடன் தொடர்புடையது.

---- ப, ---- சி, ----- டி. அனைத்தும் சில அளவுருக்களை அமைக்கின்றன.

---- இ. குழாயின் எழுதும் நூலைத் தொடங்கத் தொடங்குங்கள், இங்கே குழாய் எழுதும் நூல் குழாய்-> எழுத்தாளர் () இன் செயலாக்க செயல்பாடு, இந்த செயல்பாடு osd ஐ இணைக்க முயற்சிக்கும். சாக்கெட் இணைப்பு சேனலை நிறுவவும்.

தற்போதைய ஆதார புள்ளிவிவரங்களின்படி, எழுதும் கோரிக்கை இலக்கு பிரதான OSD க்கு ஏற்ப OSDSession ஐ தேடலாம் அல்லது நிறுவலாம். இந்த OSDSession இல், தரவு சேனலை நிர்வகிக்கும் குழாய் அமைப்பு இருக்கும். இந்த கட்டமைப்பில் செய்திகளை அனுப்பும் ஒரு செயலாக்க நூல் எழுத்தாளர் இருக்கிறார். இந்த நூல் இலக்கு OSD உடன் சாக்கெட் தகவல்தொடர்புகளைப் பராமரிக்கும்.

12. இந்த ஆதாரங்களை நிறுவி பெற்று, பின்னர் _op_submit செயல்பாட்டிற்கு திரும்புக

ceph_tid_t Objecter::_op_submit(Op *op, RWLock::Context& lc) { check_for_latest_map = _calc_target(&op->target, &op->last_force_resend)； //---a int r = _get_session(op->target.osd, &s, lc) //---b _session_op_assign(s, op) //----c MOSDOp *m = _prepare_osd_op(op) //-----d _send_op(op, m) //----e }

--- c, தற்போதைய அமர்வு கோரிக்கையை இந்த அமர்வுக்கு பிணைக்கவும், பின்னர் கோரிக்கையை அனுப்பும்போது எந்த அமர்வை பயன்படுத்த வேண்டும் என்பதை நீங்கள் அறிந்து கொள்ளலாம்.

--d, MOSDop க்கு op ஐ மாற்றவும், பின்னர் MOSDOp ஐ பொருளாகக் கையாளவும்.

--- e, _send_op முன்னர் நிறுவப்பட்ட தகவல் தொடர்பு சேனலின் படி இந்த MOSDOp ஐ அனுப்பும். _Send_op இல் op-> session-> con-> send_message (m) ஐ அழைக்கவும், இந்த முறை SimpleMessager-> send_message (m) ஐ அழைக்கும், பின்னர் _send_message () ஐ அழைக்கவும், பின்னர் submit_message () ஐ அழைக்கவும். Submit_message இல் முந்தைய குழாயைக் கண்டுபிடிக்கும், பின்னர் குழாய்-> அனுப்பும் முறையை அழைக்கவும், இறுதியாக அதை குழாய்-> எழுத்தாளர் நூல் வழியாக இலக்கு osd க்கு அனுப்பவும்.

அப்போதிருந்து, வாடிக்கையாளர் osd செயலாக்கம் முடிவடையும் வரை காத்திருக்கிறார்.

1. மேல் இடது மூலையில் உள்ள ரேடோஸ் கட்டமைப்பைப் பாருங்கள், முதலில் io சூழலை உருவாக்கவும், ரேடோஸ் தகவல்களை உருவாக்கவும், உள்ளமைவு கோப்பில் உள்ள தரவை ரேடோக்களாக கட்டமைக்கவும்.

2. ரேடோக்களின் அடிப்படையில் ஒரு ரேடோஸ் கிளையண்ட் கிளையன்ட் கட்டமைப்பை உருவாக்கவும். இந்த கட்டமைப்பில் மூன்று முக்கியமான தொகுதிகள் உள்ளன, ஃபினிசர் கால்பேக் செயலாக்க நூல், மெசேஜர் செய்தி செயலாக்க அமைப்பு மற்றும் ஆப்ஜெக்டர் தரவு செயலாக்க அமைப்பு. இறுதித் தரவு ஒரு செய்தியுடன் இணைக்கப்பட்டு மெசேஜர் மூலம் இலக்கு osd க்கு அனுப்பப்பட வேண்டும்.

3. பூல் தகவல் மற்றும் ரேடோஸ்கிளைண்ட் அடிப்படையில் ஒரு ioctx ஐ உருவாக்கவும். இங்கே நீங்கள் பூல் தொடர்பான தகவல்களை வைத்திருக்கிறீர்கள், பின்னர் இந்த தகவலைப் பெற்ற பிறகு தரவு செயலாக்கத்தில் அதைப் பயன்படுத்துவீர்கள்.

4. ioctx பின்னர் imagectx க்கு நகலெடுக்கப்பட்டு, data_ioctx மற்றும் md_ioctx தரவு செயலாக்க சேனல்களாக மாறி, இறுதியாக imagectx ஐ பட கட்டமைப்பில் இணைக்கிறது. அதன் பிறகு, அனைத்து எழுதும் செயல்பாடுகளும் இந்த படத்தின் மூலம் செய்யப்படும். உருவாக்கப்பட்ட மற்றும் பயன்படுத்தக்கூடிய தரவு கட்டமைப்பைக் கண்டுபிடிக்க படத்தின் கட்டமைப்பைப் பின்பற்றவும்.

5. மேல் வலது மூலையில் உள்ள படத்தின் மூலம் செயல்பாடுகளைப் படித்து எழுதவும். வாசிப்பு மற்றும் எழுதுதல் செயல்பாட்டின் பொருள் படமாக இருக்கும்போது, ​​படம் கோரிக்கையைச் செயலாக்கத் தொடங்கும், பின்னர் கோரிக்கை செயலாக்கப்பட்ட பிறகு பொருள் பொருளாகப் பிரிக்கப்படும். பிளவுக்குப் பிறகு, இலக்கு osd ஐக் கண்டுபிடிப்பதற்கு செயலாக்கத்திற்காக அது எதிர்ப்பாளரிடம் ஒப்படைக்கப்படும். நிச்சயமாக, இலக்கு osd தொகுப்பு மற்றும் பிரதான osd ஐக் கண்டுபிடிக்க க்ரஷ் வழிமுறை இங்கே பயன்படுத்தப்படுகிறது.

6. கோரிக்கையை ஒரு MOSDOp செய்தியில் இணைத்து, பின்னர் அதை சிம்பிள் மெசேஜரிடம் ஒப்படைக்கவும். சிம்பிள் மெசேஜர் ஏற்கனவே இருக்கும் osd_session இல் கண்டுபிடிக்க முயற்சிக்கும். தொடர்புடைய அமர்வு எதுவும் காணப்படவில்லை எனில், இது ஒரு OSDSession ஐ மீண்டும் உருவாக்கி, இந்த OSDSession க்கான தரவு சேனல் குழாயை உருவாக்கும், தரவு சேனலை சிம்பிள் மெசேஜரில் சேமிக்கவும், அடுத்த முறை பயன்படுத்தலாம்.

7. குழாய் இலக்கு osd உடன் ஒரு சாக்கெட் தகவல்தொடர்பு சேனலை நிறுவுகிறது, மேலும் குழாய் சாக்கெட் தகவல்தொடர்புக்கு பொறுப்பான ஒரு சிறப்பு எழுத்து நூல் எழுத்தாளரைக் கொண்டிருக்கும். நூல் எழுத்தாளரில், தகவல்தொடர்புகளை நிறுவ இலக்கு ஐபி முதலில் இணைக்கப்படும். சிம்பிள் மெசேஜரிடமிருந்து செய்தி வந்த பிறகு, அது குழாயின் வெளிப்புற வரிசையில் சேமிக்கப்படும். எழுத்தாளர் நூலின் மற்றொரு பயன்பாடு அவுட் வரிசையை கண்காணிப்பதாகும். அனுப்ப காத்திருக்கும் வரிசையில் ஒரு செய்தி இருக்கும்போது, ​​செய்தி சாக்கெட்டில் எழுதப்பட்டு இலக்கு OSD க்கு அனுப்பப்படும்.

8. தரவுச் செய்தியைச் செயலாக்குவதற்கு OSD க்காகக் காத்திருந்த பிறகு, அது ஒரு கால்பேக்கைச் செய்வது, செயல்படுத்தல் முடிவைக் கருத்தில் கொள்வது, பின்னர் படிப்படியாக முடிவை அழைப்பவருக்கு தெரிவித்தல்.

நான்கு, செஃப் வாசிப்பு செயல்முறை

OSD முடிவு செய்தி விநியோக செயல்முறை

OSD முடிவு வாசிப்பு செயல்பாட்டு செயலாக்க ஓட்டம்

ஒட்டுமொத்த ஓட்ட விளக்கப்படம்:

முழு வாசிப்பு (inodeno_t ino,
file_layout_t * தளவமைப்பு,
ஸ்னாப்பிட்_டி ஸ்னாப்,
uint64_t ஆஃப்செட்,
uint64_t லென்,
இடையக பட்டியல் * bl, // ptr to data
முழு கொடிகள்,
சூழல் * onfinish,
int op_flags = 0) -------------------------------- Filer.h

ஸ்ட்ரைப்பர் :: file_to_extents (cct, ino, Layout, offset, len, truncate_size, extents) // அணுக வேண்டிய பொருளில் படிக்க வேண்டிய தரவின் நீளம் மற்றும் ஆஃப்செட்டை மாற்றவும், நீட்டிப்புகள் brtfs கோப்பு முறைமையின் கருத்தைப் பின்பற்றுகின்றன
objecter-> sg_read_trunc (extents, snap, bl, flags, truncate_size, truncate_seq, onfinish, op_flags) // osd க்கு ஒரு கோரிக்கையைத் தொடங்கவும்

வாசிப்பு செயல்பாடுகளுக்கு:

1. கிளையன்ட் நேரடியாக சேமிக்கப்பட்ட தரவு எந்த முக்கிய ஓ.எஸ்.டி.யைக் கணக்கிடுகிறது, மேலும் நேரடியாக ஒரு செய்தியை பிரதான ஓ.எஸ்.டி.க்கு அனுப்புகிறது.

2. செய்தியைப் பெற்ற பிறகு, முக்கிய osd கோப்பு முறைமையை பிரதான பி.ஜி.யில் உள்ள உள்ளடக்கத்தை நேரடியாக கோப்பு முறைமையில் படித்து வாடிக்கையாளருக்கு திருப்பி அனுப்பலாம். குறிப்பிட்ட அழைப்பு செயல்பாடு ReplatedPG :: do_osd_ops இல் செயல்படுத்தப்படுகிறது.

CEPH_OSD_OP_MAPEXT || CEPH_OSD_OP_SPARSE_READ

r = osd-> store-> fiemap (coll, soid, op.extent.offset, op.extent.length, bl)

CEPH_OSD_OP_READ

r = pgbackend-> object_read_sync (soid, miter-> first, miter-> second, & tmpbl)

ஐந்து, செஃப் எழுதும் செயல்முறை

OSD எழுதும் செயல்முறை ஓட்டம்

எழுதும் செயல்பாடுகளுக்கு, தரவு எழுத்தின் ஒத்திசைவை உறுதிப்படுத்துவது மிகவும் சிக்கலானது:

1. முதலில் கிளையன்ட் தரவை பிரதான OSD க்கு அனுப்புவார்,

2. மாஸ்டர் osd முதலில் எழுதும் செயல்பாட்டின் முன் செயலாக்கத்தையும் செய்ய வேண்டும், அது முடிந்ததும், அது மற்ற அடிமை osds க்கு ஒரு எழுதும் செய்தியை அனுப்புகிறது, அவை நகல் pg இல் மாற்றங்களைச் செய்ய அனுமதிக்கின்றன,

3. ஓ.எஸ்.டி-யிலிருந்து ஃபைல் ஜர்னல் வழியாக ஜர்னலுக்கு எழுதும் செயல்பாட்டை முடித்த பிறகு, முக்கிய ஓ.எஸ்.டி முடிந்துவிட்டது என்று சொல்ல ஒரு செய்தியை அனுப்பவும், 5 ஐ உள்ளிடவும்

4. எழுதும் செயல்பாட்டை முடிக்க மாஸ்டர் osd அடிமை osd இலிருந்து அனைத்து செய்திகளையும் பெறும்போது, ​​அது கோப்பு ஜர்னல் மூலம் ஜர்னலுக்கு அதன் சொந்த எழுதும் செயல்பாட்டை நிறைவு செய்யும். முடிந்ததும், எழுதும் செயல்பாடு முடிந்ததாக வாடிக்கையாளருக்கு அறிவிக்கப்படும்.

5. பிரதான osd osd நூலிலிருந்து வேலை செய்யத் தொடங்குகிறது மற்றும் ஜர்னலில் தரவை அடிப்படை கோப்பு முறைமைக்கு எழுத பைல்ஸ்டோரை அழைக்கிறது.

எழுதப்பட்ட தர்க்க ஓட்ட விளக்கப்படம் பின்வருமாறு:

எழுதும் செயல்பாடு பின்வரும் படிகளாகப் பிரிக்கப்படுவதை அந்த உருவத்திலிருந்து நாம் காணலாம்:
1. இந்த கட்டுரையின் ஆரம்பத்தில் உள்ள படத்தில் விவரிக்கப்பட்டுள்ளபடி OSD :: op_tp நூல் OSD :: op_wq இலிருந்து எடுக்கப்பட்டது, குறிப்பிட்ட குறியீடு ஓட்டம்

ReplicatePG :: apply_repop C_OSD_OpCommit மற்றும் C_OSD_OpApplied

கோல்பேக் :: வரிசை_ பரிமாற்றங்களில் C_JournaledAhead என்ற அழைப்பு வகுப்பு உருவாக்கப்பட்டது

2. FileJournal :: write_thread நூல் FileJournal :: writeq இலிருந்து செயல்பட எடுக்கப்படுகிறது, முக்கியமாக ஒரு குறிப்பிட்ட பத்திரிகைக்கு தரவை எழுத, மற்றும் குறிப்பிட்ட குறியீடு ஓட்டம்:

3. ஜர்னல் :: Finisher.finisher_thread நூல் ஜர்னலில் இருந்து எடுக்கப்பட்டது :: Finisher.finish_queue. கோல்பேக் செயல்பாட்டை ஃபைல்ஸ்டோர்: _ஜோர்னல்டு_ஹெட் சி_ஜர்னல்அஹெட் விட்டுச் செல்வதன் மூலம், நூல் வேலை செய்யத் தொடங்குகிறது. இரண்டு விஷயங்கள்: முதலில் கோப்பு ஸ்டோர் :: op_wq அறிவிப்பை உள்ளிடவும், தொடங்கவும் கோப்பு அங்காடி :: ondisk_finisher.finisher_queue அறிவிப்பை மீண்டும் எழுதவும். குறிப்பிட்ட குறியீடு ஓட்டம்:

4.FileStore :: ondisk_finisher.finisher_thread நூல் FileStore :: ondisk_finisher.finisher_queue இலிருந்து செயல்பாட்டை எடுத்துக்கொள்கிறது, மேலும் அழைப்பு செயல்பாட்டு செயல்பாட்டை ReplicatePG :: C_OSD_OpCommit விட்டுச் சென்றது.

5. ஃபைல்ஸ்டோர் :: op_tp நூல் பூல் ஃபைல்ஸ்டோரிலிருந்து செயல்படுகிறது :: op_wq (OP_WQ இங்கே பெற்றோர் வகுப்பான ThreadPool :: வாரிசு மற்றும் _process மற்றும் _process_finish போன்ற செயல்பாடுகளை மீண்டும் எழுதுகிறது, எனவே இது OSD :: op_wq இலிருந்து வேறுபட்டது, இது உங்கள் சொந்த பணிப்பாய்வு உள்ளது ), முதலில் FileStore :: _ do_op ஐ அழைக்கவும், முடிந்ததும் FileStore :: _ fin_op ஐ அழைக்கவும்.

6. கோப்பு அங்காடி :: op_finisher.finisher_thread நூல் செயல்பட கோப்பு அங்காடி :: op_finisher.finisher_queue இலிருந்து எடுக்கப்படுகிறது, கால்பேக் செயல்பாட்டை அழைப்பதன் மூலம் ReplicatePG :: op_applied by C_OSD_OpApplied, அறிவிப்பு தரவு படிக்கக்கூடியது.

குறிப்பிட்ட OSD களின் மூலக் குறியீட்டை வாக்கியத்தால் வாக்கியமாக பகுப்பாய்வு செய்யலாம். சியாவோ ஜியாங்கின் வலைப்பதிவு இடுகை

இந்த கட்டுரை முக்கியமாக குறிப்புப் பொருட்களின் உள்ளடக்கத்தைப் பயன்படுத்தி குறிப்புப் பொருட்கள், ஓ.எஸ்.டி இறுதி வாசிப்பு மற்றும் எழுதும் செயல்முறை போன்றவற்றில் செஃப் கிளையன்ட் வாசிப்பு மற்றும் எழுதும் செயல்முறையை சுருக்கமாகக் கூறுகிறது, குறிப்புப் பொருட்களின் ஆசிரியர்களின் உரிமைகள் மீறப்பட்டால், தயவுசெய்து என்னை தொடர்பு கொள்ளவும், தொடர்புடைய உள்ளடக்கத்தை சரியான நேரத்தில் நீக்குவேன்.

குறிப்பு பொருட்கள்:

http://blog.sina.com.cn/s/blog_c2e1a9c7010151xb.html

நூலாசிரியர்: ywy463726588 http://blog.csdn.net/ywy463726588/article/details/42676493

http://blog.csdn.net/ywy463726588/article/details/42679869

ஆசிரியர்: லியு ஷிமின் (சமி லியு) http://www.cnblogs.com/sammyliu/p/4836014.html

ஆசிரியர்: ஒரு சிறிய நதி http://my.oschina.net/u/2460844/blog/532755

http://my.oschina.net/u/2460844/blog/534390?fromerr=PnkKCbYU

தன்னலமற்ற பகிர்வுக்கு மேற்கண்ட ஆசிரியர்களுக்கு நன்றி!