dlopen ఫంక్షన్‌ని ఉపయోగిస్తున్నప్పుడు, కంపైలర్ మేము ఉపయోగిస్తున్న రకాలు మరియు నమూనాల గురించి తెలియనందున సంభావ్య లోపాల కోసం పరిశీలించదు. స్టాండర్డ్ లోడింగ్ కోసం dlopen ఫంక్షన్ యొక్క విస్తరణ కొన్ని చిన్న పరిస్థితులకు తప్ప, దాని ద్వారా ప్రచారం చేయబడినట్లు కనిపించదు. మార్గం ద్వారా, ఇది ఆత్మపరిశీలనను మెరుగుపరచడానికి ఒక విధానం. భాగస్వామ్య మాడ్యూల్ ప్రస్తుతం మరొక ప్రోగ్రామ్ ద్వారా ఉపయోగించబడుతున్నప్పుడు, మెమొరీ లేఅవుట్ ఆప్టిమైజేషన్ ప్రత్యేకించి షరతులతో కూడిన లోడింగ్‌పై ఆసక్తి చూపదు. గతంలో ఉపయోగించిన లైబ్రరీని లోడ్ చేసినప్పుడు మెమరీ ఫుట్‌ప్రింట్ పెరగదు. కంపైలర్ పర్యవేక్షణను నివారించడం ప్రమాదకరం మరియు మంచి బగ్ రైటింగ్ కోసం చేస్తుంది. అదనంగా, మాకు సాధ్యం కంపైలర్ ఆప్టిమైజేషన్ లేదు.
ఉదాహరణ 1:
ఇప్పుడు, C భాషలో dlopen ఫంక్షన్ యొక్క కార్యాచరణను చూడటానికి క్రింది ఉదాహరణను పరిగణించండి. మొదటి దశలో, మేము కొన్ని C ప్రామాణిక లైబ్రరీలను లోడ్ చేస్తాము. ఇక్కడ, మేము కొత్త లైబ్రరీ “dlfcn.h”ని లోడ్ చేస్తాము, ఇది dlopen మోడ్ ఆర్గ్యుమెంట్‌ను నిర్మిస్తున్నప్పుడు మాక్రోలను నిర్వచించడానికి ఉపయోగించబడుతుంది.
అప్పుడు, మేము మా ప్రోగ్రామ్ “gnu/lib-name.h” లోపల మరొక లైబ్రరీని పరిచయం చేస్తాము. GNU libcతో చేర్చబడిన భాగస్వామ్య లైబ్రరీ ఫైల్‌లు అది నిర్వచించిన మాక్రోల ప్రకారం వినియోగదారు ప్రోగ్రామ్‌లచే కనుగొనబడతాయి. GNU C లైబ్రరీ GNU మరియు GNU/Linux ఆపరేటింగ్ సిస్టమ్‌ల కోసం అలాగే అనేక ఇతర Linux-ఆధారిత సిస్టమ్‌ల కోసం ప్రాథమిక లైబ్రరీలను అందిస్తుంది. ఆ తరువాత, మేము ప్రధాన పద్ధతి అమలును కలిగి ఉన్నాము. దాని లోపల, మేము పాయింటర్ ఆబ్జెక్ట్‌ను 'హ్యాండిల్' అని శూన్యమైన కీవర్డ్‌తో ప్రకటిస్తాము. మేము డేటా టైప్ డబుల్ కలిగి ఉన్న పాయింటర్ సైన్ ఫంక్షన్‌ని ప్రకటిస్తాము. లోపం నిర్వహణ కోసం పాయింటర్ ఆబ్జెక్ట్ 'ఎర్రర్' యొక్క మరొక ప్రకటన ఉంది.
ఆ తరువాత, మేము 'హ్యాండిల్' ఆబ్జెక్ట్ లోపల dlopen ఫంక్షన్‌ను అమలు చేస్తాము. dlopen రెండు ఆర్గ్యుమెంట్‌లను తీసుకుంటుంది: LIBM_SO మరియు “RTLD_LAZY”. ఇక్కడ, “LIBM_SO” అనేది త్రికోణమితి ఫంక్షన్‌ల వంటి గణిత విధులను అందించే లైబ్రరీ ఫైల్ పేరు. మేము సైన్ ఫంక్షన్‌ని ఉపయోగిస్తున్నందున ఈ షేర్డ్ లైబ్రరీ అవసరం. 'RTLD_LAZY' అనేది dlopen ఫంక్షన్‌ని పిలిచే మరొక వాదన. ఇచ్చిన చిహ్నాన్ని మొదటిసారి సూచించినప్పుడు, అమలు ద్వారా నిర్ణయించబడిన సమయంలో పునరావాసాలు తప్పనిసరిగా నిర్వహించబడతాయి.
ఒక ప్రక్రియ ఎక్జిక్యూటబుల్ ఆబ్జెక్ట్ ఫైల్‌లోని ప్రతి చిహ్నాన్ని సూచించకపోవచ్చు కాబట్టి, RTLD LAZYని పేర్కొనడం వలన డైనమిక్ సింబల్ బైండింగ్‌ను ప్రారంభించే ఇంప్లిమెంటేషన్‌లలో పనితీరు మెరుగుపడుతుంది. తర్వాత, హ్యాండిల్ ఆబ్జెక్ట్ dlopen ఫంక్షన్‌ను చేయడంలో విఫలమైనప్పుడు లోపం నిర్వహణ కోసం మనకు if-else షరతు ఉంటుంది. లోపాన్ని క్లియర్ చేయడానికి మేము dlerror అని పిలుస్తాము.
dlerror() ఫంక్షన్ మానవులకు చదవగలిగే శూన్య-ముగింపు స్ట్రింగ్‌ను అందిస్తుంది మరియు చివరి dlerror కాల్ నుండి dlopen API కాల్‌లలో ఒకదానికి కాల్ చేయడం వలన సంభవించిన ఇటీవలి లోపం యొక్క రిపోర్టింగ్‌ను నిర్దేశిస్తుంది. అప్పుడు, మేము ఫంక్షన్‌ను ఇలా ప్రసారం చేస్తాము: “(* శూన్యం **)(&sine)= dlsym(హ్యాండిల్, పాపం)”. ఇది వింతగా ఉన్నందున, కాస్టింగ్ ISO Cకి అనుగుణంగా ఉంటుంది, ఇది కంపైలర్ నుండి హెచ్చరికలను నివారిస్తుంది. మేము dlsym ఫంక్షన్‌ని ఉపయోగిస్తాము, ఇది డైనమిక్ లింక్ మాడ్యూల్ లోపల పేర్కొనబడిన చిహ్నం యొక్క మార్గాన్ని పొందుతుంది, ఇది dlopen() ఫంక్షన్ ద్వారా యాక్సెస్ చేయబడుతుంది.
అలాగే, dlerror() NULL కానప్పుడు ఉత్పన్నమయ్యే ప్రామాణిక లోపం కోసం మేము if-else ఆపరేషన్‌ను మళ్లీ చేస్తాము. అప్పుడు, మనకు ఒక printf స్టేట్‌మెంట్ ఉంటుంది, అక్కడ మనం గణించాల్సిన సైన్ విలువను నిర్దేశిస్తాము. చివరి దశలో, dlopen() ద్వారా తిరిగి వచ్చిన హ్యాండిల్ కోసం dlcloseని ప్రారంభించడం ద్వారా మేము ఆ భాగస్వామ్య వస్తువును మూసివేస్తాము.
#
#
#
#include
int
ప్రధాన ( int argc , చార్ ** argv )
{
శూన్యం * హ్యాండిల్ ;
రెట్టింపు ( * వారిది ) ( రెట్టింపు ) ;
చార్ * లోపం ;
హ్యాండిల్ = dlopen ( LIBM_SO , RTLD_LAZY ) ;
ఉంటే ( ! హ్యాండిల్ ) {
fprintf ( stderr , '%s \n ' , dlerror ( ) ) ;
బయటకి దారి ( EXIT_FAILURE ) ;
}
dlerror ( ) ;
* ( శూన్యం ** ) ( & వారిది ) = dlsym ( హ్యాండిల్ , 'లేకుండా' ) ;
ఉంటే ( ( లోపం = dlerror ( ) ) != శూన్య ) {
fprintf ( stderr , '%s \n ' , లోపం ) ;
బయటకి దారి ( EXIT_FAILURE ) ;
}
printf ( '%f \n ' , ( * వారిది ) ( 4.0 ) ) ;
dlclose ( హ్యాండిల్ ) ;
బయటకి దారి ( EXIT_SUCCESS ) ;
}
ఇది dlopen లింక్డ్ ఇంటర్‌ఫేస్ కోసం లైబ్రరీ మరియు ఇది అవసరం కాబట్టి మేము C కంపైలేషన్ కమాండ్‌తో -ldl ఎంపికను ఉపయోగిస్తాము. dlopen ఫైల్ అమలు చేయబడినప్పుడు, ఇది గతంలో ఇచ్చిన విలువ యొక్క సైన్ విలువను ప్రదర్శిస్తుంది.
ఉదాహరణ 2:
ఇప్పుడు, మేము dlopen ఫంక్షన్‌ను ఉపయోగించటానికి మరొక ఉదాహరణ తీసుకుంటాము. మేము dlopen కోడ్ అమలు కోసం అవసరమైన అన్ని C లైబ్రరీలతో మా ప్రోగ్రామ్‌ను లోడ్ చేస్తాము. అప్పుడు, మేము మా ప్రోగ్రామ్‌ను ప్రధాన పద్ధతిలో ప్రారంభిస్తాము. ఇక్కడ, వేరియబుల్ “src” డిక్లరేషన్‌తో మేము స్ట్రింగ్‌ను నిర్వచించాము. మేము పాయింటర్ వేరియబుల్స్ 'strlen', 'హ్యాండిల్' మరియు 'ఎర్రర్' డిక్లేర్ చేస్తాము.
తరువాత, మేము హ్యాండిల్ వేరియబుల్ అని పిలుస్తాము మరియు dlopen ఫంక్షన్‌ను అమలు చేస్తాము. dlopen ఫంక్షన్ స్ట్రింగ్ హ్యాండ్లింగ్ ఫంక్షన్‌ల కోసం షేర్డ్ లైబ్రరీ “libstr.so”ని ఇన్‌పుట్ చేస్తుంది మరియు మునుపటి ఉదాహరణలో ఇప్పటికే ప్రదర్శించబడిన “RTLD_LAZY” ఫ్లాగ్‌ను ఇన్‌పుట్ చేస్తుంది. dlopen ఫంక్షన్ ద్వారా ఉత్పన్నమయ్యే లోపాన్ని క్లియర్ చేయడానికి మేము 'ఎర్రర్' వేరియబుల్ లోపల dlerror ఫంక్షన్‌ని అమలు చేస్తాము. లోపాలను పరిశీలించడానికి if-else ఉపయోగించబడుతుంది.
అప్పుడు, మేము dlsym ఫంక్షన్‌ని ఉపయోగించి strlen ఫంక్షన్ యొక్క చిరునామాను పొందుతాము మరియు దీన్ని చేస్తున్నప్పుడు లోపాలను ధృవీకరిస్తాము. దీని తర్వాత, మేము ఇచ్చిన స్ట్రింగ్ యొక్క పొడవును తిరిగి ఇవ్వడానికి strnlen ఫంక్షన్‌కు కాల్ చేయడానికి printf ఫంక్షన్‌ని ఉపయోగిస్తాము. చివరికి, మేము dlclose ఫంక్షన్‌తో షేర్డ్ లైబ్రరీని మూసివేస్తాము.
##
#
#include
int ప్రధాన ( శూన్యం )
{
చార్ * src = 'హలో Linux' ;
int ( * strlen ) ( స్థిరంగా చార్ * ) ;
శూన్యం * హ్యాండిల్ ;
చార్ * లోపం ;
హ్యాండిల్ = dlopen ( './libstr.so' , RTLD_LAZY ) ;
లోపం = dlerror ( ) ;
ఉంటే ( ! హ్యాండిల్ || లోపం != శూన్య ) { printf ( 'లైబ్రరీ లోడ్ ప్రయత్నం విఫలమైంది! \n %s \n ' , లోపం ) ;
తిరిగి - 1 ; }
strlen = dlsym ( హ్యాండిల్ , 'strlen' ) ;
లోపం = dlerror ( ) ;
ఉంటే ( ! strlen || లోపం == శూన్య ) { printf ( '%s \n ' , లోపం ) ; తిరిగి - 1 ; }
printf ( 'స్ట్రింగ్ యొక్క పొడవు:%d \n ' , strlen ( src ) ) ;
dlclose ( హ్యాండిల్ ) ;
తిరిగి 0 ;
}
ఇచ్చిన ప్రోగ్రామ్ యొక్క అమలు కోసం మేము కింది ఆదేశాన్ని ఉపయోగిస్తాము. ఇక్కడ, స్ట్రింగ్ పొడవు ఫంక్షన్ కోసం -lstr ఫ్లాగ్ ఉపయోగించబడుతుంది మరియు dlopen లైబ్రరీ ఫైల్ కోసం ldl ఉపయోగించబడుతుంది. కంపైల్ చేయబడిన ప్రోగ్రామ్ షెల్‌లో చూపిన విధంగా స్ట్రింగ్ యొక్క పొడవును ఇస్తుంది:
ముగింపు
ఈ కథనంలో సి భాష యొక్క dlopen ఫంక్షన్‌కు సంబంధించి సమాచారం అందించబడింది. మాకు dlopen ఫంక్షన్ గురించి క్లుప్త పరిచయం ఉంది. అప్పుడు, మేము రెండు ఉదాహరణలను అమలు చేసాము. ఫంక్షన్ తెరవబడిన లైబ్రరీని నిర్వచించే ఐడెంటిఫైయర్‌ని అందిస్తుంది. తెరవబడిన లైబ్రరీ లోపల ఉన్న ఫంక్షన్‌ల చిరునామాలు ఈ ఐడెంటిఫైయర్ మరియు dlsym ఫంక్షన్‌ని ఉపయోగించి నిర్ణయించబడతాయి. dlopen ఉపయోగించి ఇప్పటికే తెరవబడిన లైబ్రరీలోని ఫంక్షన్ చిరునామాను dlsym ఫంక్షన్‌ని ఉపయోగించి కనుగొనవచ్చు.