qemu-char.c 121 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194319531963197319831993200320132023203320432053206320732083209321032113212321332143215321632173218321932203221322232233224322532263227322832293230323132323233323432353236323732383239324032413242324332443245324632473248324932503251325232533254325532563257325832593260326132623263326432653266326732683269327032713272327332743275327632773278327932803281328232833284328532863287328832893290329132923293329432953296329732983299330033013302330333043305330633073308330933103311331233133314331533163317331833193320332133223323332433253326332733283329333033313332333333343335333633373338333933403341334233433344334533463347334833493350335133523353335433553356335733583359336033613362336333643365336633673368336933703371337233733374337533763377337833793380338133823383338433853386338733883389339033913392339333943395339633973398339934003401340234033404340534063407340834093410341134123413341434153416341734183419342034213422342334243425342634273428342934303431343234333434343534363437343834393440344134423443344434453446344734483449345034513452345334543455345634573458345934603461346234633464346534663467346834693470347134723473347434753476347734783479348034813482348334843485348634873488348934903491349234933494349534963497349834993500350135023503350435053506350735083509351035113512351335143515351635173518351935203521352235233524352535263527352835293530353135323533353435353536353735383539354035413542354335443545354635473548354935503551355235533554355535563557355835593560356135623563356435653566356735683569357035713572357335743575357635773578357935803581358235833584358535863587358835893590359135923593359435953596359735983599360036013602360336043605360636073608360936103611361236133614361536163617361836193620362136223623362436253626362736283629363036313632363336343635363636373638363936403641364236433644364536463647364836493650365136523653365436553656365736583659366036613662366336643665366636673668366936703671367236733674367536763677367836793680368136823683368436853686368736883689369036913692369336943695369636973698369937003701370237033704370537063707370837093710371137123713371437153716371737183719372037213722372337243725372637273728372937303731373237333734373537363737373837393740374137423743374437453746374737483749375037513752375337543755375637573758375937603761376237633764376537663767376837693770377137723773377437753776377737783779378037813782378337843785378637873788378937903791379237933794379537963797379837993800380138023803380438053806380738083809381038113812381338143815381638173818381938203821382238233824382538263827382838293830383138323833383438353836383738383839384038413842384338443845384638473848384938503851385238533854385538563857385838593860386138623863386438653866386738683869387038713872387338743875387638773878387938803881388238833884388538863887388838893890389138923893389438953896389738983899390039013902390339043905390639073908390939103911391239133914391539163917391839193920392139223923392439253926392739283929393039313932393339343935393639373938393939403941394239433944394539463947394839493950395139523953395439553956395739583959396039613962396339643965396639673968396939703971397239733974397539763977397839793980398139823983398439853986398739883989399039913992399339943995399639973998399940004001400240034004400540064007400840094010401140124013401440154016401740184019402040214022402340244025402640274028402940304031403240334034403540364037403840394040404140424043404440454046404740484049405040514052405340544055405640574058405940604061406240634064406540664067406840694070407140724073407440754076407740784079408040814082408340844085408640874088408940904091409240934094409540964097409840994100410141024103410441054106410741084109411041114112411341144115411641174118411941204121412241234124412541264127412841294130413141324133413441354136413741384139414041414142414341444145414641474148414941504151415241534154415541564157415841594160416141624163416441654166416741684169417041714172417341744175417641774178417941804181418241834184418541864187418841894190419141924193419441954196419741984199420042014202420342044205420642074208420942104211421242134214421542164217421842194220422142224223422442254226422742284229423042314232423342344235423642374238423942404241424242434244424542464247424842494250425142524253425442554256425742584259426042614262426342644265426642674268426942704271427242734274427542764277427842794280428142824283428442854286428742884289429042914292429342944295429642974298429943004301430243034304430543064307430843094310431143124313431443154316431743184319432043214322432343244325432643274328432943304331433243334334433543364337433843394340434143424343434443454346434743484349435043514352435343544355435643574358435943604361436243634364436543664367436843694370437143724373437443754376437743784379438043814382438343844385438643874388438943904391439243934394439543964397439843994400440144024403440444054406440744084409441044114412441344144415441644174418441944204421442244234424442544264427442844294430443144324433443444354436443744384439444044414442444344444445444644474448444944504451445244534454445544564457445844594460446144624463446444654466446744684469447044714472447344744475447644774478447944804481448244834484448544864487448844894490449144924493449444954496449744984499450045014502450345044505450645074508
  1. /*
  2. * QEMU System Emulator
  3. *
  4. * Copyright (c) 2003-2008 Fabrice Bellard
  5. *
  6. * Permission is hereby granted, free of charge, to any person obtaining a copy
  7. * of this software and associated documentation files (the "Software"), to deal
  8. * in the Software without restriction, including without limitation the rights
  9. * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10. * copies of the Software, and to permit persons to whom the Software is
  11. * furnished to do so, subject to the following conditions:
  12. *
  13. * The above copyright notice and this permission notice shall be included in
  14. * all copies or substantial portions of the Software.
  15. *
  16. * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17. * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18. * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19. * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20. * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21. * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22. * THE SOFTWARE.
  23. */
  24. #include "qemu/osdep.h"
  25. #include "qemu-common.h"
  26. #include "monitor/monitor.h"
  27. #include "sysemu/sysemu.h"
  28. #include "qemu/error-report.h"
  29. #include "qemu/timer.h"
  30. #include "sysemu/char.h"
  31. #include "hw/usb.h"
  32. #include "qmp-commands.h"
  33. #include "qapi/qmp-input-visitor.h"
  34. #include "qapi/qmp-output-visitor.h"
  35. #include "qapi-visit.h"
  36. #include "qemu/base64.h"
  37. #include "io/channel-socket.h"
  38. #include "io/channel-file.h"
  39. #include "io/channel-tls.h"
  40. #include <zlib.h>
  41. #ifndef _WIN32
  42. #include <sys/times.h>
  43. #include <sys/wait.h>
  44. #include <termios.h>
  45. #include <sys/mman.h>
  46. #include <sys/ioctl.h>
  47. #include <sys/resource.h>
  48. #include <sys/socket.h>
  49. #include <netinet/in.h>
  50. #include <net/if.h>
  51. #include <arpa/inet.h>
  52. #include <netdb.h>
  53. #include <sys/select.h>
  54. #ifdef CONFIG_BSD
  55. #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
  56. #include <dev/ppbus/ppi.h>
  57. #include <dev/ppbus/ppbconf.h>
  58. #elif defined(__DragonFly__)
  59. #include <dev/misc/ppi/ppi.h>
  60. #include <bus/ppbus/ppbconf.h>
  61. #endif
  62. #else
  63. #ifdef __linux__
  64. #include <linux/ppdev.h>
  65. #include <linux/parport.h>
  66. #endif
  67. #ifdef __sun__
  68. #include <sys/ethernet.h>
  69. #include <sys/sockio.h>
  70. #include <netinet/arp.h>
  71. #include <netinet/in.h>
  72. #include <netinet/in_systm.h>
  73. #include <netinet/ip.h>
  74. #include <netinet/ip_icmp.h> // must come after ip.h
  75. #include <netinet/udp.h>
  76. #include <netinet/tcp.h>
  77. #endif
  78. #endif
  79. #endif
  80. #include "qemu/sockets.h"
  81. #include "ui/qemu-spice.h"
  82. #define READ_BUF_LEN 4096
  83. #define READ_RETRIES 10
  84. #define TCP_MAX_FDS 16
  85. /***********************************************************/
  86. /* Socket address helpers */
  87. static char *SocketAddress_to_str(const char *prefix, SocketAddress *addr,
  88. bool is_listen, bool is_telnet)
  89. {
  90. switch (addr->type) {
  91. case SOCKET_ADDRESS_KIND_INET:
  92. return g_strdup_printf("%s%s:%s:%s%s", prefix,
  93. is_telnet ? "telnet" : "tcp", addr->u.inet->host,
  94. addr->u.inet->port, is_listen ? ",server" : "");
  95. break;
  96. case SOCKET_ADDRESS_KIND_UNIX:
  97. return g_strdup_printf("%sunix:%s%s", prefix,
  98. addr->u.q_unix->path,
  99. is_listen ? ",server" : "");
  100. break;
  101. case SOCKET_ADDRESS_KIND_FD:
  102. return g_strdup_printf("%sfd:%s%s", prefix, addr->u.fd->str,
  103. is_listen ? ",server" : "");
  104. break;
  105. default:
  106. abort();
  107. }
  108. }
  109. static char *sockaddr_to_str(struct sockaddr_storage *ss, socklen_t ss_len,
  110. struct sockaddr_storage *ps, socklen_t ps_len,
  111. bool is_listen, bool is_telnet)
  112. {
  113. char shost[NI_MAXHOST], sserv[NI_MAXSERV];
  114. char phost[NI_MAXHOST], pserv[NI_MAXSERV];
  115. const char *left = "", *right = "";
  116. switch (ss->ss_family) {
  117. #ifndef _WIN32
  118. case AF_UNIX:
  119. return g_strdup_printf("unix:%s%s",
  120. ((struct sockaddr_un *)(ss))->sun_path,
  121. is_listen ? ",server" : "");
  122. #endif
  123. case AF_INET6:
  124. left = "[";
  125. right = "]";
  126. /* fall through */
  127. case AF_INET:
  128. getnameinfo((struct sockaddr *) ss, ss_len, shost, sizeof(shost),
  129. sserv, sizeof(sserv), NI_NUMERICHOST | NI_NUMERICSERV);
  130. getnameinfo((struct sockaddr *) ps, ps_len, phost, sizeof(phost),
  131. pserv, sizeof(pserv), NI_NUMERICHOST | NI_NUMERICSERV);
  132. return g_strdup_printf("%s:%s%s%s:%s%s <-> %s%s%s:%s",
  133. is_telnet ? "telnet" : "tcp",
  134. left, shost, right, sserv,
  135. is_listen ? ",server" : "",
  136. left, phost, right, pserv);
  137. default:
  138. return g_strdup_printf("unknown");
  139. }
  140. }
  141. /***********************************************************/
  142. /* character device */
  143. static QTAILQ_HEAD(CharDriverStateHead, CharDriverState) chardevs =
  144. QTAILQ_HEAD_INITIALIZER(chardevs);
  145. static void qemu_chr_free_common(CharDriverState *chr);
  146. CharDriverState *qemu_chr_alloc(ChardevCommon *backend, Error **errp)
  147. {
  148. CharDriverState *chr = g_malloc0(sizeof(CharDriverState));
  149. qemu_mutex_init(&chr->chr_write_lock);
  150. if (backend->has_logfile) {
  151. int flags = O_WRONLY | O_CREAT;
  152. if (backend->has_logappend &&
  153. backend->logappend) {
  154. flags |= O_APPEND;
  155. } else {
  156. flags |= O_TRUNC;
  157. }
  158. chr->logfd = qemu_open(backend->logfile, flags, 0666);
  159. if (chr->logfd < 0) {
  160. error_setg_errno(errp, errno,
  161. "Unable to open logfile %s",
  162. backend->logfile);
  163. g_free(chr);
  164. return NULL;
  165. }
  166. } else {
  167. chr->logfd = -1;
  168. }
  169. return chr;
  170. }
  171. void qemu_chr_be_event(CharDriverState *s, int event)
  172. {
  173. /* Keep track if the char device is open */
  174. switch (event) {
  175. case CHR_EVENT_OPENED:
  176. s->be_open = 1;
  177. break;
  178. case CHR_EVENT_CLOSED:
  179. s->be_open = 0;
  180. break;
  181. }
  182. if (!s->chr_event)
  183. return;
  184. s->chr_event(s->handler_opaque, event);
  185. }
  186. void qemu_chr_be_generic_open(CharDriverState *s)
  187. {
  188. qemu_chr_be_event(s, CHR_EVENT_OPENED);
  189. }
  190. /* Not reporting errors from writing to logfile, as logs are
  191. * defined to be "best effort" only */
  192. static void qemu_chr_fe_write_log(CharDriverState *s,
  193. const uint8_t *buf, size_t len)
  194. {
  195. size_t done = 0;
  196. ssize_t ret;
  197. if (s->logfd < 0) {
  198. return;
  199. }
  200. while (done < len) {
  201. do {
  202. ret = write(s->logfd, buf + done, len - done);
  203. if (ret == -1 && errno == EAGAIN) {
  204. g_usleep(100);
  205. }
  206. } while (ret == -1 && errno == EAGAIN);
  207. if (ret <= 0) {
  208. return;
  209. }
  210. done += ret;
  211. }
  212. }
  213. int qemu_chr_fe_write(CharDriverState *s, const uint8_t *buf, int len)
  214. {
  215. int ret;
  216. qemu_mutex_lock(&s->chr_write_lock);
  217. ret = s->chr_write(s, buf, len);
  218. if (ret > 0) {
  219. qemu_chr_fe_write_log(s, buf, ret);
  220. }
  221. qemu_mutex_unlock(&s->chr_write_lock);
  222. return ret;
  223. }
  224. int qemu_chr_fe_write_all(CharDriverState *s, const uint8_t *buf, int len)
  225. {
  226. int offset = 0;
  227. int res = 0;
  228. qemu_mutex_lock(&s->chr_write_lock);
  229. while (offset < len) {
  230. do {
  231. res = s->chr_write(s, buf + offset, len - offset);
  232. if (res == -1 && errno == EAGAIN) {
  233. g_usleep(100);
  234. }
  235. } while (res == -1 && errno == EAGAIN);
  236. if (res <= 0) {
  237. break;
  238. }
  239. offset += res;
  240. }
  241. if (offset > 0) {
  242. qemu_chr_fe_write_log(s, buf, offset);
  243. }
  244. qemu_mutex_unlock(&s->chr_write_lock);
  245. if (res < 0) {
  246. return res;
  247. }
  248. return offset;
  249. }
  250. int qemu_chr_fe_read_all(CharDriverState *s, uint8_t *buf, int len)
  251. {
  252. int offset = 0, counter = 10;
  253. int res;
  254. if (!s->chr_sync_read) {
  255. return 0;
  256. }
  257. while (offset < len) {
  258. do {
  259. res = s->chr_sync_read(s, buf + offset, len - offset);
  260. if (res == -1 && errno == EAGAIN) {
  261. g_usleep(100);
  262. }
  263. } while (res == -1 && errno == EAGAIN);
  264. if (res == 0) {
  265. break;
  266. }
  267. if (res < 0) {
  268. return res;
  269. }
  270. offset += res;
  271. if (!counter--) {
  272. break;
  273. }
  274. }
  275. return offset;
  276. }
  277. int qemu_chr_fe_ioctl(CharDriverState *s, int cmd, void *arg)
  278. {
  279. if (!s->chr_ioctl)
  280. return -ENOTSUP;
  281. return s->chr_ioctl(s, cmd, arg);
  282. }
  283. int qemu_chr_be_can_write(CharDriverState *s)
  284. {
  285. if (!s->chr_can_read)
  286. return 0;
  287. return s->chr_can_read(s->handler_opaque);
  288. }
  289. void qemu_chr_be_write(CharDriverState *s, uint8_t *buf, int len)
  290. {
  291. if (s->chr_read) {
  292. s->chr_read(s->handler_opaque, buf, len);
  293. }
  294. }
  295. int qemu_chr_fe_get_msgfd(CharDriverState *s)
  296. {
  297. int fd;
  298. return (qemu_chr_fe_get_msgfds(s, &fd, 1) == 1) ? fd : -1;
  299. }
  300. int qemu_chr_fe_get_msgfds(CharDriverState *s, int *fds, int len)
  301. {
  302. return s->get_msgfds ? s->get_msgfds(s, fds, len) : -1;
  303. }
  304. int qemu_chr_fe_set_msgfds(CharDriverState *s, int *fds, int num)
  305. {
  306. return s->set_msgfds ? s->set_msgfds(s, fds, num) : -1;
  307. }
  308. int qemu_chr_add_client(CharDriverState *s, int fd)
  309. {
  310. return s->chr_add_client ? s->chr_add_client(s, fd) : -1;
  311. }
  312. void qemu_chr_accept_input(CharDriverState *s)
  313. {
  314. if (s->chr_accept_input)
  315. s->chr_accept_input(s);
  316. qemu_notify_event();
  317. }
  318. void qemu_chr_fe_printf(CharDriverState *s, const char *fmt, ...)
  319. {
  320. char buf[READ_BUF_LEN];
  321. va_list ap;
  322. va_start(ap, fmt);
  323. vsnprintf(buf, sizeof(buf), fmt, ap);
  324. qemu_chr_fe_write(s, (uint8_t *)buf, strlen(buf));
  325. va_end(ap);
  326. }
  327. static void remove_fd_in_watch(CharDriverState *chr);
  328. void qemu_chr_add_handlers(CharDriverState *s,
  329. IOCanReadHandler *fd_can_read,
  330. IOReadHandler *fd_read,
  331. IOEventHandler *fd_event,
  332. void *opaque)
  333. {
  334. int fe_open;
  335. if (!opaque && !fd_can_read && !fd_read && !fd_event) {
  336. fe_open = 0;
  337. remove_fd_in_watch(s);
  338. } else {
  339. fe_open = 1;
  340. }
  341. s->chr_can_read = fd_can_read;
  342. s->chr_read = fd_read;
  343. s->chr_event = fd_event;
  344. s->handler_opaque = opaque;
  345. if (fe_open && s->chr_update_read_handler)
  346. s->chr_update_read_handler(s);
  347. if (!s->explicit_fe_open) {
  348. qemu_chr_fe_set_open(s, fe_open);
  349. }
  350. /* We're connecting to an already opened device, so let's make sure we
  351. also get the open event */
  352. if (fe_open && s->be_open) {
  353. qemu_chr_be_generic_open(s);
  354. }
  355. }
  356. static int null_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
  357. {
  358. return len;
  359. }
  360. static CharDriverState *qemu_chr_open_null(const char *id,
  361. ChardevBackend *backend,
  362. ChardevReturn *ret,
  363. Error **errp)
  364. {
  365. CharDriverState *chr;
  366. ChardevCommon *common = qapi_ChardevDummy_base(backend->u.null);
  367. chr = qemu_chr_alloc(common, errp);
  368. if (!chr) {
  369. return NULL;
  370. }
  371. chr->chr_write = null_chr_write;
  372. chr->explicit_be_open = true;
  373. return chr;
  374. }
  375. /* MUX driver for serial I/O splitting */
  376. #define MAX_MUX 4
  377. #define MUX_BUFFER_SIZE 32 /* Must be a power of 2. */
  378. #define MUX_BUFFER_MASK (MUX_BUFFER_SIZE - 1)
  379. typedef struct {
  380. IOCanReadHandler *chr_can_read[MAX_MUX];
  381. IOReadHandler *chr_read[MAX_MUX];
  382. IOEventHandler *chr_event[MAX_MUX];
  383. void *ext_opaque[MAX_MUX];
  384. CharDriverState *drv;
  385. int focus;
  386. int mux_cnt;
  387. int term_got_escape;
  388. int max_size;
  389. /* Intermediate input buffer allows to catch escape sequences even if the
  390. currently active device is not accepting any input - but only until it
  391. is full as well. */
  392. unsigned char buffer[MAX_MUX][MUX_BUFFER_SIZE];
  393. int prod[MAX_MUX];
  394. int cons[MAX_MUX];
  395. int timestamps;
  396. /* Protected by the CharDriverState chr_write_lock. */
  397. int linestart;
  398. int64_t timestamps_start;
  399. } MuxDriver;
  400. /* Called with chr_write_lock held. */
  401. static int mux_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
  402. {
  403. MuxDriver *d = chr->opaque;
  404. int ret;
  405. if (!d->timestamps) {
  406. ret = qemu_chr_fe_write(d->drv, buf, len);
  407. } else {
  408. int i;
  409. ret = 0;
  410. for (i = 0; i < len; i++) {
  411. if (d->linestart) {
  412. char buf1[64];
  413. int64_t ti;
  414. int secs;
  415. ti = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
  416. if (d->timestamps_start == -1)
  417. d->timestamps_start = ti;
  418. ti -= d->timestamps_start;
  419. secs = ti / 1000;
  420. snprintf(buf1, sizeof(buf1),
  421. "[%02d:%02d:%02d.%03d] ",
  422. secs / 3600,
  423. (secs / 60) % 60,
  424. secs % 60,
  425. (int)(ti % 1000));
  426. qemu_chr_fe_write(d->drv, (uint8_t *)buf1, strlen(buf1));
  427. d->linestart = 0;
  428. }
  429. ret += qemu_chr_fe_write(d->drv, buf+i, 1);
  430. if (buf[i] == '\n') {
  431. d->linestart = 1;
  432. }
  433. }
  434. }
  435. return ret;
  436. }
  437. static const char * const mux_help[] = {
  438. "% h print this help\n\r",
  439. "% x exit emulator\n\r",
  440. "% s save disk data back to file (if -snapshot)\n\r",
  441. "% t toggle console timestamps\n\r",
  442. "% b send break (magic sysrq)\n\r",
  443. "% c switch between console and monitor\n\r",
  444. "% % sends %\n\r",
  445. NULL
  446. };
  447. int term_escape_char = 0x01; /* ctrl-a is used for escape */
  448. static void mux_print_help(CharDriverState *chr)
  449. {
  450. int i, j;
  451. char ebuf[15] = "Escape-Char";
  452. char cbuf[50] = "\n\r";
  453. if (term_escape_char > 0 && term_escape_char < 26) {
  454. snprintf(cbuf, sizeof(cbuf), "\n\r");
  455. snprintf(ebuf, sizeof(ebuf), "C-%c", term_escape_char - 1 + 'a');
  456. } else {
  457. snprintf(cbuf, sizeof(cbuf),
  458. "\n\rEscape-Char set to Ascii: 0x%02x\n\r\n\r",
  459. term_escape_char);
  460. }
  461. qemu_chr_fe_write(chr, (uint8_t *)cbuf, strlen(cbuf));
  462. for (i = 0; mux_help[i] != NULL; i++) {
  463. for (j=0; mux_help[i][j] != '\0'; j++) {
  464. if (mux_help[i][j] == '%')
  465. qemu_chr_fe_write(chr, (uint8_t *)ebuf, strlen(ebuf));
  466. else
  467. qemu_chr_fe_write(chr, (uint8_t *)&mux_help[i][j], 1);
  468. }
  469. }
  470. }
  471. static void mux_chr_send_event(MuxDriver *d, int mux_nr, int event)
  472. {
  473. if (d->chr_event[mux_nr])
  474. d->chr_event[mux_nr](d->ext_opaque[mux_nr], event);
  475. }
  476. static int mux_proc_byte(CharDriverState *chr, MuxDriver *d, int ch)
  477. {
  478. if (d->term_got_escape) {
  479. d->term_got_escape = 0;
  480. if (ch == term_escape_char)
  481. goto send_char;
  482. switch(ch) {
  483. case '?':
  484. case 'h':
  485. mux_print_help(chr);
  486. break;
  487. case 'x':
  488. {
  489. const char *term = "QEMU: Terminated\n\r";
  490. qemu_chr_fe_write(chr, (uint8_t *)term, strlen(term));
  491. exit(0);
  492. break;
  493. }
  494. case 's':
  495. bdrv_commit_all();
  496. break;
  497. case 'b':
  498. qemu_chr_be_event(chr, CHR_EVENT_BREAK);
  499. break;
  500. case 'c':
  501. /* Switch to the next registered device */
  502. mux_chr_send_event(d, d->focus, CHR_EVENT_MUX_OUT);
  503. d->focus++;
  504. if (d->focus >= d->mux_cnt)
  505. d->focus = 0;
  506. mux_chr_send_event(d, d->focus, CHR_EVENT_MUX_IN);
  507. break;
  508. case 't':
  509. d->timestamps = !d->timestamps;
  510. d->timestamps_start = -1;
  511. d->linestart = 0;
  512. break;
  513. }
  514. } else if (ch == term_escape_char) {
  515. d->term_got_escape = 1;
  516. } else {
  517. send_char:
  518. return 1;
  519. }
  520. return 0;
  521. }
  522. static void mux_chr_accept_input(CharDriverState *chr)
  523. {
  524. MuxDriver *d = chr->opaque;
  525. int m = d->focus;
  526. while (d->prod[m] != d->cons[m] &&
  527. d->chr_can_read[m] &&
  528. d->chr_can_read[m](d->ext_opaque[m])) {
  529. d->chr_read[m](d->ext_opaque[m],
  530. &d->buffer[m][d->cons[m]++ & MUX_BUFFER_MASK], 1);
  531. }
  532. }
  533. static int mux_chr_can_read(void *opaque)
  534. {
  535. CharDriverState *chr = opaque;
  536. MuxDriver *d = chr->opaque;
  537. int m = d->focus;
  538. if ((d->prod[m] - d->cons[m]) < MUX_BUFFER_SIZE)
  539. return 1;
  540. if (d->chr_can_read[m])
  541. return d->chr_can_read[m](d->ext_opaque[m]);
  542. return 0;
  543. }
  544. static void mux_chr_read(void *opaque, const uint8_t *buf, int size)
  545. {
  546. CharDriverState *chr = opaque;
  547. MuxDriver *d = chr->opaque;
  548. int m = d->focus;
  549. int i;
  550. mux_chr_accept_input (opaque);
  551. for(i = 0; i < size; i++)
  552. if (mux_proc_byte(chr, d, buf[i])) {
  553. if (d->prod[m] == d->cons[m] &&
  554. d->chr_can_read[m] &&
  555. d->chr_can_read[m](d->ext_opaque[m]))
  556. d->chr_read[m](d->ext_opaque[m], &buf[i], 1);
  557. else
  558. d->buffer[m][d->prod[m]++ & MUX_BUFFER_MASK] = buf[i];
  559. }
  560. }
  561. static void mux_chr_event(void *opaque, int event)
  562. {
  563. CharDriverState *chr = opaque;
  564. MuxDriver *d = chr->opaque;
  565. int i;
  566. /* Send the event to all registered listeners */
  567. for (i = 0; i < d->mux_cnt; i++)
  568. mux_chr_send_event(d, i, event);
  569. }
  570. static void mux_chr_update_read_handler(CharDriverState *chr)
  571. {
  572. MuxDriver *d = chr->opaque;
  573. if (d->mux_cnt >= MAX_MUX) {
  574. fprintf(stderr, "Cannot add I/O handlers, MUX array is full\n");
  575. return;
  576. }
  577. d->ext_opaque[d->mux_cnt] = chr->handler_opaque;
  578. d->chr_can_read[d->mux_cnt] = chr->chr_can_read;
  579. d->chr_read[d->mux_cnt] = chr->chr_read;
  580. d->chr_event[d->mux_cnt] = chr->chr_event;
  581. /* Fix up the real driver with mux routines */
  582. if (d->mux_cnt == 0) {
  583. qemu_chr_add_handlers(d->drv, mux_chr_can_read, mux_chr_read,
  584. mux_chr_event, chr);
  585. }
  586. if (d->focus != -1) {
  587. mux_chr_send_event(d, d->focus, CHR_EVENT_MUX_OUT);
  588. }
  589. d->focus = d->mux_cnt;
  590. d->mux_cnt++;
  591. mux_chr_send_event(d, d->focus, CHR_EVENT_MUX_IN);
  592. }
  593. static bool muxes_realized;
  594. /**
  595. * Called after processing of default and command-line-specified
  596. * chardevs to deliver CHR_EVENT_OPENED events to any FEs attached
  597. * to a mux chardev. This is done here to ensure that
  598. * output/prompts/banners are only displayed for the FE that has
  599. * focus when initial command-line processing/machine init is
  600. * completed.
  601. *
  602. * After this point, any new FE attached to any new or existing
  603. * mux will receive CHR_EVENT_OPENED notifications for the BE
  604. * immediately.
  605. */
  606. static void muxes_realize_done(Notifier *notifier, void *unused)
  607. {
  608. CharDriverState *chr;
  609. QTAILQ_FOREACH(chr, &chardevs, next) {
  610. if (chr->is_mux) {
  611. MuxDriver *d = chr->opaque;
  612. int i;
  613. /* send OPENED to all already-attached FEs */
  614. for (i = 0; i < d->mux_cnt; i++) {
  615. mux_chr_send_event(d, i, CHR_EVENT_OPENED);
  616. }
  617. /* mark mux as OPENED so any new FEs will immediately receive
  618. * OPENED event
  619. */
  620. qemu_chr_be_generic_open(chr);
  621. }
  622. }
  623. muxes_realized = true;
  624. }
  625. static Notifier muxes_realize_notify = {
  626. .notify = muxes_realize_done,
  627. };
  628. static GSource *mux_chr_add_watch(CharDriverState *s, GIOCondition cond)
  629. {
  630. MuxDriver *d = s->opaque;
  631. return d->drv->chr_add_watch(d->drv, cond);
  632. }
  633. static CharDriverState *qemu_chr_open_mux(const char *id,
  634. ChardevBackend *backend,
  635. ChardevReturn *ret, Error **errp)
  636. {
  637. ChardevMux *mux = backend->u.mux;
  638. CharDriverState *chr, *drv;
  639. MuxDriver *d;
  640. ChardevCommon *common = qapi_ChardevMux_base(backend->u.mux);
  641. drv = qemu_chr_find(mux->chardev);
  642. if (drv == NULL) {
  643. error_setg(errp, "mux: base chardev %s not found", mux->chardev);
  644. return NULL;
  645. }
  646. chr = qemu_chr_alloc(common, errp);
  647. if (!chr) {
  648. return NULL;
  649. }
  650. d = g_new0(MuxDriver, 1);
  651. chr->opaque = d;
  652. d->drv = drv;
  653. d->focus = -1;
  654. chr->chr_write = mux_chr_write;
  655. chr->chr_update_read_handler = mux_chr_update_read_handler;
  656. chr->chr_accept_input = mux_chr_accept_input;
  657. /* Frontend guest-open / -close notification is not support with muxes */
  658. chr->chr_set_fe_open = NULL;
  659. if (drv->chr_add_watch) {
  660. chr->chr_add_watch = mux_chr_add_watch;
  661. }
  662. /* only default to opened state if we've realized the initial
  663. * set of muxes
  664. */
  665. chr->explicit_be_open = muxes_realized ? 0 : 1;
  666. chr->is_mux = 1;
  667. return chr;
  668. }
  669. typedef struct IOWatchPoll
  670. {
  671. GSource parent;
  672. QIOChannel *ioc;
  673. GSource *src;
  674. IOCanReadHandler *fd_can_read;
  675. GSourceFunc fd_read;
  676. void *opaque;
  677. } IOWatchPoll;
  678. static IOWatchPoll *io_watch_poll_from_source(GSource *source)
  679. {
  680. return container_of(source, IOWatchPoll, parent);
  681. }
  682. static gboolean io_watch_poll_prepare(GSource *source, gint *timeout_)
  683. {
  684. IOWatchPoll *iwp = io_watch_poll_from_source(source);
  685. bool now_active = iwp->fd_can_read(iwp->opaque) > 0;
  686. bool was_active = iwp->src != NULL;
  687. if (was_active == now_active) {
  688. return FALSE;
  689. }
  690. if (now_active) {
  691. iwp->src = qio_channel_create_watch(
  692. iwp->ioc, G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL);
  693. g_source_set_callback(iwp->src, iwp->fd_read, iwp->opaque, NULL);
  694. g_source_attach(iwp->src, NULL);
  695. } else {
  696. g_source_destroy(iwp->src);
  697. g_source_unref(iwp->src);
  698. iwp->src = NULL;
  699. }
  700. return FALSE;
  701. }
  702. static gboolean io_watch_poll_check(GSource *source)
  703. {
  704. return FALSE;
  705. }
  706. static gboolean io_watch_poll_dispatch(GSource *source, GSourceFunc callback,
  707. gpointer user_data)
  708. {
  709. abort();
  710. }
  711. static void io_watch_poll_finalize(GSource *source)
  712. {
  713. /* Due to a glib bug, removing the last reference to a source
  714. * inside a finalize callback causes recursive locking (and a
  715. * deadlock). This is not a problem inside other callbacks,
  716. * including dispatch callbacks, so we call io_remove_watch_poll
  717. * to remove this source. At this point, iwp->src must
  718. * be NULL, or we would leak it.
  719. *
  720. * This would be solved much more elegantly by child sources,
  721. * but we support older glib versions that do not have them.
  722. */
  723. IOWatchPoll *iwp = io_watch_poll_from_source(source);
  724. assert(iwp->src == NULL);
  725. }
  726. static GSourceFuncs io_watch_poll_funcs = {
  727. .prepare = io_watch_poll_prepare,
  728. .check = io_watch_poll_check,
  729. .dispatch = io_watch_poll_dispatch,
  730. .finalize = io_watch_poll_finalize,
  731. };
  732. /* Can only be used for read */
  733. static guint io_add_watch_poll(QIOChannel *ioc,
  734. IOCanReadHandler *fd_can_read,
  735. QIOChannelFunc fd_read,
  736. gpointer user_data)
  737. {
  738. IOWatchPoll *iwp;
  739. int tag;
  740. iwp = (IOWatchPoll *) g_source_new(&io_watch_poll_funcs, sizeof(IOWatchPoll));
  741. iwp->fd_can_read = fd_can_read;
  742. iwp->opaque = user_data;
  743. iwp->ioc = ioc;
  744. iwp->fd_read = (GSourceFunc) fd_read;
  745. iwp->src = NULL;
  746. tag = g_source_attach(&iwp->parent, NULL);
  747. g_source_unref(&iwp->parent);
  748. return tag;
  749. }
  750. static void io_remove_watch_poll(guint tag)
  751. {
  752. GSource *source;
  753. IOWatchPoll *iwp;
  754. g_return_if_fail (tag > 0);
  755. source = g_main_context_find_source_by_id(NULL, tag);
  756. g_return_if_fail (source != NULL);
  757. iwp = io_watch_poll_from_source(source);
  758. if (iwp->src) {
  759. g_source_destroy(iwp->src);
  760. g_source_unref(iwp->src);
  761. iwp->src = NULL;
  762. }
  763. g_source_destroy(&iwp->parent);
  764. }
  765. static void remove_fd_in_watch(CharDriverState *chr)
  766. {
  767. if (chr->fd_in_tag) {
  768. io_remove_watch_poll(chr->fd_in_tag);
  769. chr->fd_in_tag = 0;
  770. }
  771. }
  772. static int io_channel_send_full(QIOChannel *ioc,
  773. const void *buf, size_t len,
  774. int *fds, size_t nfds)
  775. {
  776. size_t offset = 0;
  777. while (offset < len) {
  778. ssize_t ret = 0;
  779. struct iovec iov = { .iov_base = (char *)buf + offset,
  780. .iov_len = len - offset };
  781. ret = qio_channel_writev_full(
  782. ioc, &iov, 1,
  783. fds, nfds, NULL);
  784. if (ret == QIO_CHANNEL_ERR_BLOCK) {
  785. errno = EAGAIN;
  786. return -1;
  787. } else if (ret < 0) {
  788. if (offset) {
  789. return offset;
  790. }
  791. errno = EINVAL;
  792. return -1;
  793. }
  794. offset += ret;
  795. }
  796. return offset;
  797. }
  798. #ifndef _WIN32
  799. static int io_channel_send(QIOChannel *ioc, const void *buf, size_t len)
  800. {
  801. return io_channel_send_full(ioc, buf, len, NULL, 0);
  802. }
  803. typedef struct FDCharDriver {
  804. CharDriverState *chr;
  805. QIOChannel *ioc_in, *ioc_out;
  806. int max_size;
  807. } FDCharDriver;
  808. /* Called with chr_write_lock held. */
  809. static int fd_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
  810. {
  811. FDCharDriver *s = chr->opaque;
  812. return io_channel_send(s->ioc_out, buf, len);
  813. }
  814. static gboolean fd_chr_read(QIOChannel *chan, GIOCondition cond, void *opaque)
  815. {
  816. CharDriverState *chr = opaque;
  817. FDCharDriver *s = chr->opaque;
  818. int len;
  819. uint8_t buf[READ_BUF_LEN];
  820. ssize_t ret;
  821. len = sizeof(buf);
  822. if (len > s->max_size) {
  823. len = s->max_size;
  824. }
  825. if (len == 0) {
  826. return TRUE;
  827. }
  828. ret = qio_channel_read(
  829. chan, (gchar *)buf, len, NULL);
  830. if (ret == 0) {
  831. remove_fd_in_watch(chr);
  832. qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
  833. return FALSE;
  834. }
  835. if (ret > 0) {
  836. qemu_chr_be_write(chr, buf, ret);
  837. }
  838. return TRUE;
  839. }
  840. static int fd_chr_read_poll(void *opaque)
  841. {
  842. CharDriverState *chr = opaque;
  843. FDCharDriver *s = chr->opaque;
  844. s->max_size = qemu_chr_be_can_write(chr);
  845. return s->max_size;
  846. }
  847. static GSource *fd_chr_add_watch(CharDriverState *chr, GIOCondition cond)
  848. {
  849. FDCharDriver *s = chr->opaque;
  850. return qio_channel_create_watch(s->ioc_out, cond);
  851. }
  852. static void fd_chr_update_read_handler(CharDriverState *chr)
  853. {
  854. FDCharDriver *s = chr->opaque;
  855. remove_fd_in_watch(chr);
  856. if (s->ioc_in) {
  857. chr->fd_in_tag = io_add_watch_poll(s->ioc_in,
  858. fd_chr_read_poll,
  859. fd_chr_read, chr);
  860. }
  861. }
  862. static void fd_chr_close(struct CharDriverState *chr)
  863. {
  864. FDCharDriver *s = chr->opaque;
  865. remove_fd_in_watch(chr);
  866. if (s->ioc_in) {
  867. object_unref(OBJECT(s->ioc_in));
  868. }
  869. if (s->ioc_out) {
  870. object_unref(OBJECT(s->ioc_out));
  871. }
  872. g_free(s);
  873. qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
  874. }
  875. /* open a character device to a unix fd */
  876. static CharDriverState *qemu_chr_open_fd(int fd_in, int fd_out,
  877. ChardevCommon *backend, Error **errp)
  878. {
  879. CharDriverState *chr;
  880. FDCharDriver *s;
  881. chr = qemu_chr_alloc(backend, errp);
  882. if (!chr) {
  883. return NULL;
  884. }
  885. s = g_new0(FDCharDriver, 1);
  886. s->ioc_in = QIO_CHANNEL(qio_channel_file_new_fd(fd_in));
  887. s->ioc_out = QIO_CHANNEL(qio_channel_file_new_fd(fd_out));
  888. qemu_set_nonblock(fd_out);
  889. s->chr = chr;
  890. chr->opaque = s;
  891. chr->chr_add_watch = fd_chr_add_watch;
  892. chr->chr_write = fd_chr_write;
  893. chr->chr_update_read_handler = fd_chr_update_read_handler;
  894. chr->chr_close = fd_chr_close;
  895. return chr;
  896. }
  897. static CharDriverState *qemu_chr_open_pipe(const char *id,
  898. ChardevBackend *backend,
  899. ChardevReturn *ret,
  900. Error **errp)
  901. {
  902. ChardevHostdev *opts = backend->u.pipe;
  903. int fd_in, fd_out;
  904. char *filename_in;
  905. char *filename_out;
  906. const char *filename = opts->device;
  907. ChardevCommon *common = qapi_ChardevHostdev_base(backend->u.pipe);
  908. filename_in = g_strdup_printf("%s.in", filename);
  909. filename_out = g_strdup_printf("%s.out", filename);
  910. TFR(fd_in = qemu_open(filename_in, O_RDWR | O_BINARY));
  911. TFR(fd_out = qemu_open(filename_out, O_RDWR | O_BINARY));
  912. g_free(filename_in);
  913. g_free(filename_out);
  914. if (fd_in < 0 || fd_out < 0) {
  915. if (fd_in >= 0)
  916. close(fd_in);
  917. if (fd_out >= 0)
  918. close(fd_out);
  919. TFR(fd_in = fd_out = qemu_open(filename, O_RDWR | O_BINARY));
  920. if (fd_in < 0) {
  921. error_setg_file_open(errp, errno, filename);
  922. return NULL;
  923. }
  924. }
  925. return qemu_chr_open_fd(fd_in, fd_out, common, errp);
  926. }
  927. /* init terminal so that we can grab keys */
  928. static struct termios oldtty;
  929. static int old_fd0_flags;
  930. static bool stdio_in_use;
  931. static bool stdio_allow_signal;
  932. static bool stdio_echo_state;
  933. static void qemu_chr_set_echo_stdio(CharDriverState *chr, bool echo);
  934. static void term_exit(void)
  935. {
  936. tcsetattr (0, TCSANOW, &oldtty);
  937. fcntl(0, F_SETFL, old_fd0_flags);
  938. }
  939. static void term_stdio_handler(int sig)
  940. {
  941. /* restore echo after resume from suspend. */
  942. qemu_chr_set_echo_stdio(NULL, stdio_echo_state);
  943. }
  944. static void qemu_chr_set_echo_stdio(CharDriverState *chr, bool echo)
  945. {
  946. struct termios tty;
  947. stdio_echo_state = echo;
  948. tty = oldtty;
  949. if (!echo) {
  950. tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
  951. |INLCR|IGNCR|ICRNL|IXON);
  952. tty.c_oflag |= OPOST;
  953. tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
  954. tty.c_cflag &= ~(CSIZE|PARENB);
  955. tty.c_cflag |= CS8;
  956. tty.c_cc[VMIN] = 1;
  957. tty.c_cc[VTIME] = 0;
  958. }
  959. if (!stdio_allow_signal)
  960. tty.c_lflag &= ~ISIG;
  961. tcsetattr (0, TCSANOW, &tty);
  962. }
  963. static void qemu_chr_close_stdio(struct CharDriverState *chr)
  964. {
  965. term_exit();
  966. fd_chr_close(chr);
  967. }
  968. static CharDriverState *qemu_chr_open_stdio(const char *id,
  969. ChardevBackend *backend,
  970. ChardevReturn *ret,
  971. Error **errp)
  972. {
  973. ChardevStdio *opts = backend->u.stdio;
  974. CharDriverState *chr;
  975. struct sigaction act;
  976. ChardevCommon *common = qapi_ChardevStdio_base(backend->u.stdio);
  977. if (is_daemonized()) {
  978. error_setg(errp, "cannot use stdio with -daemonize");
  979. return NULL;
  980. }
  981. if (stdio_in_use) {
  982. error_setg(errp, "cannot use stdio by multiple character devices");
  983. return NULL;
  984. }
  985. stdio_in_use = true;
  986. old_fd0_flags = fcntl(0, F_GETFL);
  987. tcgetattr(0, &oldtty);
  988. qemu_set_nonblock(0);
  989. atexit(term_exit);
  990. memset(&act, 0, sizeof(act));
  991. act.sa_handler = term_stdio_handler;
  992. sigaction(SIGCONT, &act, NULL);
  993. chr = qemu_chr_open_fd(0, 1, common, errp);
  994. chr->chr_close = qemu_chr_close_stdio;
  995. chr->chr_set_echo = qemu_chr_set_echo_stdio;
  996. if (opts->has_signal) {
  997. stdio_allow_signal = opts->signal;
  998. }
  999. qemu_chr_fe_set_echo(chr, false);
  1000. return chr;
  1001. }
  1002. #if defined(__linux__) || defined(__sun__) || defined(__FreeBSD__) \
  1003. || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) \
  1004. || defined(__GLIBC__)
  1005. #define HAVE_CHARDEV_SERIAL 1
  1006. #define HAVE_CHARDEV_PTY 1
  1007. typedef struct {
  1008. QIOChannel *ioc;
  1009. int read_bytes;
  1010. /* Protected by the CharDriverState chr_write_lock. */
  1011. int connected;
  1012. guint timer_tag;
  1013. guint open_tag;
  1014. } PtyCharDriver;
  1015. static void pty_chr_update_read_handler_locked(CharDriverState *chr);
  1016. static void pty_chr_state(CharDriverState *chr, int connected);
  1017. static gboolean pty_chr_timer(gpointer opaque)
  1018. {
  1019. struct CharDriverState *chr = opaque;
  1020. PtyCharDriver *s = chr->opaque;
  1021. qemu_mutex_lock(&chr->chr_write_lock);
  1022. s->timer_tag = 0;
  1023. s->open_tag = 0;
  1024. if (!s->connected) {
  1025. /* Next poll ... */
  1026. pty_chr_update_read_handler_locked(chr);
  1027. }
  1028. qemu_mutex_unlock(&chr->chr_write_lock);
  1029. return FALSE;
  1030. }
  1031. /* Called with chr_write_lock held. */
  1032. static void pty_chr_rearm_timer(CharDriverState *chr, int ms)
  1033. {
  1034. PtyCharDriver *s = chr->opaque;
  1035. if (s->timer_tag) {
  1036. g_source_remove(s->timer_tag);
  1037. s->timer_tag = 0;
  1038. }
  1039. if (ms == 1000) {
  1040. s->timer_tag = g_timeout_add_seconds(1, pty_chr_timer, chr);
  1041. } else {
  1042. s->timer_tag = g_timeout_add(ms, pty_chr_timer, chr);
  1043. }
  1044. }
  1045. /* Called with chr_write_lock held. */
  1046. static void pty_chr_update_read_handler_locked(CharDriverState *chr)
  1047. {
  1048. PtyCharDriver *s = chr->opaque;
  1049. GPollFD pfd;
  1050. int rc;
  1051. QIOChannelFile *fioc = QIO_CHANNEL_FILE(s->ioc);
  1052. pfd.fd = fioc->fd;
  1053. pfd.events = G_IO_OUT;
  1054. pfd.revents = 0;
  1055. do {
  1056. rc = g_poll(&pfd, 1, 0);
  1057. } while (rc == -1 && errno == EINTR);
  1058. assert(rc >= 0);
  1059. if (pfd.revents & G_IO_HUP) {
  1060. pty_chr_state(chr, 0);
  1061. } else {
  1062. pty_chr_state(chr, 1);
  1063. }
  1064. }
  1065. static void pty_chr_update_read_handler(CharDriverState *chr)
  1066. {
  1067. qemu_mutex_lock(&chr->chr_write_lock);
  1068. pty_chr_update_read_handler_locked(chr);
  1069. qemu_mutex_unlock(&chr->chr_write_lock);
  1070. }
  1071. /* Called with chr_write_lock held. */
  1072. static int pty_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
  1073. {
  1074. PtyCharDriver *s = chr->opaque;
  1075. if (!s->connected) {
  1076. /* guest sends data, check for (re-)connect */
  1077. pty_chr_update_read_handler_locked(chr);
  1078. if (!s->connected) {
  1079. return 0;
  1080. }
  1081. }
  1082. return io_channel_send(s->ioc, buf, len);
  1083. }
  1084. static GSource *pty_chr_add_watch(CharDriverState *chr, GIOCondition cond)
  1085. {
  1086. PtyCharDriver *s = chr->opaque;
  1087. if (!s->connected) {
  1088. return NULL;
  1089. }
  1090. return qio_channel_create_watch(s->ioc, cond);
  1091. }
  1092. static int pty_chr_read_poll(void *opaque)
  1093. {
  1094. CharDriverState *chr = opaque;
  1095. PtyCharDriver *s = chr->opaque;
  1096. s->read_bytes = qemu_chr_be_can_write(chr);
  1097. return s->read_bytes;
  1098. }
  1099. static gboolean pty_chr_read(QIOChannel *chan, GIOCondition cond, void *opaque)
  1100. {
  1101. CharDriverState *chr = opaque;
  1102. PtyCharDriver *s = chr->opaque;
  1103. gsize len;
  1104. uint8_t buf[READ_BUF_LEN];
  1105. ssize_t ret;
  1106. len = sizeof(buf);
  1107. if (len > s->read_bytes)
  1108. len = s->read_bytes;
  1109. if (len == 0) {
  1110. return TRUE;
  1111. }
  1112. ret = qio_channel_read(s->ioc, (char *)buf, len, NULL);
  1113. if (ret <= 0) {
  1114. pty_chr_state(chr, 0);
  1115. return FALSE;
  1116. } else {
  1117. pty_chr_state(chr, 1);
  1118. qemu_chr_be_write(chr, buf, ret);
  1119. }
  1120. return TRUE;
  1121. }
  1122. static gboolean qemu_chr_be_generic_open_func(gpointer opaque)
  1123. {
  1124. CharDriverState *chr = opaque;
  1125. PtyCharDriver *s = chr->opaque;
  1126. s->open_tag = 0;
  1127. qemu_chr_be_generic_open(chr);
  1128. return FALSE;
  1129. }
  1130. /* Called with chr_write_lock held. */
  1131. static void pty_chr_state(CharDriverState *chr, int connected)
  1132. {
  1133. PtyCharDriver *s = chr->opaque;
  1134. if (!connected) {
  1135. if (s->open_tag) {
  1136. g_source_remove(s->open_tag);
  1137. s->open_tag = 0;
  1138. }
  1139. remove_fd_in_watch(chr);
  1140. s->connected = 0;
  1141. /* (re-)connect poll interval for idle guests: once per second.
  1142. * We check more frequently in case the guests sends data to
  1143. * the virtual device linked to our pty. */
  1144. pty_chr_rearm_timer(chr, 1000);
  1145. } else {
  1146. if (s->timer_tag) {
  1147. g_source_remove(s->timer_tag);
  1148. s->timer_tag = 0;
  1149. }
  1150. if (!s->connected) {
  1151. g_assert(s->open_tag == 0);
  1152. s->connected = 1;
  1153. s->open_tag = g_idle_add(qemu_chr_be_generic_open_func, chr);
  1154. }
  1155. if (!chr->fd_in_tag) {
  1156. chr->fd_in_tag = io_add_watch_poll(s->ioc,
  1157. pty_chr_read_poll,
  1158. pty_chr_read, chr);
  1159. }
  1160. }
  1161. }
  1162. static void pty_chr_close(struct CharDriverState *chr)
  1163. {
  1164. PtyCharDriver *s = chr->opaque;
  1165. qemu_mutex_lock(&chr->chr_write_lock);
  1166. pty_chr_state(chr, 0);
  1167. object_unref(OBJECT(s->ioc));
  1168. if (s->timer_tag) {
  1169. g_source_remove(s->timer_tag);
  1170. s->timer_tag = 0;
  1171. }
  1172. qemu_mutex_unlock(&chr->chr_write_lock);
  1173. g_free(s);
  1174. qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
  1175. }
  1176. static CharDriverState *qemu_chr_open_pty(const char *id,
  1177. ChardevBackend *backend,
  1178. ChardevReturn *ret,
  1179. Error **errp)
  1180. {
  1181. CharDriverState *chr;
  1182. PtyCharDriver *s;
  1183. int master_fd, slave_fd;
  1184. char pty_name[PATH_MAX];
  1185. ChardevCommon *common = qapi_ChardevDummy_base(backend->u.pty);
  1186. master_fd = qemu_openpty_raw(&slave_fd, pty_name);
  1187. if (master_fd < 0) {
  1188. error_setg_errno(errp, errno, "Failed to create PTY");
  1189. return NULL;
  1190. }
  1191. close(slave_fd);
  1192. qemu_set_nonblock(master_fd);
  1193. chr = qemu_chr_alloc(common, errp);
  1194. if (!chr) {
  1195. close(master_fd);
  1196. return NULL;
  1197. }
  1198. chr->filename = g_strdup_printf("pty:%s", pty_name);
  1199. ret->pty = g_strdup(pty_name);
  1200. ret->has_pty = true;
  1201. fprintf(stderr, "char device redirected to %s (label %s)\n",
  1202. pty_name, id);
  1203. s = g_new0(PtyCharDriver, 1);
  1204. chr->opaque = s;
  1205. chr->chr_write = pty_chr_write;
  1206. chr->chr_update_read_handler = pty_chr_update_read_handler;
  1207. chr->chr_close = pty_chr_close;
  1208. chr->chr_add_watch = pty_chr_add_watch;
  1209. chr->explicit_be_open = true;
  1210. s->ioc = QIO_CHANNEL(qio_channel_file_new_fd(master_fd));
  1211. s->timer_tag = 0;
  1212. return chr;
  1213. }
  1214. static void tty_serial_init(int fd, int speed,
  1215. int parity, int data_bits, int stop_bits)
  1216. {
  1217. struct termios tty;
  1218. speed_t spd;
  1219. #if 0
  1220. printf("tty_serial_init: speed=%d parity=%c data=%d stop=%d\n",
  1221. speed, parity, data_bits, stop_bits);
  1222. #endif
  1223. tcgetattr (fd, &tty);
  1224. #define check_speed(val) if (speed <= val) { spd = B##val; break; }
  1225. speed = speed * 10 / 11;
  1226. do {
  1227. check_speed(50);
  1228. check_speed(75);
  1229. check_speed(110);
  1230. check_speed(134);
  1231. check_speed(150);
  1232. check_speed(200);
  1233. check_speed(300);
  1234. check_speed(600);
  1235. check_speed(1200);
  1236. check_speed(1800);
  1237. check_speed(2400);
  1238. check_speed(4800);
  1239. check_speed(9600);
  1240. check_speed(19200);
  1241. check_speed(38400);
  1242. /* Non-Posix values follow. They may be unsupported on some systems. */
  1243. check_speed(57600);
  1244. check_speed(115200);
  1245. #ifdef B230400
  1246. check_speed(230400);
  1247. #endif
  1248. #ifdef B460800
  1249. check_speed(460800);
  1250. #endif
  1251. #ifdef B500000
  1252. check_speed(500000);
  1253. #endif
  1254. #ifdef B576000
  1255. check_speed(576000);
  1256. #endif
  1257. #ifdef B921600
  1258. check_speed(921600);
  1259. #endif
  1260. #ifdef B1000000
  1261. check_speed(1000000);
  1262. #endif
  1263. #ifdef B1152000
  1264. check_speed(1152000);
  1265. #endif
  1266. #ifdef B1500000
  1267. check_speed(1500000);
  1268. #endif
  1269. #ifdef B2000000
  1270. check_speed(2000000);
  1271. #endif
  1272. #ifdef B2500000
  1273. check_speed(2500000);
  1274. #endif
  1275. #ifdef B3000000
  1276. check_speed(3000000);
  1277. #endif
  1278. #ifdef B3500000
  1279. check_speed(3500000);
  1280. #endif
  1281. #ifdef B4000000
  1282. check_speed(4000000);
  1283. #endif
  1284. spd = B115200;
  1285. } while (0);
  1286. cfsetispeed(&tty, spd);
  1287. cfsetospeed(&tty, spd);
  1288. tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
  1289. |INLCR|IGNCR|ICRNL|IXON);
  1290. tty.c_oflag |= OPOST;
  1291. tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN|ISIG);
  1292. tty.c_cflag &= ~(CSIZE|PARENB|PARODD|CRTSCTS|CSTOPB);
  1293. switch(data_bits) {
  1294. default:
  1295. case 8:
  1296. tty.c_cflag |= CS8;
  1297. break;
  1298. case 7:
  1299. tty.c_cflag |= CS7;
  1300. break;
  1301. case 6:
  1302. tty.c_cflag |= CS6;
  1303. break;
  1304. case 5:
  1305. tty.c_cflag |= CS5;
  1306. break;
  1307. }
  1308. switch(parity) {
  1309. default:
  1310. case 'N':
  1311. break;
  1312. case 'E':
  1313. tty.c_cflag |= PARENB;
  1314. break;
  1315. case 'O':
  1316. tty.c_cflag |= PARENB | PARODD;
  1317. break;
  1318. }
  1319. if (stop_bits == 2)
  1320. tty.c_cflag |= CSTOPB;
  1321. tcsetattr (fd, TCSANOW, &tty);
  1322. }
  1323. static int tty_serial_ioctl(CharDriverState *chr, int cmd, void *arg)
  1324. {
  1325. FDCharDriver *s = chr->opaque;
  1326. QIOChannelFile *fioc = QIO_CHANNEL_FILE(s->ioc_in);
  1327. switch(cmd) {
  1328. case CHR_IOCTL_SERIAL_SET_PARAMS:
  1329. {
  1330. QEMUSerialSetParams *ssp = arg;
  1331. tty_serial_init(fioc->fd,
  1332. ssp->speed, ssp->parity,
  1333. ssp->data_bits, ssp->stop_bits);
  1334. }
  1335. break;
  1336. case CHR_IOCTL_SERIAL_SET_BREAK:
  1337. {
  1338. int enable = *(int *)arg;
  1339. if (enable) {
  1340. tcsendbreak(fioc->fd, 1);
  1341. }
  1342. }
  1343. break;
  1344. case CHR_IOCTL_SERIAL_GET_TIOCM:
  1345. {
  1346. int sarg = 0;
  1347. int *targ = (int *)arg;
  1348. ioctl(fioc->fd, TIOCMGET, &sarg);
  1349. *targ = 0;
  1350. if (sarg & TIOCM_CTS)
  1351. *targ |= CHR_TIOCM_CTS;
  1352. if (sarg & TIOCM_CAR)
  1353. *targ |= CHR_TIOCM_CAR;
  1354. if (sarg & TIOCM_DSR)
  1355. *targ |= CHR_TIOCM_DSR;
  1356. if (sarg & TIOCM_RI)
  1357. *targ |= CHR_TIOCM_RI;
  1358. if (sarg & TIOCM_DTR)
  1359. *targ |= CHR_TIOCM_DTR;
  1360. if (sarg & TIOCM_RTS)
  1361. *targ |= CHR_TIOCM_RTS;
  1362. }
  1363. break;
  1364. case CHR_IOCTL_SERIAL_SET_TIOCM:
  1365. {
  1366. int sarg = *(int *)arg;
  1367. int targ = 0;
  1368. ioctl(fioc->fd, TIOCMGET, &targ);
  1369. targ &= ~(CHR_TIOCM_CTS | CHR_TIOCM_CAR | CHR_TIOCM_DSR
  1370. | CHR_TIOCM_RI | CHR_TIOCM_DTR | CHR_TIOCM_RTS);
  1371. if (sarg & CHR_TIOCM_CTS)
  1372. targ |= TIOCM_CTS;
  1373. if (sarg & CHR_TIOCM_CAR)
  1374. targ |= TIOCM_CAR;
  1375. if (sarg & CHR_TIOCM_DSR)
  1376. targ |= TIOCM_DSR;
  1377. if (sarg & CHR_TIOCM_RI)
  1378. targ |= TIOCM_RI;
  1379. if (sarg & CHR_TIOCM_DTR)
  1380. targ |= TIOCM_DTR;
  1381. if (sarg & CHR_TIOCM_RTS)
  1382. targ |= TIOCM_RTS;
  1383. ioctl(fioc->fd, TIOCMSET, &targ);
  1384. }
  1385. break;
  1386. default:
  1387. return -ENOTSUP;
  1388. }
  1389. return 0;
  1390. }
  1391. static void qemu_chr_close_tty(CharDriverState *chr)
  1392. {
  1393. fd_chr_close(chr);
  1394. }
  1395. static CharDriverState *qemu_chr_open_tty_fd(int fd,
  1396. ChardevCommon *backend,
  1397. Error **errp)
  1398. {
  1399. CharDriverState *chr;
  1400. tty_serial_init(fd, 115200, 'N', 8, 1);
  1401. chr = qemu_chr_open_fd(fd, fd, backend, errp);
  1402. chr->chr_ioctl = tty_serial_ioctl;
  1403. chr->chr_close = qemu_chr_close_tty;
  1404. return chr;
  1405. }
  1406. #endif /* __linux__ || __sun__ */
  1407. #if defined(__linux__)
  1408. #define HAVE_CHARDEV_PARPORT 1
  1409. typedef struct {
  1410. int fd;
  1411. int mode;
  1412. } ParallelCharDriver;
  1413. static int pp_hw_mode(ParallelCharDriver *s, uint16_t mode)
  1414. {
  1415. if (s->mode != mode) {
  1416. int m = mode;
  1417. if (ioctl(s->fd, PPSETMODE, &m) < 0)
  1418. return 0;
  1419. s->mode = mode;
  1420. }
  1421. return 1;
  1422. }
  1423. static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
  1424. {
  1425. ParallelCharDriver *drv = chr->opaque;
  1426. int fd = drv->fd;
  1427. uint8_t b;
  1428. switch(cmd) {
  1429. case CHR_IOCTL_PP_READ_DATA:
  1430. if (ioctl(fd, PPRDATA, &b) < 0)
  1431. return -ENOTSUP;
  1432. *(uint8_t *)arg = b;
  1433. break;
  1434. case CHR_IOCTL_PP_WRITE_DATA:
  1435. b = *(uint8_t *)arg;
  1436. if (ioctl(fd, PPWDATA, &b) < 0)
  1437. return -ENOTSUP;
  1438. break;
  1439. case CHR_IOCTL_PP_READ_CONTROL:
  1440. if (ioctl(fd, PPRCONTROL, &b) < 0)
  1441. return -ENOTSUP;
  1442. /* Linux gives only the lowest bits, and no way to know data
  1443. direction! For better compatibility set the fixed upper
  1444. bits. */
  1445. *(uint8_t *)arg = b | 0xc0;
  1446. break;
  1447. case CHR_IOCTL_PP_WRITE_CONTROL:
  1448. b = *(uint8_t *)arg;
  1449. if (ioctl(fd, PPWCONTROL, &b) < 0)
  1450. return -ENOTSUP;
  1451. break;
  1452. case CHR_IOCTL_PP_READ_STATUS:
  1453. if (ioctl(fd, PPRSTATUS, &b) < 0)
  1454. return -ENOTSUP;
  1455. *(uint8_t *)arg = b;
  1456. break;
  1457. case CHR_IOCTL_PP_DATA_DIR:
  1458. if (ioctl(fd, PPDATADIR, (int *)arg) < 0)
  1459. return -ENOTSUP;
  1460. break;
  1461. case CHR_IOCTL_PP_EPP_READ_ADDR:
  1462. if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
  1463. struct ParallelIOArg *parg = arg;
  1464. int n = read(fd, parg->buffer, parg->count);
  1465. if (n != parg->count) {
  1466. return -EIO;
  1467. }
  1468. }
  1469. break;
  1470. case CHR_IOCTL_PP_EPP_READ:
  1471. if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
  1472. struct ParallelIOArg *parg = arg;
  1473. int n = read(fd, parg->buffer, parg->count);
  1474. if (n != parg->count) {
  1475. return -EIO;
  1476. }
  1477. }
  1478. break;
  1479. case CHR_IOCTL_PP_EPP_WRITE_ADDR:
  1480. if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
  1481. struct ParallelIOArg *parg = arg;
  1482. int n = write(fd, parg->buffer, parg->count);
  1483. if (n != parg->count) {
  1484. return -EIO;
  1485. }
  1486. }
  1487. break;
  1488. case CHR_IOCTL_PP_EPP_WRITE:
  1489. if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
  1490. struct ParallelIOArg *parg = arg;
  1491. int n = write(fd, parg->buffer, parg->count);
  1492. if (n != parg->count) {
  1493. return -EIO;
  1494. }
  1495. }
  1496. break;
  1497. default:
  1498. return -ENOTSUP;
  1499. }
  1500. return 0;
  1501. }
  1502. static void pp_close(CharDriverState *chr)
  1503. {
  1504. ParallelCharDriver *drv = chr->opaque;
  1505. int fd = drv->fd;
  1506. pp_hw_mode(drv, IEEE1284_MODE_COMPAT);
  1507. ioctl(fd, PPRELEASE);
  1508. close(fd);
  1509. g_free(drv);
  1510. qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
  1511. }
  1512. static CharDriverState *qemu_chr_open_pp_fd(int fd,
  1513. ChardevCommon *backend,
  1514. Error **errp)
  1515. {
  1516. CharDriverState *chr;
  1517. ParallelCharDriver *drv;
  1518. if (ioctl(fd, PPCLAIM) < 0) {
  1519. error_setg_errno(errp, errno, "not a parallel port");
  1520. close(fd);
  1521. return NULL;
  1522. }
  1523. chr = qemu_chr_alloc(backend, errp);
  1524. if (!chr) {
  1525. return NULL;
  1526. }
  1527. drv = g_new0(ParallelCharDriver, 1);
  1528. chr->opaque = drv;
  1529. chr->chr_write = null_chr_write;
  1530. chr->chr_ioctl = pp_ioctl;
  1531. chr->chr_close = pp_close;
  1532. drv->fd = fd;
  1533. drv->mode = IEEE1284_MODE_COMPAT;
  1534. return chr;
  1535. }
  1536. #endif /* __linux__ */
  1537. #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
  1538. #define HAVE_CHARDEV_PARPORT 1
  1539. static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
  1540. {
  1541. int fd = (int)(intptr_t)chr->opaque;
  1542. uint8_t b;
  1543. switch(cmd) {
  1544. case CHR_IOCTL_PP_READ_DATA:
  1545. if (ioctl(fd, PPIGDATA, &b) < 0)
  1546. return -ENOTSUP;
  1547. *(uint8_t *)arg = b;
  1548. break;
  1549. case CHR_IOCTL_PP_WRITE_DATA:
  1550. b = *(uint8_t *)arg;
  1551. if (ioctl(fd, PPISDATA, &b) < 0)
  1552. return -ENOTSUP;
  1553. break;
  1554. case CHR_IOCTL_PP_READ_CONTROL:
  1555. if (ioctl(fd, PPIGCTRL, &b) < 0)
  1556. return -ENOTSUP;
  1557. *(uint8_t *)arg = b;
  1558. break;
  1559. case CHR_IOCTL_PP_WRITE_CONTROL:
  1560. b = *(uint8_t *)arg;
  1561. if (ioctl(fd, PPISCTRL, &b) < 0)
  1562. return -ENOTSUP;
  1563. break;
  1564. case CHR_IOCTL_PP_READ_STATUS:
  1565. if (ioctl(fd, PPIGSTATUS, &b) < 0)
  1566. return -ENOTSUP;
  1567. *(uint8_t *)arg = b;
  1568. break;
  1569. default:
  1570. return -ENOTSUP;
  1571. }
  1572. return 0;
  1573. }
  1574. static CharDriverState *qemu_chr_open_pp_fd(int fd,
  1575. ChardevBackend *backend,
  1576. Error **errp)
  1577. {
  1578. CharDriverState *chr;
  1579. chr = qemu_chr_alloc(common, errp);
  1580. if (!chr) {
  1581. return NULL;
  1582. }
  1583. chr->opaque = (void *)(intptr_t)fd;
  1584. chr->chr_write = null_chr_write;
  1585. chr->chr_ioctl = pp_ioctl;
  1586. chr->explicit_be_open = true;
  1587. return chr;
  1588. }
  1589. #endif
  1590. #else /* _WIN32 */
  1591. #define HAVE_CHARDEV_SERIAL 1
  1592. typedef struct {
  1593. int max_size;
  1594. HANDLE hcom, hrecv, hsend;
  1595. OVERLAPPED orecv;
  1596. BOOL fpipe;
  1597. DWORD len;
  1598. /* Protected by the CharDriverState chr_write_lock. */
  1599. OVERLAPPED osend;
  1600. } WinCharState;
  1601. typedef struct {
  1602. HANDLE hStdIn;
  1603. HANDLE hInputReadyEvent;
  1604. HANDLE hInputDoneEvent;
  1605. HANDLE hInputThread;
  1606. uint8_t win_stdio_buf;
  1607. } WinStdioCharState;
  1608. #define NSENDBUF 2048
  1609. #define NRECVBUF 2048
  1610. #define MAXCONNECT 1
  1611. #define NTIMEOUT 5000
  1612. static int win_chr_poll(void *opaque);
  1613. static int win_chr_pipe_poll(void *opaque);
  1614. static void win_chr_close(CharDriverState *chr)
  1615. {
  1616. WinCharState *s = chr->opaque;
  1617. if (s->hsend) {
  1618. CloseHandle(s->hsend);
  1619. s->hsend = NULL;
  1620. }
  1621. if (s->hrecv) {
  1622. CloseHandle(s->hrecv);
  1623. s->hrecv = NULL;
  1624. }
  1625. if (s->hcom) {
  1626. CloseHandle(s->hcom);
  1627. s->hcom = NULL;
  1628. }
  1629. if (s->fpipe)
  1630. qemu_del_polling_cb(win_chr_pipe_poll, chr);
  1631. else
  1632. qemu_del_polling_cb(win_chr_poll, chr);
  1633. qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
  1634. }
  1635. static int win_chr_init(CharDriverState *chr, const char *filename, Error **errp)
  1636. {
  1637. WinCharState *s = chr->opaque;
  1638. COMMCONFIG comcfg;
  1639. COMMTIMEOUTS cto = { 0, 0, 0, 0, 0};
  1640. COMSTAT comstat;
  1641. DWORD size;
  1642. DWORD err;
  1643. s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
  1644. if (!s->hsend) {
  1645. error_setg(errp, "Failed CreateEvent");
  1646. goto fail;
  1647. }
  1648. s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
  1649. if (!s->hrecv) {
  1650. error_setg(errp, "Failed CreateEvent");
  1651. goto fail;
  1652. }
  1653. s->hcom = CreateFile(filename, GENERIC_READ|GENERIC_WRITE, 0, NULL,
  1654. OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
  1655. if (s->hcom == INVALID_HANDLE_VALUE) {
  1656. error_setg(errp, "Failed CreateFile (%lu)", GetLastError());
  1657. s->hcom = NULL;
  1658. goto fail;
  1659. }
  1660. if (!SetupComm(s->hcom, NRECVBUF, NSENDBUF)) {
  1661. error_setg(errp, "Failed SetupComm");
  1662. goto fail;
  1663. }
  1664. ZeroMemory(&comcfg, sizeof(COMMCONFIG));
  1665. size = sizeof(COMMCONFIG);
  1666. GetDefaultCommConfig(filename, &comcfg, &size);
  1667. comcfg.dcb.DCBlength = sizeof(DCB);
  1668. CommConfigDialog(filename, NULL, &comcfg);
  1669. if (!SetCommState(s->hcom, &comcfg.dcb)) {
  1670. error_setg(errp, "Failed SetCommState");
  1671. goto fail;
  1672. }
  1673. if (!SetCommMask(s->hcom, EV_ERR)) {
  1674. error_setg(errp, "Failed SetCommMask");
  1675. goto fail;
  1676. }
  1677. cto.ReadIntervalTimeout = MAXDWORD;
  1678. if (!SetCommTimeouts(s->hcom, &cto)) {
  1679. error_setg(errp, "Failed SetCommTimeouts");
  1680. goto fail;
  1681. }
  1682. if (!ClearCommError(s->hcom, &err, &comstat)) {
  1683. error_setg(errp, "Failed ClearCommError");
  1684. goto fail;
  1685. }
  1686. qemu_add_polling_cb(win_chr_poll, chr);
  1687. return 0;
  1688. fail:
  1689. win_chr_close(chr);
  1690. return -1;
  1691. }
  1692. /* Called with chr_write_lock held. */
  1693. static int win_chr_write(CharDriverState *chr, const uint8_t *buf, int len1)
  1694. {
  1695. WinCharState *s = chr->opaque;
  1696. DWORD len, ret, size, err;
  1697. len = len1;
  1698. ZeroMemory(&s->osend, sizeof(s->osend));
  1699. s->osend.hEvent = s->hsend;
  1700. while (len > 0) {
  1701. if (s->hsend)
  1702. ret = WriteFile(s->hcom, buf, len, &size, &s->osend);
  1703. else
  1704. ret = WriteFile(s->hcom, buf, len, &size, NULL);
  1705. if (!ret) {
  1706. err = GetLastError();
  1707. if (err == ERROR_IO_PENDING) {
  1708. ret = GetOverlappedResult(s->hcom, &s->osend, &size, TRUE);
  1709. if (ret) {
  1710. buf += size;
  1711. len -= size;
  1712. } else {
  1713. break;
  1714. }
  1715. } else {
  1716. break;
  1717. }
  1718. } else {
  1719. buf += size;
  1720. len -= size;
  1721. }
  1722. }
  1723. return len1 - len;
  1724. }
  1725. static int win_chr_read_poll(CharDriverState *chr)
  1726. {
  1727. WinCharState *s = chr->opaque;
  1728. s->max_size = qemu_chr_be_can_write(chr);
  1729. return s->max_size;
  1730. }
  1731. static void win_chr_readfile(CharDriverState *chr)
  1732. {
  1733. WinCharState *s = chr->opaque;
  1734. int ret, err;
  1735. uint8_t buf[READ_BUF_LEN];
  1736. DWORD size;
  1737. ZeroMemory(&s->orecv, sizeof(s->orecv));
  1738. s->orecv.hEvent = s->hrecv;
  1739. ret = ReadFile(s->hcom, buf, s->len, &size, &s->orecv);
  1740. if (!ret) {
  1741. err = GetLastError();
  1742. if (err == ERROR_IO_PENDING) {
  1743. ret = GetOverlappedResult(s->hcom, &s->orecv, &size, TRUE);
  1744. }
  1745. }
  1746. if (size > 0) {
  1747. qemu_chr_be_write(chr, buf, size);
  1748. }
  1749. }
  1750. static void win_chr_read(CharDriverState *chr)
  1751. {
  1752. WinCharState *s = chr->opaque;
  1753. if (s->len > s->max_size)
  1754. s->len = s->max_size;
  1755. if (s->len == 0)
  1756. return;
  1757. win_chr_readfile(chr);
  1758. }
  1759. static int win_chr_poll(void *opaque)
  1760. {
  1761. CharDriverState *chr = opaque;
  1762. WinCharState *s = chr->opaque;
  1763. COMSTAT status;
  1764. DWORD comerr;
  1765. ClearCommError(s->hcom, &comerr, &status);
  1766. if (status.cbInQue > 0) {
  1767. s->len = status.cbInQue;
  1768. win_chr_read_poll(chr);
  1769. win_chr_read(chr);
  1770. return 1;
  1771. }
  1772. return 0;
  1773. }
  1774. static CharDriverState *qemu_chr_open_win_path(const char *filename,
  1775. ChardevCommon *backend,
  1776. Error **errp)
  1777. {
  1778. CharDriverState *chr;
  1779. WinCharState *s;
  1780. chr = qemu_chr_alloc(backend, errp);
  1781. if (!chr) {
  1782. return NULL;
  1783. }
  1784. s = g_new0(WinCharState, 1);
  1785. chr->opaque = s;
  1786. chr->chr_write = win_chr_write;
  1787. chr->chr_close = win_chr_close;
  1788. if (win_chr_init(chr, filename, errp) < 0) {
  1789. g_free(s);
  1790. qemu_chr_free_common(chr);
  1791. return NULL;
  1792. }
  1793. return chr;
  1794. }
  1795. static int win_chr_pipe_poll(void *opaque)
  1796. {
  1797. CharDriverState *chr = opaque;
  1798. WinCharState *s = chr->opaque;
  1799. DWORD size;
  1800. PeekNamedPipe(s->hcom, NULL, 0, NULL, &size, NULL);
  1801. if (size > 0) {
  1802. s->len = size;
  1803. win_chr_read_poll(chr);
  1804. win_chr_read(chr);
  1805. return 1;
  1806. }
  1807. return 0;
  1808. }
  1809. static int win_chr_pipe_init(CharDriverState *chr, const char *filename,
  1810. Error **errp)
  1811. {
  1812. WinCharState *s = chr->opaque;
  1813. OVERLAPPED ov;
  1814. int ret;
  1815. DWORD size;
  1816. char *openname;
  1817. s->fpipe = TRUE;
  1818. s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
  1819. if (!s->hsend) {
  1820. error_setg(errp, "Failed CreateEvent");
  1821. goto fail;
  1822. }
  1823. s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
  1824. if (!s->hrecv) {
  1825. error_setg(errp, "Failed CreateEvent");
  1826. goto fail;
  1827. }
  1828. openname = g_strdup_printf("\\\\.\\pipe\\%s", filename);
  1829. s->hcom = CreateNamedPipe(openname, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
  1830. PIPE_TYPE_BYTE | PIPE_READMODE_BYTE |
  1831. PIPE_WAIT,
  1832. MAXCONNECT, NSENDBUF, NRECVBUF, NTIMEOUT, NULL);
  1833. g_free(openname);
  1834. if (s->hcom == INVALID_HANDLE_VALUE) {
  1835. error_setg(errp, "Failed CreateNamedPipe (%lu)", GetLastError());
  1836. s->hcom = NULL;
  1837. goto fail;
  1838. }
  1839. ZeroMemory(&ov, sizeof(ov));
  1840. ov.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
  1841. ret = ConnectNamedPipe(s->hcom, &ov);
  1842. if (ret) {
  1843. error_setg(errp, "Failed ConnectNamedPipe");
  1844. goto fail;
  1845. }
  1846. ret = GetOverlappedResult(s->hcom, &ov, &size, TRUE);
  1847. if (!ret) {
  1848. error_setg(errp, "Failed GetOverlappedResult");
  1849. if (ov.hEvent) {
  1850. CloseHandle(ov.hEvent);
  1851. ov.hEvent = NULL;
  1852. }
  1853. goto fail;
  1854. }
  1855. if (ov.hEvent) {
  1856. CloseHandle(ov.hEvent);
  1857. ov.hEvent = NULL;
  1858. }
  1859. qemu_add_polling_cb(win_chr_pipe_poll, chr);
  1860. return 0;
  1861. fail:
  1862. win_chr_close(chr);
  1863. return -1;
  1864. }
  1865. static CharDriverState *qemu_chr_open_pipe(const char *id,
  1866. ChardevBackend *backend,
  1867. ChardevReturn *ret,
  1868. Error **errp)
  1869. {
  1870. ChardevHostdev *opts = backend->u.pipe;
  1871. const char *filename = opts->device;
  1872. CharDriverState *chr;
  1873. WinCharState *s;
  1874. ChardevCommon *common = qapi_ChardevHostdev_base(backend->u.pipe);
  1875. chr = qemu_chr_alloc(common, errp);
  1876. if (!chr) {
  1877. return NULL;
  1878. }
  1879. s = g_new0(WinCharState, 1);
  1880. chr->opaque = s;
  1881. chr->chr_write = win_chr_write;
  1882. chr->chr_close = win_chr_close;
  1883. if (win_chr_pipe_init(chr, filename, errp) < 0) {
  1884. g_free(s);
  1885. qemu_chr_free_common(chr);
  1886. return NULL;
  1887. }
  1888. return chr;
  1889. }
  1890. static CharDriverState *qemu_chr_open_win_file(HANDLE fd_out,
  1891. ChardevCommon *backend,
  1892. Error **errp)
  1893. {
  1894. CharDriverState *chr;
  1895. WinCharState *s;
  1896. chr = qemu_chr_alloc(backend, errp);
  1897. if (!chr) {
  1898. return NULL;
  1899. }
  1900. s = g_new0(WinCharState, 1);
  1901. s->hcom = fd_out;
  1902. chr->opaque = s;
  1903. chr->chr_write = win_chr_write;
  1904. return chr;
  1905. }
  1906. static CharDriverState *qemu_chr_open_win_con(const char *id,
  1907. ChardevBackend *backend,
  1908. ChardevReturn *ret,
  1909. Error **errp)
  1910. {
  1911. ChardevCommon *common = qapi_ChardevDummy_base(backend->u.console);
  1912. return qemu_chr_open_win_file(GetStdHandle(STD_OUTPUT_HANDLE),
  1913. common, errp);
  1914. }
  1915. static int win_stdio_write(CharDriverState *chr, const uint8_t *buf, int len)
  1916. {
  1917. HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
  1918. DWORD dwSize;
  1919. int len1;
  1920. len1 = len;
  1921. while (len1 > 0) {
  1922. if (!WriteFile(hStdOut, buf, len1, &dwSize, NULL)) {
  1923. break;
  1924. }
  1925. buf += dwSize;
  1926. len1 -= dwSize;
  1927. }
  1928. return len - len1;
  1929. }
  1930. static void win_stdio_wait_func(void *opaque)
  1931. {
  1932. CharDriverState *chr = opaque;
  1933. WinStdioCharState *stdio = chr->opaque;
  1934. INPUT_RECORD buf[4];
  1935. int ret;
  1936. DWORD dwSize;
  1937. int i;
  1938. ret = ReadConsoleInput(stdio->hStdIn, buf, ARRAY_SIZE(buf), &dwSize);
  1939. if (!ret) {
  1940. /* Avoid error storm */
  1941. qemu_del_wait_object(stdio->hStdIn, NULL, NULL);
  1942. return;
  1943. }
  1944. for (i = 0; i < dwSize; i++) {
  1945. KEY_EVENT_RECORD *kev = &buf[i].Event.KeyEvent;
  1946. if (buf[i].EventType == KEY_EVENT && kev->bKeyDown) {
  1947. int j;
  1948. if (kev->uChar.AsciiChar != 0) {
  1949. for (j = 0; j < kev->wRepeatCount; j++) {
  1950. if (qemu_chr_be_can_write(chr)) {
  1951. uint8_t c = kev->uChar.AsciiChar;
  1952. qemu_chr_be_write(chr, &c, 1);
  1953. }
  1954. }
  1955. }
  1956. }
  1957. }
  1958. }
  1959. static DWORD WINAPI win_stdio_thread(LPVOID param)
  1960. {
  1961. CharDriverState *chr = param;
  1962. WinStdioCharState *stdio = chr->opaque;
  1963. int ret;
  1964. DWORD dwSize;
  1965. while (1) {
  1966. /* Wait for one byte */
  1967. ret = ReadFile(stdio->hStdIn, &stdio->win_stdio_buf, 1, &dwSize, NULL);
  1968. /* Exit in case of error, continue if nothing read */
  1969. if (!ret) {
  1970. break;
  1971. }
  1972. if (!dwSize) {
  1973. continue;
  1974. }
  1975. /* Some terminal emulator returns \r\n for Enter, just pass \n */
  1976. if (stdio->win_stdio_buf == '\r') {
  1977. continue;
  1978. }
  1979. /* Signal the main thread and wait until the byte was eaten */
  1980. if (!SetEvent(stdio->hInputReadyEvent)) {
  1981. break;
  1982. }
  1983. if (WaitForSingleObject(stdio->hInputDoneEvent, INFINITE)
  1984. != WAIT_OBJECT_0) {
  1985. break;
  1986. }
  1987. }
  1988. qemu_del_wait_object(stdio->hInputReadyEvent, NULL, NULL);
  1989. return 0;
  1990. }
  1991. static void win_stdio_thread_wait_func(void *opaque)
  1992. {
  1993. CharDriverState *chr = opaque;
  1994. WinStdioCharState *stdio = chr->opaque;
  1995. if (qemu_chr_be_can_write(chr)) {
  1996. qemu_chr_be_write(chr, &stdio->win_stdio_buf, 1);
  1997. }
  1998. SetEvent(stdio->hInputDoneEvent);
  1999. }
  2000. static void qemu_chr_set_echo_win_stdio(CharDriverState *chr, bool echo)
  2001. {
  2002. WinStdioCharState *stdio = chr->opaque;
  2003. DWORD dwMode = 0;
  2004. GetConsoleMode(stdio->hStdIn, &dwMode);
  2005. if (echo) {
  2006. SetConsoleMode(stdio->hStdIn, dwMode | ENABLE_ECHO_INPUT);
  2007. } else {
  2008. SetConsoleMode(stdio->hStdIn, dwMode & ~ENABLE_ECHO_INPUT);
  2009. }
  2010. }
  2011. static void win_stdio_close(CharDriverState *chr)
  2012. {
  2013. WinStdioCharState *stdio = chr->opaque;
  2014. if (stdio->hInputReadyEvent != INVALID_HANDLE_VALUE) {
  2015. CloseHandle(stdio->hInputReadyEvent);
  2016. }
  2017. if (stdio->hInputDoneEvent != INVALID_HANDLE_VALUE) {
  2018. CloseHandle(stdio->hInputDoneEvent);
  2019. }
  2020. if (stdio->hInputThread != INVALID_HANDLE_VALUE) {
  2021. TerminateThread(stdio->hInputThread, 0);
  2022. }
  2023. g_free(chr->opaque);
  2024. g_free(chr);
  2025. }
  2026. static CharDriverState *qemu_chr_open_stdio(const char *id,
  2027. ChardevBackend *backend,
  2028. ChardevReturn *ret,
  2029. Error **errp)
  2030. {
  2031. CharDriverState *chr;
  2032. WinStdioCharState *stdio;
  2033. DWORD dwMode;
  2034. int is_console = 0;
  2035. ChardevCommon *common = qapi_ChardevStdio_base(backend->u.stdio);
  2036. chr = qemu_chr_alloc(common, errp);
  2037. if (!chr) {
  2038. return NULL;
  2039. }
  2040. stdio = g_new0(WinStdioCharState, 1);
  2041. stdio->hStdIn = GetStdHandle(STD_INPUT_HANDLE);
  2042. if (stdio->hStdIn == INVALID_HANDLE_VALUE) {
  2043. error_setg(errp, "cannot open stdio: invalid handle");
  2044. return NULL;
  2045. }
  2046. is_console = GetConsoleMode(stdio->hStdIn, &dwMode) != 0;
  2047. chr->opaque = stdio;
  2048. chr->chr_write = win_stdio_write;
  2049. chr->chr_close = win_stdio_close;
  2050. if (is_console) {
  2051. if (qemu_add_wait_object(stdio->hStdIn,
  2052. win_stdio_wait_func, chr)) {
  2053. error_setg(errp, "qemu_add_wait_object: failed");
  2054. goto err1;
  2055. }
  2056. } else {
  2057. DWORD dwId;
  2058. stdio->hInputReadyEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
  2059. stdio->hInputDoneEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
  2060. if (stdio->hInputReadyEvent == INVALID_HANDLE_VALUE
  2061. || stdio->hInputDoneEvent == INVALID_HANDLE_VALUE) {
  2062. error_setg(errp, "cannot create event");
  2063. goto err2;
  2064. }
  2065. if (qemu_add_wait_object(stdio->hInputReadyEvent,
  2066. win_stdio_thread_wait_func, chr)) {
  2067. error_setg(errp, "qemu_add_wait_object: failed");
  2068. goto err2;
  2069. }
  2070. stdio->hInputThread = CreateThread(NULL, 0, win_stdio_thread,
  2071. chr, 0, &dwId);
  2072. if (stdio->hInputThread == INVALID_HANDLE_VALUE) {
  2073. error_setg(errp, "cannot create stdio thread");
  2074. goto err3;
  2075. }
  2076. }
  2077. dwMode |= ENABLE_LINE_INPUT;
  2078. if (is_console) {
  2079. /* set the terminal in raw mode */
  2080. /* ENABLE_QUICK_EDIT_MODE | ENABLE_EXTENDED_FLAGS */
  2081. dwMode |= ENABLE_PROCESSED_INPUT;
  2082. }
  2083. SetConsoleMode(stdio->hStdIn, dwMode);
  2084. chr->chr_set_echo = qemu_chr_set_echo_win_stdio;
  2085. qemu_chr_fe_set_echo(chr, false);
  2086. return chr;
  2087. err3:
  2088. qemu_del_wait_object(stdio->hInputReadyEvent, NULL, NULL);
  2089. err2:
  2090. CloseHandle(stdio->hInputReadyEvent);
  2091. CloseHandle(stdio->hInputDoneEvent);
  2092. err1:
  2093. qemu_del_wait_object(stdio->hStdIn, NULL, NULL);
  2094. return NULL;
  2095. }
  2096. #endif /* !_WIN32 */
  2097. /***********************************************************/
  2098. /* UDP Net console */
  2099. typedef struct {
  2100. QIOChannel *ioc;
  2101. uint8_t buf[READ_BUF_LEN];
  2102. int bufcnt;
  2103. int bufptr;
  2104. int max_size;
  2105. } NetCharDriver;
  2106. /* Called with chr_write_lock held. */
  2107. static int udp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
  2108. {
  2109. NetCharDriver *s = chr->opaque;
  2110. return qio_channel_write(
  2111. s->ioc, (const char *)buf, len, NULL);
  2112. }
  2113. static int udp_chr_read_poll(void *opaque)
  2114. {
  2115. CharDriverState *chr = opaque;
  2116. NetCharDriver *s = chr->opaque;
  2117. s->max_size = qemu_chr_be_can_write(chr);
  2118. /* If there were any stray characters in the queue process them
  2119. * first
  2120. */
  2121. while (s->max_size > 0 && s->bufptr < s->bufcnt) {
  2122. qemu_chr_be_write(chr, &s->buf[s->bufptr], 1);
  2123. s->bufptr++;
  2124. s->max_size = qemu_chr_be_can_write(chr);
  2125. }
  2126. return s->max_size;
  2127. }
  2128. static gboolean udp_chr_read(QIOChannel *chan, GIOCondition cond, void *opaque)
  2129. {
  2130. CharDriverState *chr = opaque;
  2131. NetCharDriver *s = chr->opaque;
  2132. ssize_t ret;
  2133. if (s->max_size == 0) {
  2134. return TRUE;
  2135. }
  2136. ret = qio_channel_read(
  2137. s->ioc, (char *)s->buf, sizeof(s->buf), NULL);
  2138. if (ret <= 0) {
  2139. remove_fd_in_watch(chr);
  2140. return FALSE;
  2141. }
  2142. s->bufcnt = ret;
  2143. s->bufptr = 0;
  2144. while (s->max_size > 0 && s->bufptr < s->bufcnt) {
  2145. qemu_chr_be_write(chr, &s->buf[s->bufptr], 1);
  2146. s->bufptr++;
  2147. s->max_size = qemu_chr_be_can_write(chr);
  2148. }
  2149. return TRUE;
  2150. }
  2151. static void udp_chr_update_read_handler(CharDriverState *chr)
  2152. {
  2153. NetCharDriver *s = chr->opaque;
  2154. remove_fd_in_watch(chr);
  2155. if (s->ioc) {
  2156. chr->fd_in_tag = io_add_watch_poll(s->ioc,
  2157. udp_chr_read_poll,
  2158. udp_chr_read, chr);
  2159. }
  2160. }
  2161. static void udp_chr_close(CharDriverState *chr)
  2162. {
  2163. NetCharDriver *s = chr->opaque;
  2164. remove_fd_in_watch(chr);
  2165. if (s->ioc) {
  2166. object_unref(OBJECT(s->ioc));
  2167. }
  2168. g_free(s);
  2169. qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
  2170. }
  2171. static CharDriverState *qemu_chr_open_udp(QIOChannelSocket *sioc,
  2172. ChardevCommon *backend,
  2173. Error **errp)
  2174. {
  2175. CharDriverState *chr = NULL;
  2176. NetCharDriver *s = NULL;
  2177. chr = qemu_chr_alloc(backend, errp);
  2178. if (!chr) {
  2179. return NULL;
  2180. }
  2181. s = g_new0(NetCharDriver, 1);
  2182. s->ioc = QIO_CHANNEL(sioc);
  2183. s->bufcnt = 0;
  2184. s->bufptr = 0;
  2185. chr->opaque = s;
  2186. chr->chr_write = udp_chr_write;
  2187. chr->chr_update_read_handler = udp_chr_update_read_handler;
  2188. chr->chr_close = udp_chr_close;
  2189. /* be isn't opened until we get a connection */
  2190. chr->explicit_be_open = true;
  2191. return chr;
  2192. }
  2193. /***********************************************************/
  2194. /* TCP Net console */
  2195. typedef struct {
  2196. QIOChannel *ioc; /* Client I/O channel */
  2197. QIOChannelSocket *sioc; /* Client master channel */
  2198. QIOChannelSocket *listen_ioc;
  2199. guint listen_tag;
  2200. QCryptoTLSCreds *tls_creds;
  2201. int connected;
  2202. int max_size;
  2203. int do_telnetopt;
  2204. int do_nodelay;
  2205. int is_unix;
  2206. int *read_msgfds;
  2207. size_t read_msgfds_num;
  2208. int *write_msgfds;
  2209. size_t write_msgfds_num;
  2210. SocketAddress *addr;
  2211. bool is_listen;
  2212. bool is_telnet;
  2213. guint reconnect_timer;
  2214. int64_t reconnect_time;
  2215. bool connect_err_reported;
  2216. } TCPCharDriver;
  2217. static gboolean socket_reconnect_timeout(gpointer opaque);
  2218. static void qemu_chr_socket_restart_timer(CharDriverState *chr)
  2219. {
  2220. TCPCharDriver *s = chr->opaque;
  2221. assert(s->connected == 0);
  2222. s->reconnect_timer = g_timeout_add_seconds(s->reconnect_time,
  2223. socket_reconnect_timeout, chr);
  2224. }
  2225. static void check_report_connect_error(CharDriverState *chr,
  2226. Error *err)
  2227. {
  2228. TCPCharDriver *s = chr->opaque;
  2229. if (!s->connect_err_reported) {
  2230. error_report("Unable to connect character device %s: %s",
  2231. chr->label, error_get_pretty(err));
  2232. s->connect_err_reported = true;
  2233. }
  2234. qemu_chr_socket_restart_timer(chr);
  2235. }
  2236. static gboolean tcp_chr_accept(QIOChannel *chan,
  2237. GIOCondition cond,
  2238. void *opaque);
  2239. /* Called with chr_write_lock held. */
  2240. static int tcp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
  2241. {
  2242. TCPCharDriver *s = chr->opaque;
  2243. if (s->connected) {
  2244. int ret = io_channel_send_full(s->ioc, buf, len,
  2245. s->write_msgfds,
  2246. s->write_msgfds_num);
  2247. /* free the written msgfds, no matter what */
  2248. if (s->write_msgfds_num) {
  2249. g_free(s->write_msgfds);
  2250. s->write_msgfds = 0;
  2251. s->write_msgfds_num = 0;
  2252. }
  2253. return ret;
  2254. } else {
  2255. /* XXX: indicate an error ? */
  2256. return len;
  2257. }
  2258. }
  2259. static int tcp_chr_read_poll(void *opaque)
  2260. {
  2261. CharDriverState *chr = opaque;
  2262. TCPCharDriver *s = chr->opaque;
  2263. if (!s->connected)
  2264. return 0;
  2265. s->max_size = qemu_chr_be_can_write(chr);
  2266. return s->max_size;
  2267. }
  2268. #define IAC 255
  2269. #define IAC_BREAK 243
  2270. static void tcp_chr_process_IAC_bytes(CharDriverState *chr,
  2271. TCPCharDriver *s,
  2272. uint8_t *buf, int *size)
  2273. {
  2274. /* Handle any telnet client's basic IAC options to satisfy char by
  2275. * char mode with no echo. All IAC options will be removed from
  2276. * the buf and the do_telnetopt variable will be used to track the
  2277. * state of the width of the IAC information.
  2278. *
  2279. * IAC commands come in sets of 3 bytes with the exception of the
  2280. * "IAC BREAK" command and the double IAC.
  2281. */
  2282. int i;
  2283. int j = 0;
  2284. for (i = 0; i < *size; i++) {
  2285. if (s->do_telnetopt > 1) {
  2286. if ((unsigned char)buf[i] == IAC && s->do_telnetopt == 2) {
  2287. /* Double IAC means send an IAC */
  2288. if (j != i)
  2289. buf[j] = buf[i];
  2290. j++;
  2291. s->do_telnetopt = 1;
  2292. } else {
  2293. if ((unsigned char)buf[i] == IAC_BREAK && s->do_telnetopt == 2) {
  2294. /* Handle IAC break commands by sending a serial break */
  2295. qemu_chr_be_event(chr, CHR_EVENT_BREAK);
  2296. s->do_telnetopt++;
  2297. }
  2298. s->do_telnetopt++;
  2299. }
  2300. if (s->do_telnetopt >= 4) {
  2301. s->do_telnetopt = 1;
  2302. }
  2303. } else {
  2304. if ((unsigned char)buf[i] == IAC) {
  2305. s->do_telnetopt = 2;
  2306. } else {
  2307. if (j != i)
  2308. buf[j] = buf[i];
  2309. j++;
  2310. }
  2311. }
  2312. }
  2313. *size = j;
  2314. }
  2315. static int tcp_get_msgfds(CharDriverState *chr, int *fds, int num)
  2316. {
  2317. TCPCharDriver *s = chr->opaque;
  2318. int to_copy = (s->read_msgfds_num < num) ? s->read_msgfds_num : num;
  2319. assert(num <= TCP_MAX_FDS);
  2320. if (to_copy) {
  2321. int i;
  2322. memcpy(fds, s->read_msgfds, to_copy * sizeof(int));
  2323. /* Close unused fds */
  2324. for (i = to_copy; i < s->read_msgfds_num; i++) {
  2325. close(s->read_msgfds[i]);
  2326. }
  2327. g_free(s->read_msgfds);
  2328. s->read_msgfds = 0;
  2329. s->read_msgfds_num = 0;
  2330. }
  2331. return to_copy;
  2332. }
  2333. static int tcp_set_msgfds(CharDriverState *chr, int *fds, int num)
  2334. {
  2335. TCPCharDriver *s = chr->opaque;
  2336. if (!qio_channel_has_feature(s->ioc,
  2337. QIO_CHANNEL_FEATURE_FD_PASS)) {
  2338. return -1;
  2339. }
  2340. /* clear old pending fd array */
  2341. g_free(s->write_msgfds);
  2342. if (num) {
  2343. s->write_msgfds = g_new(int, num);
  2344. memcpy(s->write_msgfds, fds, num * sizeof(int));
  2345. }
  2346. s->write_msgfds_num = num;
  2347. return 0;
  2348. }
  2349. static ssize_t tcp_chr_recv(CharDriverState *chr, char *buf, size_t len)
  2350. {
  2351. TCPCharDriver *s = chr->opaque;
  2352. struct iovec iov = { .iov_base = buf, .iov_len = len };
  2353. int ret;
  2354. size_t i;
  2355. int *msgfds = NULL;
  2356. size_t msgfds_num = 0;
  2357. if (qio_channel_has_feature(s->ioc, QIO_CHANNEL_FEATURE_FD_PASS)) {
  2358. ret = qio_channel_readv_full(s->ioc, &iov, 1,
  2359. &msgfds, &msgfds_num,
  2360. NULL);
  2361. } else {
  2362. ret = qio_channel_readv_full(s->ioc, &iov, 1,
  2363. NULL, NULL,
  2364. NULL);
  2365. }
  2366. if (msgfds_num) {
  2367. /* close and clean read_msgfds */
  2368. for (i = 0; i < s->read_msgfds_num; i++) {
  2369. close(s->read_msgfds[i]);
  2370. }
  2371. if (s->read_msgfds_num) {
  2372. g_free(s->read_msgfds);
  2373. }
  2374. s->read_msgfds = msgfds;
  2375. s->read_msgfds_num = msgfds_num;
  2376. }
  2377. for (i = 0; i < s->read_msgfds_num; i++) {
  2378. int fd = s->read_msgfds[i];
  2379. if (fd < 0) {
  2380. continue;
  2381. }
  2382. /* O_NONBLOCK is preserved across SCM_RIGHTS so reset it */
  2383. qemu_set_block(fd);
  2384. #ifndef MSG_CMSG_CLOEXEC
  2385. qemu_set_cloexec(fd);
  2386. #endif
  2387. }
  2388. return ret;
  2389. }
  2390. static GSource *tcp_chr_add_watch(CharDriverState *chr, GIOCondition cond)
  2391. {
  2392. TCPCharDriver *s = chr->opaque;
  2393. return qio_channel_create_watch(s->ioc, cond);
  2394. }
  2395. static void tcp_chr_disconnect(CharDriverState *chr)
  2396. {
  2397. TCPCharDriver *s = chr->opaque;
  2398. s->connected = 0;
  2399. if (s->listen_ioc) {
  2400. s->listen_tag = qio_channel_add_watch(
  2401. QIO_CHANNEL(s->listen_ioc), G_IO_IN, tcp_chr_accept, chr, NULL);
  2402. }
  2403. remove_fd_in_watch(chr);
  2404. object_unref(OBJECT(s->sioc));
  2405. s->sioc = NULL;
  2406. object_unref(OBJECT(s->ioc));
  2407. s->ioc = NULL;
  2408. g_free(chr->filename);
  2409. chr->filename = SocketAddress_to_str("disconnected:", s->addr,
  2410. s->is_listen, s->is_telnet);
  2411. qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
  2412. if (s->reconnect_time) {
  2413. qemu_chr_socket_restart_timer(chr);
  2414. }
  2415. }
  2416. static gboolean tcp_chr_read(QIOChannel *chan, GIOCondition cond, void *opaque)
  2417. {
  2418. CharDriverState *chr = opaque;
  2419. TCPCharDriver *s = chr->opaque;
  2420. uint8_t buf[READ_BUF_LEN];
  2421. int len, size;
  2422. if (!s->connected || s->max_size <= 0) {
  2423. return TRUE;
  2424. }
  2425. len = sizeof(buf);
  2426. if (len > s->max_size)
  2427. len = s->max_size;
  2428. size = tcp_chr_recv(chr, (void *)buf, len);
  2429. if (size == 0 || size == -1) {
  2430. /* connection closed */
  2431. tcp_chr_disconnect(chr);
  2432. } else if (size > 0) {
  2433. if (s->do_telnetopt)
  2434. tcp_chr_process_IAC_bytes(chr, s, buf, &size);
  2435. if (size > 0)
  2436. qemu_chr_be_write(chr, buf, size);
  2437. }
  2438. return TRUE;
  2439. }
  2440. static int tcp_chr_sync_read(CharDriverState *chr, const uint8_t *buf, int len)
  2441. {
  2442. TCPCharDriver *s = chr->opaque;
  2443. int size;
  2444. if (!s->connected) {
  2445. return 0;
  2446. }
  2447. size = tcp_chr_recv(chr, (void *) buf, len);
  2448. if (size == 0) {
  2449. /* connection closed */
  2450. tcp_chr_disconnect(chr);
  2451. }
  2452. return size;
  2453. }
  2454. static void tcp_chr_connect(void *opaque)
  2455. {
  2456. CharDriverState *chr = opaque;
  2457. TCPCharDriver *s = chr->opaque;
  2458. g_free(chr->filename);
  2459. chr->filename = sockaddr_to_str(
  2460. &s->sioc->localAddr, s->sioc->localAddrLen,
  2461. &s->sioc->remoteAddr, s->sioc->remoteAddrLen,
  2462. s->is_listen, s->is_telnet);
  2463. s->connected = 1;
  2464. if (s->ioc) {
  2465. chr->fd_in_tag = io_add_watch_poll(s->ioc,
  2466. tcp_chr_read_poll,
  2467. tcp_chr_read, chr);
  2468. }
  2469. qemu_chr_be_generic_open(chr);
  2470. }
  2471. static void tcp_chr_update_read_handler(CharDriverState *chr)
  2472. {
  2473. TCPCharDriver *s = chr->opaque;
  2474. remove_fd_in_watch(chr);
  2475. if (s->ioc) {
  2476. chr->fd_in_tag = io_add_watch_poll(s->ioc,
  2477. tcp_chr_read_poll,
  2478. tcp_chr_read, chr);
  2479. }
  2480. }
  2481. typedef struct {
  2482. CharDriverState *chr;
  2483. char buf[12];
  2484. size_t buflen;
  2485. } TCPCharDriverTelnetInit;
  2486. static gboolean tcp_chr_telnet_init_io(QIOChannel *ioc,
  2487. GIOCondition cond G_GNUC_UNUSED,
  2488. gpointer user_data)
  2489. {
  2490. TCPCharDriverTelnetInit *init = user_data;
  2491. ssize_t ret;
  2492. ret = qio_channel_write(ioc, init->buf, init->buflen, NULL);
  2493. if (ret < 0) {
  2494. if (ret == QIO_CHANNEL_ERR_BLOCK) {
  2495. ret = 0;
  2496. } else {
  2497. tcp_chr_disconnect(init->chr);
  2498. return FALSE;
  2499. }
  2500. }
  2501. init->buflen -= ret;
  2502. if (init->buflen == 0) {
  2503. tcp_chr_connect(init->chr);
  2504. return FALSE;
  2505. }
  2506. memmove(init->buf, init->buf + ret, init->buflen);
  2507. return TRUE;
  2508. }
  2509. static void tcp_chr_telnet_init(CharDriverState *chr)
  2510. {
  2511. TCPCharDriver *s = chr->opaque;
  2512. TCPCharDriverTelnetInit *init =
  2513. g_new0(TCPCharDriverTelnetInit, 1);
  2514. size_t n = 0;
  2515. init->chr = chr;
  2516. init->buflen = 12;
  2517. #define IACSET(x, a, b, c) \
  2518. do { \
  2519. x[n++] = a; \
  2520. x[n++] = b; \
  2521. x[n++] = c; \
  2522. } while (0)
  2523. /* Prep the telnet negotion to put telnet in binary,
  2524. * no echo, single char mode */
  2525. IACSET(init->buf, 0xff, 0xfb, 0x01); /* IAC WILL ECHO */
  2526. IACSET(init->buf, 0xff, 0xfb, 0x03); /* IAC WILL Suppress go ahead */
  2527. IACSET(init->buf, 0xff, 0xfb, 0x00); /* IAC WILL Binary */
  2528. IACSET(init->buf, 0xff, 0xfd, 0x00); /* IAC DO Binary */
  2529. #undef IACSET
  2530. qio_channel_add_watch(
  2531. s->ioc, G_IO_OUT,
  2532. tcp_chr_telnet_init_io,
  2533. init, NULL);
  2534. }
  2535. static void tcp_chr_tls_handshake(Object *source,
  2536. Error *err,
  2537. gpointer user_data)
  2538. {
  2539. CharDriverState *chr = user_data;
  2540. TCPCharDriver *s = chr->opaque;
  2541. if (err) {
  2542. tcp_chr_disconnect(chr);
  2543. } else {
  2544. if (s->do_telnetopt) {
  2545. tcp_chr_telnet_init(chr);
  2546. } else {
  2547. tcp_chr_connect(chr);
  2548. }
  2549. }
  2550. }
  2551. static void tcp_chr_tls_init(CharDriverState *chr)
  2552. {
  2553. TCPCharDriver *s = chr->opaque;
  2554. QIOChannelTLS *tioc;
  2555. Error *err = NULL;
  2556. if (s->is_listen) {
  2557. tioc = qio_channel_tls_new_server(
  2558. s->ioc, s->tls_creds,
  2559. NULL, /* XXX Use an ACL */
  2560. &err);
  2561. } else {
  2562. tioc = qio_channel_tls_new_client(
  2563. s->ioc, s->tls_creds,
  2564. s->addr->u.inet->host,
  2565. &err);
  2566. }
  2567. if (tioc == NULL) {
  2568. error_free(err);
  2569. tcp_chr_disconnect(chr);
  2570. }
  2571. object_unref(OBJECT(s->ioc));
  2572. s->ioc = QIO_CHANNEL(tioc);
  2573. qio_channel_tls_handshake(tioc,
  2574. tcp_chr_tls_handshake,
  2575. chr,
  2576. NULL);
  2577. }
  2578. static int tcp_chr_new_client(CharDriverState *chr, QIOChannelSocket *sioc)
  2579. {
  2580. TCPCharDriver *s = chr->opaque;
  2581. if (s->ioc != NULL) {
  2582. return -1;
  2583. }
  2584. s->ioc = QIO_CHANNEL(sioc);
  2585. object_ref(OBJECT(sioc));
  2586. s->sioc = sioc;
  2587. object_ref(OBJECT(sioc));
  2588. if (s->do_nodelay) {
  2589. qio_channel_set_delay(s->ioc, false);
  2590. }
  2591. if (s->listen_tag) {
  2592. g_source_remove(s->listen_tag);
  2593. s->listen_tag = 0;
  2594. }
  2595. if (s->tls_creds) {
  2596. tcp_chr_tls_init(chr);
  2597. } else {
  2598. if (s->do_telnetopt) {
  2599. tcp_chr_telnet_init(chr);
  2600. } else {
  2601. tcp_chr_connect(chr);
  2602. }
  2603. }
  2604. return 0;
  2605. }
  2606. static int tcp_chr_add_client(CharDriverState *chr, int fd)
  2607. {
  2608. int ret;
  2609. QIOChannelSocket *sioc;
  2610. sioc = qio_channel_socket_new_fd(fd, NULL);
  2611. if (!sioc) {
  2612. return -1;
  2613. }
  2614. qio_channel_set_blocking(QIO_CHANNEL(sioc), false, NULL);
  2615. ret = tcp_chr_new_client(chr, sioc);
  2616. object_unref(OBJECT(sioc));
  2617. return ret;
  2618. }
  2619. static gboolean tcp_chr_accept(QIOChannel *channel,
  2620. GIOCondition cond,
  2621. void *opaque)
  2622. {
  2623. CharDriverState *chr = opaque;
  2624. QIOChannelSocket *sioc;
  2625. sioc = qio_channel_socket_accept(QIO_CHANNEL_SOCKET(channel),
  2626. NULL);
  2627. if (!sioc) {
  2628. return TRUE;
  2629. }
  2630. tcp_chr_new_client(chr, sioc);
  2631. object_unref(OBJECT(sioc));
  2632. return TRUE;
  2633. }
  2634. static void tcp_chr_close(CharDriverState *chr)
  2635. {
  2636. TCPCharDriver *s = chr->opaque;
  2637. int i;
  2638. if (s->reconnect_timer) {
  2639. g_source_remove(s->reconnect_timer);
  2640. s->reconnect_timer = 0;
  2641. }
  2642. qapi_free_SocketAddress(s->addr);
  2643. remove_fd_in_watch(chr);
  2644. if (s->ioc) {
  2645. object_unref(OBJECT(s->ioc));
  2646. }
  2647. if (s->listen_tag) {
  2648. g_source_remove(s->listen_tag);
  2649. s->listen_tag = 0;
  2650. }
  2651. if (s->listen_ioc) {
  2652. object_unref(OBJECT(s->listen_ioc));
  2653. }
  2654. if (s->read_msgfds_num) {
  2655. for (i = 0; i < s->read_msgfds_num; i++) {
  2656. close(s->read_msgfds[i]);
  2657. }
  2658. g_free(s->read_msgfds);
  2659. }
  2660. if (s->tls_creds) {
  2661. object_unref(OBJECT(s->tls_creds));
  2662. }
  2663. if (s->write_msgfds_num) {
  2664. g_free(s->write_msgfds);
  2665. }
  2666. g_free(s);
  2667. qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
  2668. }
  2669. static void qemu_chr_finish_socket_connection(CharDriverState *chr,
  2670. QIOChannelSocket *sioc)
  2671. {
  2672. TCPCharDriver *s = chr->opaque;
  2673. if (s->is_listen) {
  2674. s->listen_ioc = sioc;
  2675. s->listen_tag = qio_channel_add_watch(
  2676. QIO_CHANNEL(s->listen_ioc), G_IO_IN, tcp_chr_accept, chr, NULL);
  2677. } else {
  2678. tcp_chr_new_client(chr, sioc);
  2679. object_unref(OBJECT(sioc));
  2680. }
  2681. }
  2682. static void qemu_chr_socket_connected(Object *src, Error *err, void *opaque)
  2683. {
  2684. QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(src);
  2685. CharDriverState *chr = opaque;
  2686. TCPCharDriver *s = chr->opaque;
  2687. if (err) {
  2688. check_report_connect_error(chr, err);
  2689. object_unref(src);
  2690. return;
  2691. }
  2692. s->connect_err_reported = false;
  2693. qemu_chr_finish_socket_connection(chr, sioc);
  2694. }
  2695. static bool qemu_chr_open_socket_fd(CharDriverState *chr, Error **errp)
  2696. {
  2697. TCPCharDriver *s = chr->opaque;
  2698. QIOChannelSocket *sioc = qio_channel_socket_new();
  2699. if (s->is_listen) {
  2700. if (qio_channel_socket_listen_sync(sioc, s->addr, errp) < 0) {
  2701. goto fail;
  2702. }
  2703. qemu_chr_finish_socket_connection(chr, sioc);
  2704. } else if (s->reconnect_time) {
  2705. qio_channel_socket_connect_async(sioc, s->addr,
  2706. qemu_chr_socket_connected,
  2707. chr, NULL);
  2708. } else {
  2709. if (qio_channel_socket_connect_sync(sioc, s->addr, errp) < 0) {
  2710. goto fail;
  2711. }
  2712. qemu_chr_finish_socket_connection(chr, sioc);
  2713. }
  2714. return true;
  2715. fail:
  2716. object_unref(OBJECT(sioc));
  2717. return false;
  2718. }
  2719. /*********************************************************/
  2720. /* Ring buffer chardev */
  2721. typedef struct {
  2722. size_t size;
  2723. size_t prod;
  2724. size_t cons;
  2725. uint8_t *cbuf;
  2726. } RingBufCharDriver;
  2727. static size_t ringbuf_count(const CharDriverState *chr)
  2728. {
  2729. const RingBufCharDriver *d = chr->opaque;
  2730. return d->prod - d->cons;
  2731. }
  2732. /* Called with chr_write_lock held. */
  2733. static int ringbuf_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
  2734. {
  2735. RingBufCharDriver *d = chr->opaque;
  2736. int i;
  2737. if (!buf || (len < 0)) {
  2738. return -1;
  2739. }
  2740. for (i = 0; i < len; i++ ) {
  2741. d->cbuf[d->prod++ & (d->size - 1)] = buf[i];
  2742. if (d->prod - d->cons > d->size) {
  2743. d->cons = d->prod - d->size;
  2744. }
  2745. }
  2746. return 0;
  2747. }
  2748. static int ringbuf_chr_read(CharDriverState *chr, uint8_t *buf, int len)
  2749. {
  2750. RingBufCharDriver *d = chr->opaque;
  2751. int i;
  2752. qemu_mutex_lock(&chr->chr_write_lock);
  2753. for (i = 0; i < len && d->cons != d->prod; i++) {
  2754. buf[i] = d->cbuf[d->cons++ & (d->size - 1)];
  2755. }
  2756. qemu_mutex_unlock(&chr->chr_write_lock);
  2757. return i;
  2758. }
  2759. static void ringbuf_chr_close(struct CharDriverState *chr)
  2760. {
  2761. RingBufCharDriver *d = chr->opaque;
  2762. g_free(d->cbuf);
  2763. g_free(d);
  2764. chr->opaque = NULL;
  2765. }
  2766. static CharDriverState *qemu_chr_open_ringbuf(const char *id,
  2767. ChardevBackend *backend,
  2768. ChardevReturn *ret,
  2769. Error **errp)
  2770. {
  2771. ChardevRingbuf *opts = backend->u.ringbuf;
  2772. ChardevCommon *common = qapi_ChardevRingbuf_base(backend->u.ringbuf);
  2773. CharDriverState *chr;
  2774. RingBufCharDriver *d;
  2775. chr = qemu_chr_alloc(common, errp);
  2776. if (!chr) {
  2777. return NULL;
  2778. }
  2779. d = g_malloc(sizeof(*d));
  2780. d->size = opts->has_size ? opts->size : 65536;
  2781. /* The size must be power of 2 */
  2782. if (d->size & (d->size - 1)) {
  2783. error_setg(errp, "size of ringbuf chardev must be power of two");
  2784. goto fail;
  2785. }
  2786. d->prod = 0;
  2787. d->cons = 0;
  2788. d->cbuf = g_malloc0(d->size);
  2789. chr->opaque = d;
  2790. chr->chr_write = ringbuf_chr_write;
  2791. chr->chr_close = ringbuf_chr_close;
  2792. return chr;
  2793. fail:
  2794. g_free(d);
  2795. qemu_chr_free_common(chr);
  2796. return NULL;
  2797. }
  2798. bool chr_is_ringbuf(const CharDriverState *chr)
  2799. {
  2800. return chr->chr_write == ringbuf_chr_write;
  2801. }
  2802. void qmp_ringbuf_write(const char *device, const char *data,
  2803. bool has_format, enum DataFormat format,
  2804. Error **errp)
  2805. {
  2806. CharDriverState *chr;
  2807. const uint8_t *write_data;
  2808. int ret;
  2809. gsize write_count;
  2810. chr = qemu_chr_find(device);
  2811. if (!chr) {
  2812. error_setg(errp, "Device '%s' not found", device);
  2813. return;
  2814. }
  2815. if (!chr_is_ringbuf(chr)) {
  2816. error_setg(errp,"%s is not a ringbuf device", device);
  2817. return;
  2818. }
  2819. if (has_format && (format == DATA_FORMAT_BASE64)) {
  2820. write_data = qbase64_decode(data, -1,
  2821. &write_count,
  2822. errp);
  2823. if (!write_data) {
  2824. return;
  2825. }
  2826. } else {
  2827. write_data = (uint8_t *)data;
  2828. write_count = strlen(data);
  2829. }
  2830. ret = ringbuf_chr_write(chr, write_data, write_count);
  2831. if (write_data != (uint8_t *)data) {
  2832. g_free((void *)write_data);
  2833. }
  2834. if (ret < 0) {
  2835. error_setg(errp, "Failed to write to device %s", device);
  2836. return;
  2837. }
  2838. }
  2839. char *qmp_ringbuf_read(const char *device, int64_t size,
  2840. bool has_format, enum DataFormat format,
  2841. Error **errp)
  2842. {
  2843. CharDriverState *chr;
  2844. uint8_t *read_data;
  2845. size_t count;
  2846. char *data;
  2847. chr = qemu_chr_find(device);
  2848. if (!chr) {
  2849. error_setg(errp, "Device '%s' not found", device);
  2850. return NULL;
  2851. }
  2852. if (!chr_is_ringbuf(chr)) {
  2853. error_setg(errp,"%s is not a ringbuf device", device);
  2854. return NULL;
  2855. }
  2856. if (size <= 0) {
  2857. error_setg(errp, "size must be greater than zero");
  2858. return NULL;
  2859. }
  2860. count = ringbuf_count(chr);
  2861. size = size > count ? count : size;
  2862. read_data = g_malloc(size + 1);
  2863. ringbuf_chr_read(chr, read_data, size);
  2864. if (has_format && (format == DATA_FORMAT_BASE64)) {
  2865. data = g_base64_encode(read_data, size);
  2866. g_free(read_data);
  2867. } else {
  2868. /*
  2869. * FIXME should read only complete, valid UTF-8 characters up
  2870. * to @size bytes. Invalid sequences should be replaced by a
  2871. * suitable replacement character. Except when (and only
  2872. * when) ring buffer lost characters since last read, initial
  2873. * continuation characters should be dropped.
  2874. */
  2875. read_data[size] = 0;
  2876. data = (char *)read_data;
  2877. }
  2878. return data;
  2879. }
  2880. QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename)
  2881. {
  2882. char host[65], port[33], width[8], height[8];
  2883. int pos;
  2884. const char *p;
  2885. QemuOpts *opts;
  2886. Error *local_err = NULL;
  2887. opts = qemu_opts_create(qemu_find_opts("chardev"), label, 1, &local_err);
  2888. if (local_err) {
  2889. error_report_err(local_err);
  2890. return NULL;
  2891. }
  2892. if (strstart(filename, "mon:", &p)) {
  2893. filename = p;
  2894. qemu_opt_set(opts, "mux", "on", &error_abort);
  2895. if (strcmp(filename, "stdio") == 0) {
  2896. /* Monitor is muxed to stdio: do not exit on Ctrl+C by default
  2897. * but pass it to the guest. Handle this only for compat syntax,
  2898. * for -chardev syntax we have special option for this.
  2899. * This is what -nographic did, redirecting+muxing serial+monitor
  2900. * to stdio causing Ctrl+C to be passed to guest. */
  2901. qemu_opt_set(opts, "signal", "off", &error_abort);
  2902. }
  2903. }
  2904. if (strcmp(filename, "null") == 0 ||
  2905. strcmp(filename, "pty") == 0 ||
  2906. strcmp(filename, "msmouse") == 0 ||
  2907. strcmp(filename, "braille") == 0 ||
  2908. strcmp(filename, "testdev") == 0 ||
  2909. strcmp(filename, "stdio") == 0) {
  2910. qemu_opt_set(opts, "backend", filename, &error_abort);
  2911. return opts;
  2912. }
  2913. if (strstart(filename, "vc", &p)) {
  2914. qemu_opt_set(opts, "backend", "vc", &error_abort);
  2915. if (*p == ':') {
  2916. if (sscanf(p+1, "%7[0-9]x%7[0-9]", width, height) == 2) {
  2917. /* pixels */
  2918. qemu_opt_set(opts, "width", width, &error_abort);
  2919. qemu_opt_set(opts, "height", height, &error_abort);
  2920. } else if (sscanf(p+1, "%7[0-9]Cx%7[0-9]C", width, height) == 2) {
  2921. /* chars */
  2922. qemu_opt_set(opts, "cols", width, &error_abort);
  2923. qemu_opt_set(opts, "rows", height, &error_abort);
  2924. } else {
  2925. goto fail;
  2926. }
  2927. }
  2928. return opts;
  2929. }
  2930. if (strcmp(filename, "con:") == 0) {
  2931. qemu_opt_set(opts, "backend", "console", &error_abort);
  2932. return opts;
  2933. }
  2934. if (strstart(filename, "COM", NULL)) {
  2935. qemu_opt_set(opts, "backend", "serial", &error_abort);
  2936. qemu_opt_set(opts, "path", filename, &error_abort);
  2937. return opts;
  2938. }
  2939. if (strstart(filename, "file:", &p)) {
  2940. qemu_opt_set(opts, "backend", "file", &error_abort);
  2941. qemu_opt_set(opts, "path", p, &error_abort);
  2942. return opts;
  2943. }
  2944. if (strstart(filename, "pipe:", &p)) {
  2945. qemu_opt_set(opts, "backend", "pipe", &error_abort);
  2946. qemu_opt_set(opts, "path", p, &error_abort);
  2947. return opts;
  2948. }
  2949. if (strstart(filename, "tcp:", &p) ||
  2950. strstart(filename, "telnet:", &p)) {
  2951. if (sscanf(p, "%64[^:]:%32[^,]%n", host, port, &pos) < 2) {
  2952. host[0] = 0;
  2953. if (sscanf(p, ":%32[^,]%n", port, &pos) < 1)
  2954. goto fail;
  2955. }
  2956. qemu_opt_set(opts, "backend", "socket", &error_abort);
  2957. qemu_opt_set(opts, "host", host, &error_abort);
  2958. qemu_opt_set(opts, "port", port, &error_abort);
  2959. if (p[pos] == ',') {
  2960. qemu_opts_do_parse(opts, p+pos+1, NULL, &local_err);
  2961. if (local_err) {
  2962. error_report_err(local_err);
  2963. goto fail;
  2964. }
  2965. }
  2966. if (strstart(filename, "telnet:", &p))
  2967. qemu_opt_set(opts, "telnet", "on", &error_abort);
  2968. return opts;
  2969. }
  2970. if (strstart(filename, "udp:", &p)) {
  2971. qemu_opt_set(opts, "backend", "udp", &error_abort);
  2972. if (sscanf(p, "%64[^:]:%32[^@,]%n", host, port, &pos) < 2) {
  2973. host[0] = 0;
  2974. if (sscanf(p, ":%32[^@,]%n", port, &pos) < 1) {
  2975. goto fail;
  2976. }
  2977. }
  2978. qemu_opt_set(opts, "host", host, &error_abort);
  2979. qemu_opt_set(opts, "port", port, &error_abort);
  2980. if (p[pos] == '@') {
  2981. p += pos + 1;
  2982. if (sscanf(p, "%64[^:]:%32[^,]%n", host, port, &pos) < 2) {
  2983. host[0] = 0;
  2984. if (sscanf(p, ":%32[^,]%n", port, &pos) < 1) {
  2985. goto fail;
  2986. }
  2987. }
  2988. qemu_opt_set(opts, "localaddr", host, &error_abort);
  2989. qemu_opt_set(opts, "localport", port, &error_abort);
  2990. }
  2991. return opts;
  2992. }
  2993. if (strstart(filename, "unix:", &p)) {
  2994. qemu_opt_set(opts, "backend", "socket", &error_abort);
  2995. qemu_opts_do_parse(opts, p, "path", &local_err);
  2996. if (local_err) {
  2997. error_report_err(local_err);
  2998. goto fail;
  2999. }
  3000. return opts;
  3001. }
  3002. if (strstart(filename, "/dev/parport", NULL) ||
  3003. strstart(filename, "/dev/ppi", NULL)) {
  3004. qemu_opt_set(opts, "backend", "parport", &error_abort);
  3005. qemu_opt_set(opts, "path", filename, &error_abort);
  3006. return opts;
  3007. }
  3008. if (strstart(filename, "/dev/", NULL)) {
  3009. qemu_opt_set(opts, "backend", "tty", &error_abort);
  3010. qemu_opt_set(opts, "path", filename, &error_abort);
  3011. return opts;
  3012. }
  3013. fail:
  3014. qemu_opts_del(opts);
  3015. return NULL;
  3016. }
  3017. static void qemu_chr_parse_common(QemuOpts *opts, ChardevCommon *backend)
  3018. {
  3019. const char *logfile = qemu_opt_get(opts, "logfile");
  3020. backend->has_logfile = logfile != NULL;
  3021. backend->logfile = logfile ? g_strdup(logfile) : NULL;
  3022. backend->has_logappend = true;
  3023. backend->logappend = qemu_opt_get_bool(opts, "logappend", false);
  3024. }
  3025. static void qemu_chr_parse_file_out(QemuOpts *opts, ChardevBackend *backend,
  3026. Error **errp)
  3027. {
  3028. const char *path = qemu_opt_get(opts, "path");
  3029. if (path == NULL) {
  3030. error_setg(errp, "chardev: file: no filename given");
  3031. return;
  3032. }
  3033. backend->u.file = g_new0(ChardevFile, 1);
  3034. qemu_chr_parse_common(opts, qapi_ChardevFile_base(backend->u.file));
  3035. backend->u.file->out = g_strdup(path);
  3036. backend->u.file->has_append = true;
  3037. backend->u.file->append = qemu_opt_get_bool(opts, "append", false);
  3038. }
  3039. static void qemu_chr_parse_stdio(QemuOpts *opts, ChardevBackend *backend,
  3040. Error **errp)
  3041. {
  3042. backend->u.stdio = g_new0(ChardevStdio, 1);
  3043. qemu_chr_parse_common(opts, qapi_ChardevStdio_base(backend->u.stdio));
  3044. backend->u.stdio->has_signal = true;
  3045. backend->u.stdio->signal = qemu_opt_get_bool(opts, "signal", true);
  3046. }
  3047. #ifdef HAVE_CHARDEV_SERIAL
  3048. static void qemu_chr_parse_serial(QemuOpts *opts, ChardevBackend *backend,
  3049. Error **errp)
  3050. {
  3051. const char *device = qemu_opt_get(opts, "path");
  3052. if (device == NULL) {
  3053. error_setg(errp, "chardev: serial/tty: no device path given");
  3054. return;
  3055. }
  3056. backend->u.serial = g_new0(ChardevHostdev, 1);
  3057. qemu_chr_parse_common(opts, qapi_ChardevHostdev_base(backend->u.serial));
  3058. backend->u.serial->device = g_strdup(device);
  3059. }
  3060. #endif
  3061. #ifdef HAVE_CHARDEV_PARPORT
  3062. static void qemu_chr_parse_parallel(QemuOpts *opts, ChardevBackend *backend,
  3063. Error **errp)
  3064. {
  3065. const char *device = qemu_opt_get(opts, "path");
  3066. if (device == NULL) {
  3067. error_setg(errp, "chardev: parallel: no device path given");
  3068. return;
  3069. }
  3070. backend->u.parallel = g_new0(ChardevHostdev, 1);
  3071. qemu_chr_parse_common(opts, qapi_ChardevHostdev_base(backend->u.parallel));
  3072. backend->u.parallel->device = g_strdup(device);
  3073. }
  3074. #endif
  3075. static void qemu_chr_parse_pipe(QemuOpts *opts, ChardevBackend *backend,
  3076. Error **errp)
  3077. {
  3078. const char *device = qemu_opt_get(opts, "path");
  3079. if (device == NULL) {
  3080. error_setg(errp, "chardev: pipe: no device path given");
  3081. return;
  3082. }
  3083. backend->u.pipe = g_new0(ChardevHostdev, 1);
  3084. qemu_chr_parse_common(opts, qapi_ChardevHostdev_base(backend->u.pipe));
  3085. backend->u.pipe->device = g_strdup(device);
  3086. }
  3087. static void qemu_chr_parse_ringbuf(QemuOpts *opts, ChardevBackend *backend,
  3088. Error **errp)
  3089. {
  3090. int val;
  3091. backend->u.ringbuf = g_new0(ChardevRingbuf, 1);
  3092. qemu_chr_parse_common(opts, qapi_ChardevRingbuf_base(backend->u.ringbuf));
  3093. val = qemu_opt_get_size(opts, "size", 0);
  3094. if (val != 0) {
  3095. backend->u.ringbuf->has_size = true;
  3096. backend->u.ringbuf->size = val;
  3097. }
  3098. }
  3099. static void qemu_chr_parse_mux(QemuOpts *opts, ChardevBackend *backend,
  3100. Error **errp)
  3101. {
  3102. const char *chardev = qemu_opt_get(opts, "chardev");
  3103. if (chardev == NULL) {
  3104. error_setg(errp, "chardev: mux: no chardev given");
  3105. return;
  3106. }
  3107. backend->u.mux = g_new0(ChardevMux, 1);
  3108. qemu_chr_parse_common(opts, qapi_ChardevMux_base(backend->u.mux));
  3109. backend->u.mux->chardev = g_strdup(chardev);
  3110. }
  3111. static void qemu_chr_parse_socket(QemuOpts *opts, ChardevBackend *backend,
  3112. Error **errp)
  3113. {
  3114. bool is_listen = qemu_opt_get_bool(opts, "server", false);
  3115. bool is_waitconnect = is_listen && qemu_opt_get_bool(opts, "wait", true);
  3116. bool is_telnet = qemu_opt_get_bool(opts, "telnet", false);
  3117. bool do_nodelay = !qemu_opt_get_bool(opts, "delay", true);
  3118. int64_t reconnect = qemu_opt_get_number(opts, "reconnect", 0);
  3119. const char *path = qemu_opt_get(opts, "path");
  3120. const char *host = qemu_opt_get(opts, "host");
  3121. const char *port = qemu_opt_get(opts, "port");
  3122. const char *tls_creds = qemu_opt_get(opts, "tls-creds");
  3123. SocketAddress *addr;
  3124. if (!path) {
  3125. if (!host) {
  3126. error_setg(errp, "chardev: socket: no host given");
  3127. return;
  3128. }
  3129. if (!port) {
  3130. error_setg(errp, "chardev: socket: no port given");
  3131. return;
  3132. }
  3133. } else {
  3134. if (tls_creds) {
  3135. error_setg(errp, "TLS can only be used over TCP socket");
  3136. return;
  3137. }
  3138. }
  3139. backend->u.socket = g_new0(ChardevSocket, 1);
  3140. qemu_chr_parse_common(opts, qapi_ChardevSocket_base(backend->u.socket));
  3141. backend->u.socket->has_nodelay = true;
  3142. backend->u.socket->nodelay = do_nodelay;
  3143. backend->u.socket->has_server = true;
  3144. backend->u.socket->server = is_listen;
  3145. backend->u.socket->has_telnet = true;
  3146. backend->u.socket->telnet = is_telnet;
  3147. backend->u.socket->has_wait = true;
  3148. backend->u.socket->wait = is_waitconnect;
  3149. backend->u.socket->has_reconnect = true;
  3150. backend->u.socket->reconnect = reconnect;
  3151. backend->u.socket->tls_creds = g_strdup(tls_creds);
  3152. addr = g_new0(SocketAddress, 1);
  3153. if (path) {
  3154. addr->type = SOCKET_ADDRESS_KIND_UNIX;
  3155. addr->u.q_unix = g_new0(UnixSocketAddress, 1);
  3156. addr->u.q_unix->path = g_strdup(path);
  3157. } else {
  3158. addr->type = SOCKET_ADDRESS_KIND_INET;
  3159. addr->u.inet = g_new0(InetSocketAddress, 1);
  3160. addr->u.inet->host = g_strdup(host);
  3161. addr->u.inet->port = g_strdup(port);
  3162. addr->u.inet->has_to = qemu_opt_get(opts, "to");
  3163. addr->u.inet->to = qemu_opt_get_number(opts, "to", 0);
  3164. addr->u.inet->has_ipv4 = qemu_opt_get(opts, "ipv4");
  3165. addr->u.inet->ipv4 = qemu_opt_get_bool(opts, "ipv4", 0);
  3166. addr->u.inet->has_ipv6 = qemu_opt_get(opts, "ipv6");
  3167. addr->u.inet->ipv6 = qemu_opt_get_bool(opts, "ipv6", 0);
  3168. }
  3169. backend->u.socket->addr = addr;
  3170. }
  3171. static void qemu_chr_parse_udp(QemuOpts *opts, ChardevBackend *backend,
  3172. Error **errp)
  3173. {
  3174. const char *host = qemu_opt_get(opts, "host");
  3175. const char *port = qemu_opt_get(opts, "port");
  3176. const char *localaddr = qemu_opt_get(opts, "localaddr");
  3177. const char *localport = qemu_opt_get(opts, "localport");
  3178. bool has_local = false;
  3179. SocketAddress *addr;
  3180. if (host == NULL || strlen(host) == 0) {
  3181. host = "localhost";
  3182. }
  3183. if (port == NULL || strlen(port) == 0) {
  3184. error_setg(errp, "chardev: udp: remote port not specified");
  3185. return;
  3186. }
  3187. if (localport == NULL || strlen(localport) == 0) {
  3188. localport = "0";
  3189. } else {
  3190. has_local = true;
  3191. }
  3192. if (localaddr == NULL || strlen(localaddr) == 0) {
  3193. localaddr = "";
  3194. } else {
  3195. has_local = true;
  3196. }
  3197. backend->u.udp = g_new0(ChardevUdp, 1);
  3198. qemu_chr_parse_common(opts, qapi_ChardevUdp_base(backend->u.udp));
  3199. addr = g_new0(SocketAddress, 1);
  3200. addr->type = SOCKET_ADDRESS_KIND_INET;
  3201. addr->u.inet = g_new0(InetSocketAddress, 1);
  3202. addr->u.inet->host = g_strdup(host);
  3203. addr->u.inet->port = g_strdup(port);
  3204. addr->u.inet->has_ipv4 = qemu_opt_get(opts, "ipv4");
  3205. addr->u.inet->ipv4 = qemu_opt_get_bool(opts, "ipv4", 0);
  3206. addr->u.inet->has_ipv6 = qemu_opt_get(opts, "ipv6");
  3207. addr->u.inet->ipv6 = qemu_opt_get_bool(opts, "ipv6", 0);
  3208. backend->u.udp->remote = addr;
  3209. if (has_local) {
  3210. backend->u.udp->has_local = true;
  3211. addr = g_new0(SocketAddress, 1);
  3212. addr->type = SOCKET_ADDRESS_KIND_INET;
  3213. addr->u.inet = g_new0(InetSocketAddress, 1);
  3214. addr->u.inet->host = g_strdup(localaddr);
  3215. addr->u.inet->port = g_strdup(localport);
  3216. backend->u.udp->local = addr;
  3217. }
  3218. }
  3219. typedef struct CharDriver {
  3220. const char *name;
  3221. ChardevBackendKind kind;
  3222. void (*parse)(QemuOpts *opts, ChardevBackend *backend, Error **errp);
  3223. CharDriverState *(*create)(const char *id, ChardevBackend *backend,
  3224. ChardevReturn *ret, Error **errp);
  3225. } CharDriver;
  3226. static GSList *backends;
  3227. void register_char_driver(const char *name, ChardevBackendKind kind,
  3228. void (*parse)(QemuOpts *opts, ChardevBackend *backend, Error **errp),
  3229. CharDriverState *(*create)(const char *id, ChardevBackend *backend,
  3230. ChardevReturn *ret, Error **errp))
  3231. {
  3232. CharDriver *s;
  3233. s = g_malloc0(sizeof(*s));
  3234. s->name = g_strdup(name);
  3235. s->kind = kind;
  3236. s->parse = parse;
  3237. s->create = create;
  3238. backends = g_slist_append(backends, s);
  3239. }
  3240. CharDriverState *qemu_chr_new_from_opts(QemuOpts *opts,
  3241. void (*init)(struct CharDriverState *s),
  3242. Error **errp)
  3243. {
  3244. Error *local_err = NULL;
  3245. CharDriver *cd;
  3246. CharDriverState *chr;
  3247. GSList *i;
  3248. ChardevReturn *ret = NULL;
  3249. ChardevBackend *backend;
  3250. const char *id = qemu_opts_id(opts);
  3251. char *bid = NULL;
  3252. if (id == NULL) {
  3253. error_setg(errp, "chardev: no id specified");
  3254. goto err;
  3255. }
  3256. if (qemu_opt_get(opts, "backend") == NULL) {
  3257. error_setg(errp, "chardev: \"%s\" missing backend",
  3258. qemu_opts_id(opts));
  3259. goto err;
  3260. }
  3261. for (i = backends; i; i = i->next) {
  3262. cd = i->data;
  3263. if (strcmp(cd->name, qemu_opt_get(opts, "backend")) == 0) {
  3264. break;
  3265. }
  3266. }
  3267. if (i == NULL) {
  3268. error_setg(errp, "chardev: backend \"%s\" not found",
  3269. qemu_opt_get(opts, "backend"));
  3270. goto err;
  3271. }
  3272. backend = g_new0(ChardevBackend, 1);
  3273. if (qemu_opt_get_bool(opts, "mux", 0)) {
  3274. bid = g_strdup_printf("%s-base", id);
  3275. }
  3276. chr = NULL;
  3277. backend->type = cd->kind;
  3278. if (cd->parse) {
  3279. cd->parse(opts, backend, &local_err);
  3280. if (local_err) {
  3281. error_propagate(errp, local_err);
  3282. goto qapi_out;
  3283. }
  3284. } else {
  3285. ChardevCommon *cc = g_new0(ChardevCommon, 1);
  3286. qemu_chr_parse_common(opts, cc);
  3287. backend->u.data = cc;
  3288. }
  3289. ret = qmp_chardev_add(bid ? bid : id, backend, errp);
  3290. if (!ret) {
  3291. goto qapi_out;
  3292. }
  3293. if (bid) {
  3294. qapi_free_ChardevBackend(backend);
  3295. qapi_free_ChardevReturn(ret);
  3296. backend = g_new0(ChardevBackend, 1);
  3297. backend->u.mux = g_new0(ChardevMux, 1);
  3298. backend->type = CHARDEV_BACKEND_KIND_MUX;
  3299. backend->u.mux->chardev = g_strdup(bid);
  3300. ret = qmp_chardev_add(id, backend, errp);
  3301. if (!ret) {
  3302. chr = qemu_chr_find(bid);
  3303. qemu_chr_delete(chr);
  3304. chr = NULL;
  3305. goto qapi_out;
  3306. }
  3307. }
  3308. chr = qemu_chr_find(id);
  3309. chr->opts = opts;
  3310. qapi_out:
  3311. qapi_free_ChardevBackend(backend);
  3312. qapi_free_ChardevReturn(ret);
  3313. g_free(bid);
  3314. return chr;
  3315. err:
  3316. qemu_opts_del(opts);
  3317. return NULL;
  3318. }
  3319. CharDriverState *qemu_chr_new(const char *label, const char *filename, void (*init)(struct CharDriverState *s))
  3320. {
  3321. const char *p;
  3322. CharDriverState *chr;
  3323. QemuOpts *opts;
  3324. Error *err = NULL;
  3325. if (strstart(filename, "chardev:", &p)) {
  3326. return qemu_chr_find(p);
  3327. }
  3328. opts = qemu_chr_parse_compat(label, filename);
  3329. if (!opts)
  3330. return NULL;
  3331. chr = qemu_chr_new_from_opts(opts, init, &err);
  3332. if (err) {
  3333. error_report_err(err);
  3334. }
  3335. if (chr && qemu_opt_get_bool(opts, "mux", 0)) {
  3336. qemu_chr_fe_claim_no_fail(chr);
  3337. monitor_init(chr, MONITOR_USE_READLINE);
  3338. }
  3339. return chr;
  3340. }
  3341. void qemu_chr_fe_set_echo(struct CharDriverState *chr, bool echo)
  3342. {
  3343. if (chr->chr_set_echo) {
  3344. chr->chr_set_echo(chr, echo);
  3345. }
  3346. }
  3347. void qemu_chr_fe_set_open(struct CharDriverState *chr, int fe_open)
  3348. {
  3349. if (chr->fe_open == fe_open) {
  3350. return;
  3351. }
  3352. chr->fe_open = fe_open;
  3353. if (chr->chr_set_fe_open) {
  3354. chr->chr_set_fe_open(chr, fe_open);
  3355. }
  3356. }
  3357. void qemu_chr_fe_event(struct CharDriverState *chr, int event)
  3358. {
  3359. if (chr->chr_fe_event) {
  3360. chr->chr_fe_event(chr, event);
  3361. }
  3362. }
  3363. int qemu_chr_fe_add_watch(CharDriverState *s, GIOCondition cond,
  3364. GIOFunc func, void *user_data)
  3365. {
  3366. GSource *src;
  3367. guint tag;
  3368. if (s->chr_add_watch == NULL) {
  3369. return -ENOSYS;
  3370. }
  3371. src = s->chr_add_watch(s, cond);
  3372. if (!src) {
  3373. return -EINVAL;
  3374. }
  3375. g_source_set_callback(src, (GSourceFunc)func, user_data, NULL);
  3376. tag = g_source_attach(src, NULL);
  3377. g_source_unref(src);
  3378. return tag;
  3379. }
  3380. int qemu_chr_fe_claim(CharDriverState *s)
  3381. {
  3382. if (s->avail_connections < 1) {
  3383. return -1;
  3384. }
  3385. s->avail_connections--;
  3386. return 0;
  3387. }
  3388. void qemu_chr_fe_claim_no_fail(CharDriverState *s)
  3389. {
  3390. if (qemu_chr_fe_claim(s) != 0) {
  3391. fprintf(stderr, "%s: error chardev \"%s\" already used\n",
  3392. __func__, s->label);
  3393. exit(1);
  3394. }
  3395. }
  3396. void qemu_chr_fe_release(CharDriverState *s)
  3397. {
  3398. s->avail_connections++;
  3399. }
  3400. static void qemu_chr_free_common(CharDriverState *chr)
  3401. {
  3402. g_free(chr->filename);
  3403. g_free(chr->label);
  3404. qemu_opts_del(chr->opts);
  3405. if (chr->logfd != -1) {
  3406. close(chr->logfd);
  3407. }
  3408. qemu_mutex_destroy(&chr->chr_write_lock);
  3409. g_free(chr);
  3410. }
  3411. void qemu_chr_free(CharDriverState *chr)
  3412. {
  3413. if (chr->chr_close) {
  3414. chr->chr_close(chr);
  3415. }
  3416. qemu_chr_free_common(chr);
  3417. }
  3418. void qemu_chr_delete(CharDriverState *chr)
  3419. {
  3420. QTAILQ_REMOVE(&chardevs, chr, next);
  3421. qemu_chr_free(chr);
  3422. }
  3423. ChardevInfoList *qmp_query_chardev(Error **errp)
  3424. {
  3425. ChardevInfoList *chr_list = NULL;
  3426. CharDriverState *chr;
  3427. QTAILQ_FOREACH(chr, &chardevs, next) {
  3428. ChardevInfoList *info = g_malloc0(sizeof(*info));
  3429. info->value = g_malloc0(sizeof(*info->value));
  3430. info->value->label = g_strdup(chr->label);
  3431. info->value->filename = g_strdup(chr->filename);
  3432. info->value->frontend_open = chr->fe_open;
  3433. info->next = chr_list;
  3434. chr_list = info;
  3435. }
  3436. return chr_list;
  3437. }
  3438. ChardevBackendInfoList *qmp_query_chardev_backends(Error **errp)
  3439. {
  3440. ChardevBackendInfoList *backend_list = NULL;
  3441. CharDriver *c = NULL;
  3442. GSList *i = NULL;
  3443. for (i = backends; i; i = i->next) {
  3444. ChardevBackendInfoList *info = g_malloc0(sizeof(*info));
  3445. c = i->data;
  3446. info->value = g_malloc0(sizeof(*info->value));
  3447. info->value->name = g_strdup(c->name);
  3448. info->next = backend_list;
  3449. backend_list = info;
  3450. }
  3451. return backend_list;
  3452. }
  3453. CharDriverState *qemu_chr_find(const char *name)
  3454. {
  3455. CharDriverState *chr;
  3456. QTAILQ_FOREACH(chr, &chardevs, next) {
  3457. if (strcmp(chr->label, name) != 0)
  3458. continue;
  3459. return chr;
  3460. }
  3461. return NULL;
  3462. }
  3463. /* Get a character (serial) device interface. */
  3464. CharDriverState *qemu_char_get_next_serial(void)
  3465. {
  3466. static int next_serial;
  3467. CharDriverState *chr;
  3468. /* FIXME: This function needs to go away: use chardev properties! */
  3469. while (next_serial < MAX_SERIAL_PORTS && serial_hds[next_serial]) {
  3470. chr = serial_hds[next_serial++];
  3471. qemu_chr_fe_claim_no_fail(chr);
  3472. return chr;
  3473. }
  3474. return NULL;
  3475. }
  3476. QemuOptsList qemu_chardev_opts = {
  3477. .name = "chardev",
  3478. .implied_opt_name = "backend",
  3479. .head = QTAILQ_HEAD_INITIALIZER(qemu_chardev_opts.head),
  3480. .desc = {
  3481. {
  3482. .name = "backend",
  3483. .type = QEMU_OPT_STRING,
  3484. },{
  3485. .name = "path",
  3486. .type = QEMU_OPT_STRING,
  3487. },{
  3488. .name = "host",
  3489. .type = QEMU_OPT_STRING,
  3490. },{
  3491. .name = "port",
  3492. .type = QEMU_OPT_STRING,
  3493. },{
  3494. .name = "localaddr",
  3495. .type = QEMU_OPT_STRING,
  3496. },{
  3497. .name = "localport",
  3498. .type = QEMU_OPT_STRING,
  3499. },{
  3500. .name = "to",
  3501. .type = QEMU_OPT_NUMBER,
  3502. },{
  3503. .name = "ipv4",
  3504. .type = QEMU_OPT_BOOL,
  3505. },{
  3506. .name = "ipv6",
  3507. .type = QEMU_OPT_BOOL,
  3508. },{
  3509. .name = "wait",
  3510. .type = QEMU_OPT_BOOL,
  3511. },{
  3512. .name = "server",
  3513. .type = QEMU_OPT_BOOL,
  3514. },{
  3515. .name = "delay",
  3516. .type = QEMU_OPT_BOOL,
  3517. },{
  3518. .name = "reconnect",
  3519. .type = QEMU_OPT_NUMBER,
  3520. },{
  3521. .name = "telnet",
  3522. .type = QEMU_OPT_BOOL,
  3523. },{
  3524. .name = "tls-creds",
  3525. .type = QEMU_OPT_STRING,
  3526. },{
  3527. .name = "width",
  3528. .type = QEMU_OPT_NUMBER,
  3529. },{
  3530. .name = "height",
  3531. .type = QEMU_OPT_NUMBER,
  3532. },{
  3533. .name = "cols",
  3534. .type = QEMU_OPT_NUMBER,
  3535. },{
  3536. .name = "rows",
  3537. .type = QEMU_OPT_NUMBER,
  3538. },{
  3539. .name = "mux",
  3540. .type = QEMU_OPT_BOOL,
  3541. },{
  3542. .name = "signal",
  3543. .type = QEMU_OPT_BOOL,
  3544. },{
  3545. .name = "name",
  3546. .type = QEMU_OPT_STRING,
  3547. },{
  3548. .name = "debug",
  3549. .type = QEMU_OPT_NUMBER,
  3550. },{
  3551. .name = "size",
  3552. .type = QEMU_OPT_SIZE,
  3553. },{
  3554. .name = "chardev",
  3555. .type = QEMU_OPT_STRING,
  3556. },{
  3557. .name = "append",
  3558. .type = QEMU_OPT_BOOL,
  3559. },{
  3560. .name = "logfile",
  3561. .type = QEMU_OPT_STRING,
  3562. },{
  3563. .name = "logappend",
  3564. .type = QEMU_OPT_BOOL,
  3565. },
  3566. { /* end of list */ }
  3567. },
  3568. };
  3569. #ifdef _WIN32
  3570. static CharDriverState *qmp_chardev_open_file(const char *id,
  3571. ChardevBackend *backend,
  3572. ChardevReturn *ret,
  3573. Error **errp)
  3574. {
  3575. ChardevFile *file = backend->u.file;
  3576. ChardevCommon *common = qapi_ChardevFile_base(backend->u.file);
  3577. HANDLE out;
  3578. if (file->has_in) {
  3579. error_setg(errp, "input file not supported");
  3580. return NULL;
  3581. }
  3582. out = CreateFile(file->out, GENERIC_WRITE, FILE_SHARE_READ, NULL,
  3583. OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
  3584. if (out == INVALID_HANDLE_VALUE) {
  3585. error_setg(errp, "open %s failed", file->out);
  3586. return NULL;
  3587. }
  3588. return qemu_chr_open_win_file(out, common, errp);
  3589. }
  3590. static CharDriverState *qmp_chardev_open_serial(const char *id,
  3591. ChardevBackend *backend,
  3592. ChardevReturn *ret,
  3593. Error **errp)
  3594. {
  3595. ChardevHostdev *serial = backend->u.serial;
  3596. ChardevCommon *common = qapi_ChardevHostdev_base(backend->u.serial);
  3597. return qemu_chr_open_win_path(serial->device, common, errp);
  3598. }
  3599. #else /* WIN32 */
  3600. static int qmp_chardev_open_file_source(char *src, int flags,
  3601. Error **errp)
  3602. {
  3603. int fd = -1;
  3604. TFR(fd = qemu_open(src, flags, 0666));
  3605. if (fd == -1) {
  3606. error_setg_file_open(errp, errno, src);
  3607. }
  3608. return fd;
  3609. }
  3610. static CharDriverState *qmp_chardev_open_file(const char *id,
  3611. ChardevBackend *backend,
  3612. ChardevReturn *ret,
  3613. Error **errp)
  3614. {
  3615. ChardevFile *file = backend->u.file;
  3616. ChardevCommon *common = qapi_ChardevFile_base(backend->u.file);
  3617. int flags, in = -1, out;
  3618. flags = O_WRONLY | O_CREAT | O_BINARY;
  3619. if (file->has_append && file->append) {
  3620. flags |= O_APPEND;
  3621. } else {
  3622. flags |= O_TRUNC;
  3623. }
  3624. out = qmp_chardev_open_file_source(file->out, flags, errp);
  3625. if (out < 0) {
  3626. return NULL;
  3627. }
  3628. if (file->has_in) {
  3629. flags = O_RDONLY;
  3630. in = qmp_chardev_open_file_source(file->in, flags, errp);
  3631. if (in < 0) {
  3632. qemu_close(out);
  3633. return NULL;
  3634. }
  3635. }
  3636. return qemu_chr_open_fd(in, out, common, errp);
  3637. }
  3638. #ifdef HAVE_CHARDEV_SERIAL
  3639. static CharDriverState *qmp_chardev_open_serial(const char *id,
  3640. ChardevBackend *backend,
  3641. ChardevReturn *ret,
  3642. Error **errp)
  3643. {
  3644. ChardevHostdev *serial = backend->u.serial;
  3645. ChardevCommon *common = qapi_ChardevHostdev_base(backend->u.serial);
  3646. int fd;
  3647. fd = qmp_chardev_open_file_source(serial->device, O_RDWR, errp);
  3648. if (fd < 0) {
  3649. return NULL;
  3650. }
  3651. qemu_set_nonblock(fd);
  3652. return qemu_chr_open_tty_fd(fd, common, errp);
  3653. }
  3654. #endif
  3655. #ifdef HAVE_CHARDEV_PARPORT
  3656. static CharDriverState *qmp_chardev_open_parallel(const char *id,
  3657. ChardevBackend *backend,
  3658. ChardevReturn *ret,
  3659. Error **errp)
  3660. {
  3661. ChardevHostdev *parallel = backend->u.parallel;
  3662. ChardevCommon *common = qapi_ChardevHostdev_base(backend->u.parallel);
  3663. int fd;
  3664. fd = qmp_chardev_open_file_source(parallel->device, O_RDWR, errp);
  3665. if (fd < 0) {
  3666. return NULL;
  3667. }
  3668. return qemu_chr_open_pp_fd(fd, common, errp);
  3669. }
  3670. #endif
  3671. #endif /* WIN32 */
  3672. static void socket_try_connect(CharDriverState *chr)
  3673. {
  3674. Error *err = NULL;
  3675. if (!qemu_chr_open_socket_fd(chr, &err)) {
  3676. check_report_connect_error(chr, err);
  3677. }
  3678. }
  3679. static gboolean socket_reconnect_timeout(gpointer opaque)
  3680. {
  3681. CharDriverState *chr = opaque;
  3682. TCPCharDriver *s = chr->opaque;
  3683. s->reconnect_timer = 0;
  3684. if (chr->be_open) {
  3685. return false;
  3686. }
  3687. socket_try_connect(chr);
  3688. return false;
  3689. }
  3690. static CharDriverState *qmp_chardev_open_socket(const char *id,
  3691. ChardevBackend *backend,
  3692. ChardevReturn *ret,
  3693. Error **errp)
  3694. {
  3695. CharDriverState *chr;
  3696. TCPCharDriver *s;
  3697. ChardevSocket *sock = backend->u.socket;
  3698. SocketAddress *addr = sock->addr;
  3699. bool do_nodelay = sock->has_nodelay ? sock->nodelay : false;
  3700. bool is_listen = sock->has_server ? sock->server : true;
  3701. bool is_telnet = sock->has_telnet ? sock->telnet : false;
  3702. bool is_waitconnect = sock->has_wait ? sock->wait : false;
  3703. int64_t reconnect = sock->has_reconnect ? sock->reconnect : 0;
  3704. ChardevCommon *common = qapi_ChardevSocket_base(backend->u.socket);
  3705. chr = qemu_chr_alloc(common, errp);
  3706. if (!chr) {
  3707. return NULL;
  3708. }
  3709. s = g_new0(TCPCharDriver, 1);
  3710. s->is_unix = addr->type == SOCKET_ADDRESS_KIND_UNIX;
  3711. s->is_listen = is_listen;
  3712. s->is_telnet = is_telnet;
  3713. s->do_nodelay = do_nodelay;
  3714. if (sock->tls_creds) {
  3715. Object *creds;
  3716. creds = object_resolve_path_component(
  3717. object_get_objects_root(), sock->tls_creds);
  3718. if (!creds) {
  3719. error_setg(errp, "No TLS credentials with id '%s'",
  3720. sock->tls_creds);
  3721. goto error;
  3722. }
  3723. s->tls_creds = (QCryptoTLSCreds *)
  3724. object_dynamic_cast(creds,
  3725. TYPE_QCRYPTO_TLS_CREDS);
  3726. if (!s->tls_creds) {
  3727. error_setg(errp, "Object with id '%s' is not TLS credentials",
  3728. sock->tls_creds);
  3729. goto error;
  3730. }
  3731. object_ref(OBJECT(s->tls_creds));
  3732. if (is_listen) {
  3733. if (s->tls_creds->endpoint != QCRYPTO_TLS_CREDS_ENDPOINT_SERVER) {
  3734. error_setg(errp, "%s",
  3735. "Expected TLS credentials for server endpoint");
  3736. goto error;
  3737. }
  3738. } else {
  3739. if (s->tls_creds->endpoint != QCRYPTO_TLS_CREDS_ENDPOINT_CLIENT) {
  3740. error_setg(errp, "%s",
  3741. "Expected TLS credentials for client endpoint");
  3742. goto error;
  3743. }
  3744. }
  3745. }
  3746. qapi_copy_SocketAddress(&s->addr, sock->addr);
  3747. chr->opaque = s;
  3748. chr->chr_write = tcp_chr_write;
  3749. chr->chr_sync_read = tcp_chr_sync_read;
  3750. chr->chr_close = tcp_chr_close;
  3751. chr->get_msgfds = tcp_get_msgfds;
  3752. chr->set_msgfds = tcp_set_msgfds;
  3753. chr->chr_add_client = tcp_chr_add_client;
  3754. chr->chr_add_watch = tcp_chr_add_watch;
  3755. chr->chr_update_read_handler = tcp_chr_update_read_handler;
  3756. /* be isn't opened until we get a connection */
  3757. chr->explicit_be_open = true;
  3758. chr->filename = SocketAddress_to_str("disconnected:",
  3759. addr, is_listen, is_telnet);
  3760. if (is_listen) {
  3761. if (is_telnet) {
  3762. s->do_telnetopt = 1;
  3763. }
  3764. } else if (reconnect > 0) {
  3765. s->reconnect_time = reconnect;
  3766. }
  3767. if (s->reconnect_time) {
  3768. socket_try_connect(chr);
  3769. } else if (!qemu_chr_open_socket_fd(chr, errp)) {
  3770. goto error;
  3771. }
  3772. if (is_listen && is_waitconnect) {
  3773. fprintf(stderr, "QEMU waiting for connection on: %s\n",
  3774. chr->filename);
  3775. tcp_chr_accept(QIO_CHANNEL(s->listen_ioc), G_IO_IN, chr);
  3776. qio_channel_set_blocking(QIO_CHANNEL(s->listen_ioc), false, NULL);
  3777. }
  3778. return chr;
  3779. error:
  3780. if (s->tls_creds) {
  3781. object_unref(OBJECT(s->tls_creds));
  3782. }
  3783. g_free(s);
  3784. qemu_chr_free_common(chr);
  3785. return NULL;
  3786. }
  3787. static CharDriverState *qmp_chardev_open_udp(const char *id,
  3788. ChardevBackend *backend,
  3789. ChardevReturn *ret,
  3790. Error **errp)
  3791. {
  3792. ChardevUdp *udp = backend->u.udp;
  3793. ChardevCommon *common = qapi_ChardevUdp_base(backend->u.udp);
  3794. QIOChannelSocket *sioc = qio_channel_socket_new();
  3795. if (qio_channel_socket_dgram_sync(sioc,
  3796. udp->remote, udp->local,
  3797. errp) < 0) {
  3798. object_unref(OBJECT(sioc));
  3799. return NULL;
  3800. }
  3801. return qemu_chr_open_udp(sioc, common, errp);
  3802. }
  3803. ChardevReturn *qmp_chardev_add(const char *id, ChardevBackend *backend,
  3804. Error **errp)
  3805. {
  3806. ChardevReturn *ret = g_new0(ChardevReturn, 1);
  3807. CharDriverState *chr = NULL;
  3808. Error *local_err = NULL;
  3809. GSList *i;
  3810. CharDriver *cd;
  3811. chr = qemu_chr_find(id);
  3812. if (chr) {
  3813. error_setg(errp, "Chardev '%s' already exists", id);
  3814. g_free(ret);
  3815. return NULL;
  3816. }
  3817. for (i = backends; i; i = i->next) {
  3818. cd = i->data;
  3819. if (cd->kind == backend->type) {
  3820. chr = cd->create(id, backend, ret, &local_err);
  3821. if (local_err) {
  3822. error_propagate(errp, local_err);
  3823. goto out_error;
  3824. }
  3825. break;
  3826. }
  3827. }
  3828. if (chr == NULL) {
  3829. assert(!i);
  3830. error_setg(errp, "chardev backend not available");
  3831. goto out_error;
  3832. }
  3833. chr->label = g_strdup(id);
  3834. chr->avail_connections =
  3835. (backend->type == CHARDEV_BACKEND_KIND_MUX) ? MAX_MUX : 1;
  3836. if (!chr->filename) {
  3837. chr->filename = g_strdup(ChardevBackendKind_lookup[backend->type]);
  3838. }
  3839. if (!chr->explicit_be_open) {
  3840. qemu_chr_be_event(chr, CHR_EVENT_OPENED);
  3841. }
  3842. QTAILQ_INSERT_TAIL(&chardevs, chr, next);
  3843. return ret;
  3844. out_error:
  3845. g_free(ret);
  3846. return NULL;
  3847. }
  3848. void qmp_chardev_remove(const char *id, Error **errp)
  3849. {
  3850. CharDriverState *chr;
  3851. chr = qemu_chr_find(id);
  3852. if (chr == NULL) {
  3853. error_setg(errp, "Chardev '%s' not found", id);
  3854. return;
  3855. }
  3856. if (chr->chr_can_read || chr->chr_read ||
  3857. chr->chr_event || chr->handler_opaque) {
  3858. error_setg(errp, "Chardev '%s' is busy", id);
  3859. return;
  3860. }
  3861. qemu_chr_delete(chr);
  3862. }
  3863. static void register_types(void)
  3864. {
  3865. register_char_driver("null", CHARDEV_BACKEND_KIND_NULL, NULL,
  3866. qemu_chr_open_null);
  3867. register_char_driver("socket", CHARDEV_BACKEND_KIND_SOCKET,
  3868. qemu_chr_parse_socket, qmp_chardev_open_socket);
  3869. register_char_driver("udp", CHARDEV_BACKEND_KIND_UDP, qemu_chr_parse_udp,
  3870. qmp_chardev_open_udp);
  3871. register_char_driver("ringbuf", CHARDEV_BACKEND_KIND_RINGBUF,
  3872. qemu_chr_parse_ringbuf, qemu_chr_open_ringbuf);
  3873. register_char_driver("file", CHARDEV_BACKEND_KIND_FILE,
  3874. qemu_chr_parse_file_out, qmp_chardev_open_file);
  3875. register_char_driver("stdio", CHARDEV_BACKEND_KIND_STDIO,
  3876. qemu_chr_parse_stdio, qemu_chr_open_stdio);
  3877. #if defined HAVE_CHARDEV_SERIAL
  3878. register_char_driver("serial", CHARDEV_BACKEND_KIND_SERIAL,
  3879. qemu_chr_parse_serial, qmp_chardev_open_serial);
  3880. register_char_driver("tty", CHARDEV_BACKEND_KIND_SERIAL,
  3881. qemu_chr_parse_serial, qmp_chardev_open_serial);
  3882. #endif
  3883. #ifdef HAVE_CHARDEV_PARPORT
  3884. register_char_driver("parallel", CHARDEV_BACKEND_KIND_PARALLEL,
  3885. qemu_chr_parse_parallel, qmp_chardev_open_parallel);
  3886. register_char_driver("parport", CHARDEV_BACKEND_KIND_PARALLEL,
  3887. qemu_chr_parse_parallel, qmp_chardev_open_parallel);
  3888. #endif
  3889. #ifdef HAVE_CHARDEV_PTY
  3890. register_char_driver("pty", CHARDEV_BACKEND_KIND_PTY, NULL,
  3891. qemu_chr_open_pty);
  3892. #endif
  3893. #ifdef _WIN32
  3894. register_char_driver("console", CHARDEV_BACKEND_KIND_CONSOLE, NULL,
  3895. qemu_chr_open_win_con);
  3896. #endif
  3897. register_char_driver("pipe", CHARDEV_BACKEND_KIND_PIPE,
  3898. qemu_chr_parse_pipe, qemu_chr_open_pipe);
  3899. register_char_driver("mux", CHARDEV_BACKEND_KIND_MUX, qemu_chr_parse_mux,
  3900. qemu_chr_open_mux);
  3901. /* Bug-compatibility: */
  3902. register_char_driver("memory", CHARDEV_BACKEND_KIND_MEMORY,
  3903. qemu_chr_parse_ringbuf, qemu_chr_open_ringbuf);
  3904. /* this must be done after machine init, since we register FEs with muxes
  3905. * as part of realize functions like serial_isa_realizefn when -nographic
  3906. * is specified
  3907. */
  3908. qemu_add_machine_init_done_notifier(&muxes_realize_notify);
  3909. }
  3910. type_init(register_types);