Process.cpp 128 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194319531963197319831993200320132023203320432053206320732083209321032113212321332143215321632173218321932203221322232233224322532263227322832293230323132323233323432353236323732383239324032413242324332443245324632473248324932503251325232533254325532563257325832593260326132623263326432653266326732683269327032713272327332743275327632773278327932803281328232833284328532863287328832893290329132923293329432953296329732983299330033013302330333043305330633073308330933103311331233133314331533163317331833193320332133223323332433253326332733283329333033313332333333343335333633373338333933403341334233433344334533463347334833493350335133523353335433553356335733583359336033613362336333643365336633673368336933703371337233733374337533763377337833793380338133823383338433853386338733883389339033913392339333943395339633973398339934003401340234033404340534063407340834093410341134123413341434153416341734183419342034213422342334243425342634273428342934303431343234333434343534363437343834393440344134423443344434453446344734483449345034513452345334543455345634573458345934603461346234633464346534663467346834693470347134723473347434753476347734783479348034813482348334843485348634873488348934903491349234933494349534963497349834993500350135023503350435053506350735083509351035113512351335143515351635173518351935203521352235233524352535263527352835293530353135323533353435353536353735383539354035413542354335443545354635473548354935503551355235533554355535563557355835593560356135623563356435653566356735683569357035713572357335743575357635773578357935803581358235833584358535863587358835893590359135923593359435953596359735983599360036013602360336043605360636073608360936103611361236133614361536163617361836193620362136223623362436253626362736283629363036313632363336343635363636373638363936403641364236433644364536463647364836493650365136523653365436553656365736583659366036613662366336643665366636673668366936703671367236733674367536763677367836793680368136823683368436853686368736883689369036913692369336943695369636973698369937003701370237033704370537063707370837093710371137123713371437153716371737183719372037213722372337243725372637273728372937303731373237333734373537363737373837393740374137423743374437453746374737483749375037513752375337543755375637573758375937603761376237633764376537663767376837693770377137723773377437753776377737783779378037813782378337843785378637873788378937903791379237933794379537963797379837993800380138023803380438053806380738083809381038113812381338143815381638173818381938203821382238233824382538263827382838293830383138323833383438353836383738383839384038413842384338443845384638473848384938503851385238533854385538563857385838593860386138623863386438653866386738683869387038713872387338743875387638773878387938803881388238833884388538863887388838893890389138923893389438953896389738983899390039013902390339043905390639073908390939103911391239133914391539163917391839193920392139223923392439253926392739283929393039313932393339343935393639373938393939403941394239433944394539463947394839493950395139523953395439553956395739583959396039613962396339643965396639673968396939703971397239733974397539763977397839793980398139823983398439853986398739883989399039913992399339943995399639973998399940004001400240034004400540064007400840094010401140124013401440154016401740184019402040214022402340244025402640274028402940304031403240334034403540364037403840394040404140424043404440454046404740484049405040514052405340544055405640574058405940604061406240634064406540664067406840694070407140724073407440754076407740784079408040814082408340844085408640874088408940904091409240934094409540964097409840994100410141024103410441054106410741084109411041114112411341144115411641174118411941204121412241234124412541264127412841294130413141324133413441354136413741384139414041414142414341444145414641474148414941504151415241534154415541564157415841594160416141624163416441654166416741684169417041714172417341744175417641774178417941804181418241834184418541864187
  1. #include <AK/FileSystemPath.h>
  2. #include <AK/StdLibExtras.h>
  3. #include <AK/StringBuilder.h>
  4. #include <AK/Time.h>
  5. #include <AK/Types.h>
  6. #include <Kernel/Arch/i386/CPU.h>
  7. #include <Kernel/Arch/i386/PIT.h>
  8. #include <Kernel/Console.h>
  9. #include <Kernel/Devices/KeyboardDevice.h>
  10. #include <Kernel/Devices/NullDevice.h>
  11. #include <Kernel/Devices/PCSpeaker.h>
  12. #include <Kernel/Devices/RandomDevice.h>
  13. #include <Kernel/FileSystem/Custody.h>
  14. #include <Kernel/FileSystem/DevPtsFS.h>
  15. #include <Kernel/FileSystem/Ext2FileSystem.h>
  16. #include <Kernel/FileSystem/FIFO.h>
  17. #include <Kernel/FileSystem/FileDescription.h>
  18. #include <Kernel/FileSystem/InodeWatcher.h>
  19. #include <Kernel/FileSystem/ProcFS.h>
  20. #include <Kernel/FileSystem/TmpFS.h>
  21. #include <Kernel/FileSystem/VirtualFileSystem.h>
  22. #include <Kernel/Heap/kmalloc.h>
  23. #include <Kernel/IO.h>
  24. #include <Kernel/KBufferBuilder.h>
  25. #include <Kernel/KSyms.h>
  26. #include <Kernel/KernelInfoPage.h>
  27. #include <Kernel/Module.h>
  28. #include <Kernel/Multiboot.h>
  29. #include <Kernel/Net/Socket.h>
  30. #include <Kernel/Process.h>
  31. #include <Kernel/ProcessTracer.h>
  32. #include <Kernel/Profiling.h>
  33. #include <Kernel/RTC.h>
  34. #include <Kernel/Random.h>
  35. #include <Kernel/Scheduler.h>
  36. #include <Kernel/SharedBuffer.h>
  37. #include <Kernel/StdLib.h>
  38. #include <Kernel/Syscall.h>
  39. #include <Kernel/TTY/MasterPTY.h>
  40. #include <Kernel/Thread.h>
  41. #include <Kernel/VM/InodeVMObject.h>
  42. #include <Kernel/VM/PurgeableVMObject.h>
  43. #include <LibC/errno_numbers.h>
  44. #include <LibC/limits.h>
  45. #include <LibC/signal_numbers.h>
  46. #include <LibELF/ELFLoader.h>
  47. //#define DEBUG_POLL_SELECT
  48. //#define DEBUG_IO
  49. //#define TASK_DEBUG
  50. //#define FORK_DEBUG
  51. //#define EXEC_DEBUG
  52. //#define SIGNAL_DEBUG
  53. //#define SHARED_BUFFER_DEBUG
  54. static void create_signal_trampolines();
  55. static void create_kernel_info_page();
  56. static pid_t next_pid;
  57. InlineLinkedList<Process>* g_processes;
  58. static String* s_hostname;
  59. static Lock* s_hostname_lock;
  60. static VirtualAddress s_info_page_address_for_userspace;
  61. static VirtualAddress s_info_page_address_for_kernel;
  62. VirtualAddress g_return_to_ring3_from_signal_trampoline;
  63. HashMap<String, OwnPtr<Module>>* g_modules;
  64. pid_t Process::allocate_pid()
  65. {
  66. InterruptDisabler disabler;
  67. return next_pid++;
  68. }
  69. void Process::initialize()
  70. {
  71. g_modules = new HashMap<String, OwnPtr<Module>>;
  72. next_pid = 0;
  73. g_processes = new InlineLinkedList<Process>;
  74. s_hostname = new String("courage");
  75. s_hostname_lock = new Lock;
  76. create_signal_trampolines();
  77. create_kernel_info_page();
  78. }
  79. void Process::update_info_page_timestamp(const timeval& tv)
  80. {
  81. auto* info_page = (KernelInfoPage*)s_info_page_address_for_kernel.as_ptr();
  82. info_page->serial++;
  83. const_cast<timeval&>(info_page->now) = tv;
  84. }
  85. Vector<pid_t> Process::all_pids()
  86. {
  87. Vector<pid_t> pids;
  88. InterruptDisabler disabler;
  89. pids.ensure_capacity((int)g_processes->size_slow());
  90. for (auto& process : *g_processes)
  91. pids.append(process.pid());
  92. return pids;
  93. }
  94. Vector<Process*> Process::all_processes()
  95. {
  96. Vector<Process*> processes;
  97. InterruptDisabler disabler;
  98. processes.ensure_capacity((int)g_processes->size_slow());
  99. for (auto& process : *g_processes)
  100. processes.append(&process);
  101. return processes;
  102. }
  103. bool Process::in_group(gid_t gid) const
  104. {
  105. return m_gid == gid || m_extra_gids.contains(gid);
  106. }
  107. Range Process::allocate_range(VirtualAddress vaddr, size_t size)
  108. {
  109. vaddr.mask(PAGE_MASK);
  110. size = PAGE_ROUND_UP(size);
  111. if (vaddr.is_null())
  112. return page_directory().range_allocator().allocate_anywhere(size);
  113. return page_directory().range_allocator().allocate_specific(vaddr, size);
  114. }
  115. static unsigned prot_to_region_access_flags(int prot)
  116. {
  117. unsigned access = 0;
  118. if (prot & PROT_READ)
  119. access |= Region::Access::Read;
  120. if (prot & PROT_WRITE)
  121. access |= Region::Access::Write;
  122. if (prot & PROT_EXEC)
  123. access |= Region::Access::Execute;
  124. return access;
  125. }
  126. Region& Process::allocate_split_region(const Region& source_region, const Range& range, size_t offset_in_vmobject)
  127. {
  128. m_regions.append(Region::create_user_accessible(range, source_region.vmobject(), offset_in_vmobject, source_region.name(), source_region.access()));
  129. return m_regions.last();
  130. }
  131. Region* Process::allocate_region(VirtualAddress vaddr, size_t size, const String& name, int prot, bool commit)
  132. {
  133. auto range = allocate_range(vaddr, size);
  134. if (!range.is_valid())
  135. return nullptr;
  136. m_regions.append(Region::create_user_accessible(range, name, prot_to_region_access_flags(prot)));
  137. m_regions.last().map(page_directory());
  138. if (commit)
  139. m_regions.last().commit();
  140. return &m_regions.last();
  141. }
  142. Region* Process::allocate_file_backed_region(VirtualAddress vaddr, size_t size, NonnullRefPtr<Inode> inode, const String& name, int prot)
  143. {
  144. auto range = allocate_range(vaddr, size);
  145. if (!range.is_valid())
  146. return nullptr;
  147. m_regions.append(Region::create_user_accessible(range, inode, name, prot_to_region_access_flags(prot)));
  148. m_regions.last().map(page_directory());
  149. return &m_regions.last();
  150. }
  151. Region* Process::allocate_region_with_vmobject(VirtualAddress vaddr, size_t size, NonnullRefPtr<VMObject> vmobject, size_t offset_in_vmobject, const String& name, int prot, bool user_accessible)
  152. {
  153. auto range = allocate_range(vaddr, size);
  154. if (!range.is_valid())
  155. return nullptr;
  156. offset_in_vmobject &= PAGE_MASK;
  157. if (user_accessible)
  158. m_regions.append(Region::create_user_accessible(range, move(vmobject), offset_in_vmobject, name, prot_to_region_access_flags(prot)));
  159. else
  160. m_regions.append(Region::create_kernel_only(range, move(vmobject), offset_in_vmobject, name, prot_to_region_access_flags(prot)));
  161. m_regions.last().map(page_directory());
  162. return &m_regions.last();
  163. }
  164. bool Process::deallocate_region(Region& region)
  165. {
  166. InterruptDisabler disabler;
  167. for (int i = 0; i < m_regions.size(); ++i) {
  168. if (&m_regions[i] == &region) {
  169. m_regions.remove(i);
  170. return true;
  171. }
  172. }
  173. return false;
  174. }
  175. Region* Process::region_from_range(const Range& range)
  176. {
  177. size_t size = PAGE_ROUND_UP(range.size());
  178. for (auto& region : m_regions) {
  179. if (region.vaddr() == range.base() && region.size() == size)
  180. return &region;
  181. }
  182. return nullptr;
  183. }
  184. Region* Process::region_containing(const Range& range)
  185. {
  186. for (auto& region : m_regions) {
  187. if (region.contains(range))
  188. return &region;
  189. }
  190. return nullptr;
  191. }
  192. int Process::sys$set_mmap_name(const Syscall::SC_set_mmap_name_params* user_params)
  193. {
  194. if (!validate_read_typed(user_params))
  195. return -EFAULT;
  196. Syscall::SC_set_mmap_name_params params;
  197. copy_from_user(&params, user_params, sizeof(params));
  198. if (!validate_read(params.name, params.name_length))
  199. return -EFAULT;
  200. auto name = copy_string_from_user(params.name, params.name_length);
  201. auto* region = region_from_range({ VirtualAddress((u32)params.addr), params.size });
  202. if (!region)
  203. return -EINVAL;
  204. if (!region->is_mmap())
  205. return -EPERM;
  206. region->set_name(name);
  207. return 0;
  208. }
  209. static bool validate_mmap_prot(int prot, bool map_stack)
  210. {
  211. bool readable = prot & PROT_READ;
  212. bool writable = prot & PROT_WRITE;
  213. bool executable = prot & PROT_EXEC;
  214. if (writable && executable)
  215. return false;
  216. if (map_stack) {
  217. if (executable)
  218. return false;
  219. if (!readable || !writable)
  220. return false;
  221. }
  222. return true;
  223. }
  224. static bool validate_inode_mmap_prot(const Process& process, int prot, const Inode& inode)
  225. {
  226. auto metadata = inode.metadata();
  227. if ((prot & PROT_WRITE) && !metadata.may_write(process))
  228. return false;
  229. if ((prot & PROT_READ) && !metadata.may_read(process))
  230. return false;
  231. return true;
  232. }
  233. // Carve out a virtual address range from a region and return the two regions on either side
  234. Vector<Region*, 2> Process::split_region_around_range(const Region& source_region, const Range& desired_range)
  235. {
  236. Range old_region_range = source_region.range();
  237. auto remaining_ranges_after_unmap = old_region_range.carve(desired_range);
  238. ASSERT(!remaining_ranges_after_unmap.is_empty());
  239. auto make_replacement_region = [&](const Range& new_range) -> Region& {
  240. ASSERT(new_range.base() >= old_region_range.base());
  241. ASSERT(new_range.end() <= old_region_range.end());
  242. size_t new_range_offset_in_vmobject = source_region.offset_in_vmobject() + (new_range.base().get() - old_region_range.base().get());
  243. return allocate_split_region(source_region, new_range, new_range_offset_in_vmobject);
  244. };
  245. Vector<Region*, 2> new_regions;
  246. for (auto& new_range : remaining_ranges_after_unmap) {
  247. new_regions.unchecked_append(&make_replacement_region(new_range));
  248. }
  249. return new_regions;
  250. }
  251. void* Process::sys$mmap(const Syscall::SC_mmap_params* user_params)
  252. {
  253. if (!validate_read_typed(user_params))
  254. return (void*)-EFAULT;
  255. Syscall::SC_mmap_params params;
  256. copy_from_user(&params, user_params, sizeof(params));
  257. void* addr = (void*)params.addr;
  258. size_t size = params.size;
  259. int prot = params.prot;
  260. int flags = params.flags;
  261. int fd = params.fd;
  262. int offset = params.offset;
  263. if (params.name && !validate_read(params.name, params.name_length))
  264. return (void*)-EFAULT;
  265. auto name = copy_string_from_user(params.name, params.name_length);
  266. if (size == 0)
  267. return (void*)-EINVAL;
  268. if ((u32)addr & ~PAGE_MASK)
  269. return (void*)-EINVAL;
  270. bool map_shared = flags & MAP_SHARED;
  271. bool map_anonymous = flags & MAP_ANONYMOUS;
  272. bool map_purgeable = flags & MAP_PURGEABLE;
  273. bool map_private = flags & MAP_PRIVATE;
  274. bool map_stack = flags & MAP_STACK;
  275. bool map_fixed = flags & MAP_FIXED;
  276. if (map_shared && map_private)
  277. return (void*)-EINVAL;
  278. if (!map_shared && !map_private)
  279. return (void*)-EINVAL;
  280. if (!validate_mmap_prot(prot, map_stack))
  281. return (void*)-EINVAL;
  282. if (map_stack && (!map_private || !map_anonymous))
  283. return (void*)-EINVAL;
  284. Region* region = nullptr;
  285. if (map_purgeable) {
  286. auto vmobject = PurgeableVMObject::create_with_size(size);
  287. region = allocate_region_with_vmobject(VirtualAddress((u32)addr), size, vmobject, 0, !name.is_null() ? name : "mmap (purgeable)", prot);
  288. if (!region && (!map_fixed && addr != 0))
  289. region = allocate_region_with_vmobject({}, size, vmobject, 0, !name.is_null() ? name : "mmap (purgeable)", prot);
  290. } else if (map_anonymous) {
  291. region = allocate_region(VirtualAddress((u32)addr), size, !name.is_null() ? name : "mmap", prot, false);
  292. if (!region && (!map_fixed && addr != 0))
  293. region = allocate_region({}, size, !name.is_null() ? name : "mmap", prot, false);
  294. } else {
  295. if (offset < 0)
  296. return (void*)-EINVAL;
  297. if (static_cast<size_t>(offset) & ~PAGE_MASK)
  298. return (void*)-EINVAL;
  299. // FIXME: Implement MAP_PRIVATE for FileDescription-backed mmap
  300. if (map_private)
  301. return (void*)-ENOTSUP;
  302. auto description = file_description(fd);
  303. if (!description)
  304. return (void*)-EBADF;
  305. if (description->is_directory())
  306. return (void*)-ENODEV;
  307. if ((prot & PROT_READ) && !description->is_readable())
  308. return (void*)-EACCES;
  309. if ((prot & PROT_WRITE) && !description->is_writable())
  310. return (void*)-EACCES;
  311. if (description->inode()) {
  312. if (!validate_inode_mmap_prot(*this, prot, *description->inode()))
  313. return (void*)-EACCES;
  314. }
  315. auto region_or_error = description->mmap(*this, VirtualAddress((u32)addr), static_cast<size_t>(offset), size, prot);
  316. if (region_or_error.is_error()) {
  317. // Fail if MAP_FIXED or address is 0, retry otherwise
  318. if (map_fixed || addr == 0)
  319. return (void*)(int)region_or_error.error();
  320. region_or_error = description->mmap(*this, {}, static_cast<size_t>(offset), size, prot);
  321. }
  322. if (region_or_error.is_error())
  323. return (void*)(int)region_or_error.error();
  324. region = region_or_error.value();
  325. }
  326. if (!region)
  327. return (void*)-ENOMEM;
  328. region->set_mmap(true);
  329. if (map_shared)
  330. region->set_shared(true);
  331. if (map_stack)
  332. region->set_stack(true);
  333. if (!name.is_null())
  334. region->set_name(name);
  335. return region->vaddr().as_ptr();
  336. }
  337. int Process::sys$munmap(void* addr, size_t size)
  338. {
  339. Range range_to_unmap { VirtualAddress((u32)addr), size };
  340. if (auto* whole_region = region_from_range(range_to_unmap)) {
  341. if (!whole_region->is_mmap())
  342. return -EPERM;
  343. bool success = deallocate_region(*whole_region);
  344. ASSERT(success);
  345. return 0;
  346. }
  347. if (auto* old_region = region_containing(range_to_unmap)) {
  348. if (!old_region->is_mmap())
  349. return -EPERM;
  350. auto new_regions = split_region_around_range(*old_region, range_to_unmap);
  351. // We manually unmap the old region here, specifying that we *don't* want the VM deallocated.
  352. old_region->unmap(Region::ShouldDeallocateVirtualMemoryRange::No);
  353. deallocate_region(*old_region);
  354. // Instead we give back the unwanted VM manually.
  355. page_directory().range_allocator().deallocate(range_to_unmap);
  356. // And finally we map the new region(s) using our page directory (they were just allocated and don't have one).
  357. for (auto* new_region : new_regions) {
  358. new_region->map(page_directory());
  359. }
  360. return 0;
  361. }
  362. // FIXME: We should also support munmap() across multiple regions. (#175)
  363. return -EINVAL;
  364. }
  365. int Process::sys$mprotect(void* addr, size_t size, int prot)
  366. {
  367. Range range_to_mprotect = { VirtualAddress((u32)addr), size };
  368. if (auto* whole_region = region_from_range(range_to_mprotect)) {
  369. if (!whole_region->is_mmap())
  370. return -EPERM;
  371. if (!validate_mmap_prot(prot, whole_region->is_stack()))
  372. return -EINVAL;
  373. if (whole_region->access() == prot_to_region_access_flags(prot))
  374. return 0;
  375. if (whole_region->vmobject().is_inode()
  376. && !validate_inode_mmap_prot(*this, prot, static_cast<const InodeVMObject&>(whole_region->vmobject()).inode())) {
  377. return -EACCES;
  378. }
  379. whole_region->set_readable(prot & PROT_READ);
  380. whole_region->set_writable(prot & PROT_WRITE);
  381. whole_region->set_executable(prot & PROT_EXEC);
  382. whole_region->remap();
  383. return 0;
  384. }
  385. // Check if we can carve out the desired range from an existing region
  386. if (auto* old_region = region_containing(range_to_mprotect)) {
  387. if (!old_region->is_mmap())
  388. return -EPERM;
  389. if (!validate_mmap_prot(prot, old_region->is_stack()))
  390. return -EINVAL;
  391. if (old_region->access() == prot_to_region_access_flags(prot))
  392. return 0;
  393. if (old_region->vmobject().is_inode()
  394. && !validate_inode_mmap_prot(*this, prot, static_cast<const InodeVMObject&>(old_region->vmobject()).inode())) {
  395. return -EACCES;
  396. }
  397. // This vector is the region(s) adjacent to our range.
  398. // We need to allocate a new region for the range we wanted to change permission bits on.
  399. auto adjacent_regions = split_region_around_range(*old_region, range_to_mprotect);
  400. size_t new_range_offset_in_vmobject = old_region->offset_in_vmobject() + (range_to_mprotect.base().get() - old_region->range().base().get());
  401. auto& new_region = allocate_split_region(*old_region, range_to_mprotect, new_range_offset_in_vmobject);
  402. new_region.set_readable(prot & PROT_READ);
  403. new_region.set_writable(prot & PROT_WRITE);
  404. new_region.set_executable(prot & PROT_EXEC);
  405. // Unmap the old region here, specifying that we *don't* want the VM deallocated.
  406. old_region->unmap(Region::ShouldDeallocateVirtualMemoryRange::No);
  407. deallocate_region(*old_region);
  408. // Map the new regions using our page directory (they were just allocated and don't have one).
  409. for (auto* adjacent_region : adjacent_regions) {
  410. adjacent_region->map(page_directory());
  411. }
  412. new_region.map(page_directory());
  413. return 0;
  414. }
  415. // FIXME: We should also support mprotect() across multiple regions. (#175) (#964)
  416. return -EINVAL;
  417. }
  418. int Process::sys$madvise(void* address, size_t size, int advice)
  419. {
  420. auto* region = region_from_range({ VirtualAddress((u32)address), size });
  421. if (!region)
  422. return -EINVAL;
  423. if (!region->is_mmap())
  424. return -EPERM;
  425. if ((advice & MADV_SET_VOLATILE) && (advice & MADV_SET_NONVOLATILE))
  426. return -EINVAL;
  427. if (advice & MADV_SET_VOLATILE) {
  428. if (!region->vmobject().is_purgeable())
  429. return -EPERM;
  430. auto& vmobject = static_cast<PurgeableVMObject&>(region->vmobject());
  431. vmobject.set_volatile(true);
  432. return 0;
  433. }
  434. if (advice & MADV_SET_NONVOLATILE) {
  435. if (!region->vmobject().is_purgeable())
  436. return -EPERM;
  437. auto& vmobject = static_cast<PurgeableVMObject&>(region->vmobject());
  438. if (!vmobject.is_volatile())
  439. return 0;
  440. vmobject.set_volatile(false);
  441. bool was_purged = vmobject.was_purged();
  442. vmobject.set_was_purged(false);
  443. return was_purged ? 1 : 0;
  444. }
  445. if (advice & MADV_GET_VOLATILE) {
  446. if (!region->vmobject().is_purgeable())
  447. return -EPERM;
  448. auto& vmobject = static_cast<PurgeableVMObject&>(region->vmobject());
  449. return vmobject.is_volatile() ? 0 : 1;
  450. }
  451. return -EINVAL;
  452. }
  453. int Process::sys$purge(int mode)
  454. {
  455. if (!is_superuser())
  456. return -EPERM;
  457. int purged_page_count = 0;
  458. if (mode & PURGE_ALL_VOLATILE) {
  459. NonnullRefPtrVector<PurgeableVMObject> vmobjects;
  460. {
  461. InterruptDisabler disabler;
  462. MM.for_each_vmobject([&](auto& vmobject) {
  463. if (vmobject.is_purgeable())
  464. vmobjects.append(static_cast<PurgeableVMObject&>(vmobject));
  465. return IterationDecision::Continue;
  466. });
  467. }
  468. for (auto& vmobject : vmobjects) {
  469. purged_page_count += vmobject.purge();
  470. }
  471. }
  472. if (mode & PURGE_ALL_CLEAN_INODE) {
  473. NonnullRefPtrVector<InodeVMObject> vmobjects;
  474. {
  475. InterruptDisabler disabler;
  476. MM.for_each_vmobject([&](auto& vmobject) {
  477. if (vmobject.is_inode())
  478. vmobjects.append(static_cast<InodeVMObject&>(vmobject));
  479. return IterationDecision::Continue;
  480. });
  481. }
  482. for (auto& vmobject : vmobjects) {
  483. purged_page_count += vmobject.release_all_clean_pages();
  484. }
  485. }
  486. return purged_page_count;
  487. }
  488. int Process::sys$gethostname(char* buffer, ssize_t size)
  489. {
  490. if (size < 0)
  491. return -EINVAL;
  492. if (!validate_write(buffer, size))
  493. return -EFAULT;
  494. LOCKER(*s_hostname_lock);
  495. if ((size_t)size < (s_hostname->length() + 1))
  496. return -ENAMETOOLONG;
  497. copy_to_user(buffer, s_hostname->characters(), s_hostname->length() + 1);
  498. return 0;
  499. }
  500. pid_t Process::sys$fork(RegisterDump& regs)
  501. {
  502. Thread* child_first_thread = nullptr;
  503. auto* child = new Process(child_first_thread, m_name, m_uid, m_gid, m_pid, m_ring, m_cwd, m_executable, m_tty, this);
  504. child->m_root_directory = m_root_directory;
  505. #ifdef FORK_DEBUG
  506. dbgprintf("fork: child=%p\n", child);
  507. #endif
  508. for (auto& region : m_regions) {
  509. #ifdef FORK_DEBUG
  510. dbg() << "fork: cloning Region{" << &region << "} '" << region.name() << "' @ " << region.vaddr();
  511. #endif
  512. child->m_regions.append(region.clone());
  513. child->m_regions.last().map(child->page_directory());
  514. if (&region == m_master_tls_region)
  515. child->m_master_tls_region = &child->m_regions.last();
  516. }
  517. child->m_extra_gids = m_extra_gids;
  518. auto& child_tss = child_first_thread->m_tss;
  519. child_tss.eax = 0; // fork() returns 0 in the child :^)
  520. child_tss.ebx = regs.ebx;
  521. child_tss.ecx = regs.ecx;
  522. child_tss.edx = regs.edx;
  523. child_tss.ebp = regs.ebp;
  524. child_tss.esp = regs.userspace_esp;
  525. child_tss.esi = regs.esi;
  526. child_tss.edi = regs.edi;
  527. child_tss.eflags = regs.eflags;
  528. child_tss.eip = regs.eip;
  529. child_tss.cs = regs.cs;
  530. child_tss.ds = regs.ds;
  531. child_tss.es = regs.es;
  532. child_tss.fs = regs.fs;
  533. child_tss.gs = regs.gs;
  534. child_tss.ss = regs.userspace_ss;
  535. #ifdef FORK_DEBUG
  536. dbgprintf("fork: child will begin executing at %w:%x with stack %w:%x, kstack %w:%x\n", child_tss.cs, child_tss.eip, child_tss.ss, child_tss.esp, child_tss.ss0, child_tss.esp0);
  537. #endif
  538. {
  539. InterruptDisabler disabler;
  540. g_processes->prepend(child);
  541. }
  542. #ifdef TASK_DEBUG
  543. kprintf("Process %u (%s) forked from %u @ %p\n", child->pid(), child->name().characters(), m_pid, child_tss.eip);
  544. #endif
  545. child_first_thread->set_state(Thread::State::Skip1SchedulerPass);
  546. return child->pid();
  547. }
  548. int Process::do_exec(String path, Vector<String> arguments, Vector<String> environment)
  549. {
  550. ASSERT(is_ring3());
  551. dbgprintf("%s(%d) do_exec(%s): thread_count() = %d\n", m_name.characters(), m_pid, path.characters(), thread_count());
  552. // FIXME(Thread): Kill any threads the moment we commit to the exec().
  553. if (thread_count() != 1) {
  554. dbgprintf("Gonna die because I have many threads! These are the threads:\n");
  555. for_each_thread([](Thread& thread) {
  556. dbgprintf("Thread{%p}: TID=%d, PID=%d\n", &thread, thread.tid(), thread.pid());
  557. return IterationDecision::Continue;
  558. });
  559. ASSERT(thread_count() == 1);
  560. ASSERT_NOT_REACHED();
  561. }
  562. size_t total_blob_size = 0;
  563. for (auto& a : arguments)
  564. total_blob_size += a.length() + 1;
  565. for (auto& e : environment)
  566. total_blob_size += e.length() + 1;
  567. size_t total_meta_size = sizeof(char*) * (arguments.size() + 1) + sizeof(char*) * (environment.size() + 1);
  568. // FIXME: How much stack space does process startup need?
  569. if ((total_blob_size + total_meta_size) >= Thread::default_userspace_stack_size)
  570. return -E2BIG;
  571. auto parts = path.split('/');
  572. if (parts.is_empty())
  573. return -ENOENT;
  574. auto result = VFS::the().open(path, 0, 0, current_directory());
  575. if (result.is_error())
  576. return result.error();
  577. auto description = result.value();
  578. auto metadata = description->metadata();
  579. if (!metadata.may_execute(*this))
  580. return -EACCES;
  581. if (!metadata.size)
  582. return -ENOTIMPL;
  583. u32 entry_eip = 0;
  584. // FIXME: Is there a race here?
  585. auto old_page_directory = move(m_page_directory);
  586. m_page_directory = PageDirectory::create_for_userspace(*this);
  587. #ifdef MM_DEBUG
  588. dbgprintf("Process %u exec: PD=%x created\n", pid(), m_page_directory.ptr());
  589. #endif
  590. ProcessPagingScope paging_scope(*this);
  591. ASSERT(description->inode());
  592. auto vmobject = InodeVMObject::create_with_inode(*description->inode());
  593. auto* region = allocate_region_with_vmobject(VirtualAddress(), metadata.size, vmobject, 0, description->absolute_path(), PROT_READ, false);
  594. ASSERT(region);
  595. // NOTE: We yank this out of 'm_regions' since we're about to manipulate the vector
  596. // and we don't want it getting lost.
  597. auto executable_region = m_regions.take_last();
  598. Region* master_tls_region { nullptr };
  599. size_t master_tls_size = 0;
  600. size_t master_tls_alignment = 0;
  601. OwnPtr<ELFLoader> loader;
  602. {
  603. // Okay, here comes the sleight of hand, pay close attention..
  604. auto old_regions = move(m_regions);
  605. m_regions.append(move(executable_region));
  606. loader = make<ELFLoader>(region->vaddr().as_ptr(), metadata.size);
  607. loader->map_section_hook = [&](VirtualAddress vaddr, size_t size, size_t alignment, size_t offset_in_image, bool is_readable, bool is_writable, bool is_executable, const String& name) -> u8* {
  608. ASSERT(size);
  609. ASSERT(alignment == PAGE_SIZE);
  610. int prot = 0;
  611. if (is_readable)
  612. prot |= PROT_READ;
  613. if (is_writable)
  614. prot |= PROT_WRITE;
  615. if (is_executable)
  616. prot |= PROT_EXEC;
  617. if (!allocate_region_with_vmobject(vaddr, size, vmobject, offset_in_image, String(name), prot))
  618. return nullptr;
  619. return vaddr.as_ptr();
  620. };
  621. loader->alloc_section_hook = [&](VirtualAddress vaddr, size_t size, size_t alignment, bool is_readable, bool is_writable, const String& name) -> u8* {
  622. ASSERT(size);
  623. ASSERT(alignment == PAGE_SIZE);
  624. int prot = 0;
  625. if (is_readable)
  626. prot |= PROT_READ;
  627. if (is_writable)
  628. prot |= PROT_WRITE;
  629. if (!allocate_region(vaddr, size, String(name), prot))
  630. return nullptr;
  631. return vaddr.as_ptr();
  632. };
  633. loader->tls_section_hook = [&](size_t size, size_t alignment) {
  634. ASSERT(size);
  635. master_tls_region = allocate_region({}, size, String(), PROT_READ | PROT_WRITE);
  636. master_tls_size = size;
  637. master_tls_alignment = alignment;
  638. return master_tls_region->vaddr().as_ptr();
  639. };
  640. bool success = loader->load();
  641. if (!success || !loader->entry().get()) {
  642. m_page_directory = move(old_page_directory);
  643. // FIXME: RAII this somehow instead.
  644. ASSERT(&current->process() == this);
  645. MM.enter_process_paging_scope(*this);
  646. executable_region = m_regions.take_first();
  647. m_regions = move(old_regions);
  648. kprintf("do_exec: Failure loading %s\n", path.characters());
  649. return -ENOEXEC;
  650. }
  651. // NOTE: At this point, we've committed to the new executable.
  652. entry_eip = loader->entry().get();
  653. #ifdef EXEC_DEBUG
  654. kprintf("Memory layout after ELF load:");
  655. dump_regions();
  656. #endif
  657. }
  658. m_elf_loader = move(loader);
  659. m_executable = description->custody();
  660. // Copy of the master TLS region that we will clone for new threads
  661. m_master_tls_region = master_tls_region;
  662. if (metadata.is_setuid())
  663. m_euid = metadata.uid;
  664. if (metadata.is_setgid())
  665. m_egid = metadata.gid;
  666. current->set_default_signal_dispositions();
  667. current->m_signal_mask = 0;
  668. current->m_pending_signals = 0;
  669. for (int i = 0; i < m_fds.size(); ++i) {
  670. auto& daf = m_fds[i];
  671. if (daf.description && daf.flags & FD_CLOEXEC) {
  672. daf.description->close();
  673. daf = {};
  674. }
  675. }
  676. // FIXME: Should we just make a new Thread here instead?
  677. Thread* new_main_thread = nullptr;
  678. if (&current->process() == this) {
  679. new_main_thread = current;
  680. } else {
  681. for_each_thread([&](auto& thread) {
  682. new_main_thread = &thread;
  683. return IterationDecision::Break;
  684. });
  685. }
  686. ASSERT(new_main_thread);
  687. // NOTE: We create the new stack before disabling interrupts since it will zero-fault
  688. // and we don't want to deal with faults after this point.
  689. u32 new_userspace_esp = new_main_thread->make_userspace_stack_for_main_thread(move(arguments), move(environment));
  690. // We cli() manually here because we don't want to get interrupted between do_exec() and Schedule::yield().
  691. // The reason is that the task redirection we've set up above will be clobbered by the timer IRQ.
  692. // If we used an InterruptDisabler that sti()'d on exit, we might timer tick'd too soon in exec().
  693. if (&current->process() == this)
  694. cli();
  695. // NOTE: Be careful to not trigger any page faults below!
  696. Scheduler::prepare_to_modify_tss(*new_main_thread);
  697. m_name = parts.take_last();
  698. new_main_thread->set_name(m_name);
  699. auto& tss = new_main_thread->m_tss;
  700. u32 old_esp0 = tss.esp0;
  701. m_master_tls_size = master_tls_size;
  702. m_master_tls_alignment = master_tls_alignment;
  703. new_main_thread->make_thread_specific_region({});
  704. memset(&tss, 0, sizeof(TSS32));
  705. tss.iomapbase = sizeof(TSS32);
  706. tss.eflags = 0x0202;
  707. tss.eip = entry_eip;
  708. tss.cs = 0x1b;
  709. tss.ds = 0x23;
  710. tss.es = 0x23;
  711. tss.fs = 0x23;
  712. tss.gs = thread_specific_selector() | 3;
  713. tss.ss = 0x23;
  714. tss.cr3 = page_directory().cr3();
  715. tss.esp = new_userspace_esp;
  716. tss.ss0 = 0x10;
  717. tss.esp0 = old_esp0;
  718. tss.ss2 = m_pid;
  719. #ifdef TASK_DEBUG
  720. kprintf("Process %u (%s) exec'd %s @ %p\n", pid(), name().characters(), path.characters(), tss.eip);
  721. #endif
  722. new_main_thread->set_state(Thread::State::Skip1SchedulerPass);
  723. big_lock().unlock_if_locked();
  724. return 0;
  725. }
  726. KResultOr<Vector<String>> Process::find_shebang_interpreter_for_executable(const String& executable_path)
  727. {
  728. // FIXME: It's a bit sad that we'll open the executable twice (in case there's no shebang)
  729. // Maybe we can find a way to plumb this opened FileDescription to the rest of the
  730. // exec implementation..
  731. auto result = VFS::the().open(executable_path, 0, 0, current_directory());
  732. if (result.is_error())
  733. return result.error();
  734. auto description = result.value();
  735. auto metadata = description->metadata();
  736. if (!metadata.may_execute(*this))
  737. return KResult(-EACCES);
  738. if (metadata.size < 3)
  739. return KResult(-ENOEXEC);
  740. char first_page[PAGE_SIZE];
  741. int nread = description->read((u8*)&first_page, sizeof(first_page));
  742. int word_start = 2;
  743. int word_length = 0;
  744. if (nread > 2 && first_page[0] == '#' && first_page[1] == '!') {
  745. Vector<String> interpreter_words;
  746. for (int i = 2; i < nread; ++i) {
  747. if (first_page[i] == '\n') {
  748. break;
  749. }
  750. if (first_page[i] != ' ') {
  751. ++word_length;
  752. }
  753. if (first_page[i] == ' ') {
  754. if (word_length > 0) {
  755. interpreter_words.append(String(&first_page[word_start], word_length));
  756. }
  757. word_length = 0;
  758. word_start = i + 1;
  759. }
  760. }
  761. if (word_length > 0)
  762. interpreter_words.append(String(&first_page[word_start], word_length));
  763. if (!interpreter_words.is_empty())
  764. return interpreter_words;
  765. }
  766. return KResult(-ENOEXEC);
  767. }
  768. int Process::exec(String path, Vector<String> arguments, Vector<String> environment)
  769. {
  770. auto result = find_shebang_interpreter_for_executable(path);
  771. if (!result.is_error()) {
  772. Vector<String> new_arguments(result.value());
  773. new_arguments.append(path);
  774. arguments.remove(0);
  775. new_arguments.append(move(arguments));
  776. return exec(result.value().first(), move(new_arguments), move(environment));
  777. }
  778. // The bulk of exec() is done by do_exec(), which ensures that all locals
  779. // are cleaned up by the time we yield-teleport below.
  780. int rc = do_exec(move(path), move(arguments), move(environment));
  781. if (rc < 0)
  782. return rc;
  783. if (&current->process() == this) {
  784. Scheduler::yield();
  785. ASSERT_NOT_REACHED();
  786. }
  787. return 0;
  788. }
  789. int Process::sys$execve(const Syscall::SC_execve_params* user_params)
  790. {
  791. // NOTE: Be extremely careful with allocating any kernel memory in exec().
  792. // On success, the kernel stack will be lost.
  793. Syscall::SC_execve_params params;
  794. if (!validate_read_typed(user_params))
  795. return -EFAULT;
  796. copy_from_user(&params, user_params, sizeof(params));
  797. if (params.arguments.length > ARG_MAX || params.environment.length > ARG_MAX)
  798. return -E2BIG;
  799. if (!validate_read(params.path.characters, params.path.length))
  800. return -EFAULT;
  801. if (params.path.length == 0)
  802. return -ENOENT;
  803. auto copy_user_strings = [&](const auto& list, auto& output) {
  804. if (!list.length)
  805. return true;
  806. if (!validate_read_typed(list.strings, list.length))
  807. return false;
  808. Vector<Syscall::StringArgument, 32> strings;
  809. strings.resize(list.length);
  810. copy_from_user(strings.data(), list.strings, list.length * sizeof(Syscall::StringArgument));
  811. for (size_t i = 0; i < list.length; ++i) {
  812. if (!validate_read(strings[i].characters, strings[i].length))
  813. return false;
  814. output.append(copy_string_from_user(strings[i].characters, strings[i].length));
  815. }
  816. return true;
  817. };
  818. Vector<String> arguments;
  819. if (!copy_user_strings(params.arguments, arguments))
  820. return -EFAULT;
  821. Vector<String> environment;
  822. if (!copy_user_strings(params.environment, environment))
  823. return -EFAULT;
  824. auto path = copy_string_from_user(params.path.characters, params.path.length);
  825. int rc = exec(move(path), move(arguments), move(environment));
  826. ASSERT(rc < 0); // We should never continue after a successful exec!
  827. return rc;
  828. }
  829. Process* Process::create_user_process(Thread*& first_thread, const String& path, uid_t uid, gid_t gid, pid_t parent_pid, int& error, Vector<String>&& arguments, Vector<String>&& environment, TTY* tty)
  830. {
  831. // FIXME: Don't split() the path twice (sys$spawn also does it...)
  832. auto parts = path.split('/');
  833. if (arguments.is_empty()) {
  834. arguments.append(parts.last());
  835. }
  836. RefPtr<Custody> cwd;
  837. RefPtr<Custody> root;
  838. {
  839. InterruptDisabler disabler;
  840. if (auto* parent = Process::from_pid(parent_pid)) {
  841. cwd = parent->m_cwd;
  842. root = parent->m_root_directory;
  843. }
  844. }
  845. if (!cwd)
  846. cwd = VFS::the().root_custody();
  847. if (!root)
  848. root = VFS::the().root_custody();
  849. auto* process = new Process(first_thread, parts.take_last(), uid, gid, parent_pid, Ring3, move(cwd), nullptr, tty);
  850. error = process->exec(path, move(arguments), move(environment));
  851. if (error != 0) {
  852. delete process;
  853. return nullptr;
  854. }
  855. {
  856. InterruptDisabler disabler;
  857. g_processes->prepend(process);
  858. }
  859. #ifdef TASK_DEBUG
  860. kprintf("Process %u (%s) spawned @ %p\n", process->pid(), process->name().characters(), first_thread->tss().eip);
  861. #endif
  862. error = 0;
  863. return process;
  864. }
  865. Process* Process::create_kernel_process(Thread*& first_thread, String&& name, void (*e)())
  866. {
  867. auto* process = new Process(first_thread, move(name), (uid_t)0, (gid_t)0, (pid_t)0, Ring0);
  868. first_thread->tss().eip = (u32)e;
  869. if (process->pid() != 0) {
  870. InterruptDisabler disabler;
  871. g_processes->prepend(process);
  872. #ifdef TASK_DEBUG
  873. kprintf("Kernel process %u (%s) spawned @ %p\n", process->pid(), process->name().characters(), first_thread->tss().eip);
  874. #endif
  875. }
  876. first_thread->set_state(Thread::State::Runnable);
  877. return process;
  878. }
  879. Process::Process(Thread*& first_thread, const String& name, uid_t uid, gid_t gid, pid_t ppid, RingLevel ring, RefPtr<Custody> cwd, RefPtr<Custody> executable, TTY* tty, Process* fork_parent)
  880. : m_name(move(name))
  881. , m_pid(allocate_pid())
  882. , m_uid(uid)
  883. , m_gid(gid)
  884. , m_euid(uid)
  885. , m_egid(gid)
  886. , m_ring(ring)
  887. , m_executable(move(executable))
  888. , m_cwd(move(cwd))
  889. , m_tty(tty)
  890. , m_ppid(ppid)
  891. {
  892. dbgprintf("Process: New process PID=%u with name=%s\n", m_pid, m_name.characters());
  893. m_page_directory = PageDirectory::create_for_userspace(*this, fork_parent ? &fork_parent->page_directory().range_allocator() : nullptr);
  894. #ifdef MM_DEBUG
  895. dbgprintf("Process %u ctor: PD=%x created\n", pid(), m_page_directory.ptr());
  896. #endif
  897. // NOTE: fork() doesn't clone all threads; the thread that called fork() becomes the main thread in the new process.
  898. if (fork_parent)
  899. first_thread = current->clone(*this);
  900. else
  901. first_thread = new Thread(*this);
  902. //m_gids.set(m_gid);
  903. if (fork_parent) {
  904. m_sid = fork_parent->m_sid;
  905. m_pgid = fork_parent->m_pgid;
  906. } else {
  907. // FIXME: Use a ProcessHandle? Presumably we're executing *IN* the parent right now though..
  908. InterruptDisabler disabler;
  909. if (auto* parent = Process::from_pid(m_ppid)) {
  910. m_sid = parent->m_sid;
  911. m_pgid = parent->m_pgid;
  912. }
  913. }
  914. if (fork_parent) {
  915. m_fds.resize(fork_parent->m_fds.size());
  916. for (int i = 0; i < fork_parent->m_fds.size(); ++i) {
  917. if (!fork_parent->m_fds[i].description)
  918. continue;
  919. #ifdef FORK_DEBUG
  920. dbgprintf("fork: cloning fd %u... (%p) istty? %u\n", i, fork_parent->m_fds[i].description.ptr(), fork_parent->m_fds[i].description->is_tty());
  921. #endif
  922. m_fds[i] = fork_parent->m_fds[i];
  923. }
  924. } else {
  925. m_fds.resize(m_max_open_file_descriptors);
  926. auto& device_to_use_as_tty = tty ? (CharacterDevice&)*tty : NullDevice::the();
  927. m_fds[0].set(*device_to_use_as_tty.open(O_RDONLY).value());
  928. m_fds[1].set(*device_to_use_as_tty.open(O_WRONLY).value());
  929. m_fds[2].set(*device_to_use_as_tty.open(O_WRONLY).value());
  930. }
  931. if (fork_parent) {
  932. m_sid = fork_parent->m_sid;
  933. m_pgid = fork_parent->m_pgid;
  934. m_umask = fork_parent->m_umask;
  935. }
  936. }
  937. Process::~Process()
  938. {
  939. dbgprintf("~Process{%p} name=%s pid=%d, m_fds=%d, m_thread_count=%u\n", this, m_name.characters(), pid(), m_fds.size(), m_thread_count);
  940. ASSERT(thread_count() == 0);
  941. }
  942. void Process::dump_regions()
  943. {
  944. kprintf("Process %s(%u) regions:\n", name().characters(), pid());
  945. kprintf("BEGIN END SIZE ACCESS NAME\n");
  946. for (auto& region : m_regions) {
  947. kprintf("%08x -- %08x %08x %c%c%c%c%c%c %s\n",
  948. region.vaddr().get(),
  949. region.vaddr().offset(region.size() - 1).get(),
  950. region.size(),
  951. region.is_readable() ? 'R' : ' ',
  952. region.is_writable() ? 'W' : ' ',
  953. region.is_executable() ? 'X' : ' ',
  954. region.is_shared() ? 'S' : ' ',
  955. region.is_stack() ? 'T' : ' ',
  956. region.vmobject().is_purgeable() ? 'P' : ' ',
  957. region.name().characters());
  958. }
  959. }
  960. void Process::sys$exit(int status)
  961. {
  962. cli();
  963. #ifdef TASK_DEBUG
  964. kprintf("sys$exit: %s(%u) exit with status %d\n", name().characters(), pid(), status);
  965. #endif
  966. dump_backtrace();
  967. m_termination_status = status;
  968. m_termination_signal = 0;
  969. die();
  970. current->die_if_needed();
  971. ASSERT_NOT_REACHED();
  972. }
  973. void signal_trampoline_dummy(void)
  974. {
  975. // The trampoline preserves the current eax, pushes the signal code and
  976. // then calls the signal handler. We do this because, when interrupting a
  977. // blocking syscall, that syscall may return some special error code in eax;
  978. // This error code would likely be overwritten by the signal handler, so it's
  979. // neccessary to preserve it here.
  980. asm(
  981. ".intel_syntax noprefix\n"
  982. "asm_signal_trampoline:\n"
  983. "push ebp\n"
  984. "mov ebp, esp\n"
  985. "push eax\n" // we have to store eax 'cause it might be the return value from a syscall
  986. "sub esp, 4\n" // align the stack to 16 bytes
  987. "mov eax, [ebp+12]\n" // push the signal code
  988. "push eax\n"
  989. "call [ebp+8]\n" // call the signal handler
  990. "add esp, 8\n"
  991. "mov eax, %P0\n"
  992. "int 0x82\n" // sigreturn syscall
  993. "asm_signal_trampoline_end:\n"
  994. ".att_syntax" ::"i"(Syscall::SC_sigreturn));
  995. }
  996. extern "C" void asm_signal_trampoline(void);
  997. extern "C" void asm_signal_trampoline_end(void);
  998. void create_signal_trampolines()
  999. {
  1000. InterruptDisabler disabler;
  1001. // NOTE: We leak this region.
  1002. auto* trampoline_region = MM.allocate_user_accessible_kernel_region(PAGE_SIZE, "Signal trampolines", Region::Access::Read | Region::Access::Write | Region::Access::Execute).leak_ptr();
  1003. g_return_to_ring3_from_signal_trampoline = trampoline_region->vaddr();
  1004. u8* trampoline = (u8*)asm_signal_trampoline;
  1005. u8* trampoline_end = (u8*)asm_signal_trampoline_end;
  1006. size_t trampoline_size = trampoline_end - trampoline;
  1007. u8* code_ptr = (u8*)trampoline_region->vaddr().as_ptr();
  1008. copy_to_user(code_ptr, trampoline, trampoline_size);
  1009. trampoline_region->set_writable(false);
  1010. trampoline_region->remap();
  1011. }
  1012. void create_kernel_info_page()
  1013. {
  1014. auto* info_page_region_for_userspace = MM.allocate_user_accessible_kernel_region(PAGE_SIZE, "Kernel info page", Region::Access::Read).leak_ptr();
  1015. auto* info_page_region_for_kernel = MM.allocate_kernel_region_with_vmobject(info_page_region_for_userspace->vmobject(), PAGE_SIZE, "Kernel info page", Region::Access::Read | Region::Access::Write).leak_ptr();
  1016. s_info_page_address_for_userspace = info_page_region_for_userspace->vaddr();
  1017. s_info_page_address_for_kernel = info_page_region_for_kernel->vaddr();
  1018. memset(s_info_page_address_for_kernel.as_ptr(), 0, PAGE_SIZE);
  1019. }
  1020. int Process::sys$sigreturn(RegisterDump& registers)
  1021. {
  1022. SmapDisabler disabler;
  1023. //Here, we restore the state pushed by dispatch signal and asm_signal_trampoline.
  1024. u32* stack_ptr = (u32*)registers.userspace_esp;
  1025. u32 smuggled_eax = *stack_ptr;
  1026. //pop the stored eax, ebp, return address, handler and signal code
  1027. stack_ptr += 5;
  1028. current->m_signal_mask = *stack_ptr;
  1029. stack_ptr++;
  1030. //pop edi, esi, ebp, esp, ebx, edx, ecx and eax
  1031. memcpy(&registers.edi, stack_ptr, 8 * sizeof(u32));
  1032. stack_ptr += 8;
  1033. registers.eip = *stack_ptr;
  1034. stack_ptr++;
  1035. registers.eflags = *stack_ptr;
  1036. stack_ptr++;
  1037. registers.userspace_esp = registers.esp;
  1038. return smuggled_eax;
  1039. }
  1040. void Process::crash(int signal, u32 eip)
  1041. {
  1042. ASSERT_INTERRUPTS_DISABLED();
  1043. ASSERT(!is_dead());
  1044. ASSERT(&current->process() == this);
  1045. if (m_elf_loader && ksyms_ready)
  1046. dbgprintf("\033[31;1m%p %s\033[0m\n", eip, m_elf_loader->symbolicate(eip).characters());
  1047. dump_backtrace();
  1048. m_termination_signal = signal;
  1049. dump_regions();
  1050. ASSERT(is_ring3());
  1051. die();
  1052. // We can not return from here, as there is nowhere
  1053. // to unwind to, so die right away.
  1054. current->die_if_needed();
  1055. ASSERT_NOT_REACHED();
  1056. }
  1057. Process* Process::from_pid(pid_t pid)
  1058. {
  1059. ASSERT_INTERRUPTS_DISABLED();
  1060. for (auto& process : *g_processes) {
  1061. if (process.pid() == pid)
  1062. return &process;
  1063. }
  1064. return nullptr;
  1065. }
  1066. RefPtr<FileDescription> Process::file_description(int fd) const
  1067. {
  1068. if (fd < 0)
  1069. return nullptr;
  1070. if (fd < m_fds.size())
  1071. return m_fds[fd].description.ptr();
  1072. return nullptr;
  1073. }
  1074. int Process::fd_flags(int fd) const
  1075. {
  1076. if (fd < 0)
  1077. return -1;
  1078. if (fd < m_fds.size())
  1079. return m_fds[fd].flags;
  1080. return -1;
  1081. }
  1082. ssize_t Process::sys$get_dir_entries(int fd, void* buffer, ssize_t size)
  1083. {
  1084. if (size < 0)
  1085. return -EINVAL;
  1086. if (!validate_write(buffer, size))
  1087. return -EFAULT;
  1088. auto description = file_description(fd);
  1089. if (!description)
  1090. return -EBADF;
  1091. return description->get_dir_entries((u8*)buffer, size);
  1092. }
  1093. int Process::sys$lseek(int fd, off_t offset, int whence)
  1094. {
  1095. auto description = file_description(fd);
  1096. if (!description)
  1097. return -EBADF;
  1098. return description->seek(offset, whence);
  1099. }
  1100. int Process::sys$ttyname_r(int fd, char* buffer, ssize_t size)
  1101. {
  1102. if (size < 0)
  1103. return -EINVAL;
  1104. if (!validate_write(buffer, size))
  1105. return -EFAULT;
  1106. auto description = file_description(fd);
  1107. if (!description)
  1108. return -EBADF;
  1109. if (!description->is_tty())
  1110. return -ENOTTY;
  1111. String tty_name = description->tty()->tty_name();
  1112. if ((size_t)size < tty_name.length() + 1)
  1113. return -ERANGE;
  1114. copy_to_user(buffer, tty_name.characters(), tty_name.length() + 1);
  1115. return 0;
  1116. }
  1117. int Process::sys$ptsname_r(int fd, char* buffer, ssize_t size)
  1118. {
  1119. if (size < 0)
  1120. return -EINVAL;
  1121. if (!validate_write(buffer, size))
  1122. return -EFAULT;
  1123. auto description = file_description(fd);
  1124. if (!description)
  1125. return -EBADF;
  1126. auto* master_pty = description->master_pty();
  1127. if (!master_pty)
  1128. return -ENOTTY;
  1129. auto pts_name = master_pty->pts_name();
  1130. if ((size_t)size < pts_name.length() + 1)
  1131. return -ERANGE;
  1132. copy_to_user(buffer, pts_name.characters(), pts_name.length() + 1);
  1133. return 0;
  1134. }
  1135. ssize_t Process::sys$writev(int fd, const struct iovec* iov, int iov_count)
  1136. {
  1137. if (iov_count < 0)
  1138. return -EINVAL;
  1139. if (!validate_read_typed(iov, iov_count))
  1140. return -EFAULT;
  1141. u64 total_length = 0;
  1142. Vector<iovec, 32> vecs;
  1143. vecs.ensure_capacity(iov_count);
  1144. copy_from_user(vecs.data(), iov, iov_count * sizeof(iovec));
  1145. for (auto& vec : vecs) {
  1146. if (!validate_read(vec.iov_base, vec.iov_len))
  1147. return -EFAULT;
  1148. total_length += vec.iov_len;
  1149. if (total_length > INT32_MAX)
  1150. return -EINVAL;
  1151. }
  1152. auto description = file_description(fd);
  1153. if (!description)
  1154. return -EBADF;
  1155. if (!description->is_writable())
  1156. return -EBADF;
  1157. int nwritten = 0;
  1158. for (auto& vec : vecs) {
  1159. int rc = do_write(*description, (const u8*)vec.iov_base, vec.iov_len);
  1160. if (rc < 0) {
  1161. if (nwritten == 0)
  1162. return rc;
  1163. return nwritten;
  1164. }
  1165. nwritten += rc;
  1166. }
  1167. return nwritten;
  1168. }
  1169. ssize_t Process::do_write(FileDescription& description, const u8* data, int data_size)
  1170. {
  1171. ssize_t nwritten = 0;
  1172. if (!description.is_blocking()) {
  1173. if (!description.can_write())
  1174. return -EAGAIN;
  1175. }
  1176. if (description.should_append()) {
  1177. #ifdef IO_DEBUG
  1178. dbgprintf("seeking to end (O_APPEND)\n");
  1179. #endif
  1180. description.seek(0, SEEK_END);
  1181. }
  1182. while (nwritten < data_size) {
  1183. #ifdef IO_DEBUG
  1184. dbgprintf("while %u < %u\n", nwritten, size);
  1185. #endif
  1186. if (!description.can_write()) {
  1187. #ifdef IO_DEBUG
  1188. dbgprintf("block write on %d\n", fd);
  1189. #endif
  1190. if (current->block<Thread::WriteBlocker>(description) != Thread::BlockResult::WokeNormally) {
  1191. if (nwritten == 0)
  1192. return -EINTR;
  1193. }
  1194. }
  1195. ssize_t rc = description.write(data + nwritten, data_size - nwritten);
  1196. #ifdef IO_DEBUG
  1197. dbgprintf(" -> write returned %d\n", rc);
  1198. #endif
  1199. if (rc < 0) {
  1200. // FIXME: Support returning partial nwritten with errno.
  1201. ASSERT(nwritten == 0);
  1202. return rc;
  1203. }
  1204. if (rc == 0)
  1205. break;
  1206. nwritten += rc;
  1207. }
  1208. return nwritten;
  1209. }
  1210. ssize_t Process::sys$write(int fd, const u8* data, ssize_t size)
  1211. {
  1212. if (size < 0)
  1213. return -EINVAL;
  1214. if (size == 0)
  1215. return 0;
  1216. if (!validate_read(data, size))
  1217. return -EFAULT;
  1218. #ifdef DEBUG_IO
  1219. dbgprintf("%s(%u): sys$write(%d, %p, %u)\n", name().characters(), pid(), fd, data, size);
  1220. #endif
  1221. auto description = file_description(fd);
  1222. if (!description)
  1223. return -EBADF;
  1224. if (!description->is_writable())
  1225. return -EBADF;
  1226. return do_write(*description, data, size);
  1227. }
  1228. ssize_t Process::sys$read(int fd, u8* buffer, ssize_t size)
  1229. {
  1230. if (size < 0)
  1231. return -EINVAL;
  1232. if (size == 0)
  1233. return 0;
  1234. if (!validate_write(buffer, size))
  1235. return -EFAULT;
  1236. #ifdef DEBUG_IO
  1237. dbgprintf("%s(%u) sys$read(%d, %p, %u)\n", name().characters(), pid(), fd, buffer, size);
  1238. #endif
  1239. auto description = file_description(fd);
  1240. if (!description)
  1241. return -EBADF;
  1242. if (!description->is_readable())
  1243. return -EBADF;
  1244. if (description->is_directory())
  1245. return -EISDIR;
  1246. if (description->is_blocking()) {
  1247. if (!description->can_read()) {
  1248. if (current->block<Thread::ReadBlocker>(*description) != Thread::BlockResult::WokeNormally)
  1249. return -EINTR;
  1250. }
  1251. }
  1252. return description->read(buffer, size);
  1253. }
  1254. int Process::sys$close(int fd)
  1255. {
  1256. auto description = file_description(fd);
  1257. #ifdef DEBUG_IO
  1258. dbgprintf("%s(%u) sys$close(%d) %p\n", name().characters(), pid(), fd, description);
  1259. #endif
  1260. if (!description)
  1261. return -EBADF;
  1262. int rc = description->close();
  1263. m_fds[fd] = {};
  1264. return rc;
  1265. }
  1266. int Process::sys$utime(const char* user_path, size_t path_length, const utimbuf* user_buf)
  1267. {
  1268. if (user_buf && !validate_read_typed(user_buf))
  1269. return -EFAULT;
  1270. auto path = get_syscall_path_argument(user_path, path_length);
  1271. if (path.is_error())
  1272. return path.error();
  1273. utimbuf buf;
  1274. if (user_buf) {
  1275. copy_from_user(&buf, user_buf, sizeof(buf));
  1276. } else {
  1277. auto now = kgettimeofday();
  1278. buf = { now.tv_sec, now.tv_sec };
  1279. }
  1280. return VFS::the().utime(path.value(), current_directory(), buf.actime, buf.modtime);
  1281. }
  1282. int Process::sys$access(const char* user_path, size_t path_length, int mode)
  1283. {
  1284. auto path = get_syscall_path_argument(user_path, path_length);
  1285. if (path.is_error())
  1286. return path.error();
  1287. return VFS::the().access(path.value(), mode, current_directory());
  1288. }
  1289. int Process::sys$fcntl(int fd, int cmd, u32 arg)
  1290. {
  1291. (void)cmd;
  1292. (void)arg;
  1293. dbgprintf("sys$fcntl: fd=%d, cmd=%d, arg=%u\n", fd, cmd, arg);
  1294. auto description = file_description(fd);
  1295. if (!description)
  1296. return -EBADF;
  1297. // NOTE: The FD flags are not shared between FileDescription objects.
  1298. // This means that dup() doesn't copy the FD_CLOEXEC flag!
  1299. switch (cmd) {
  1300. case F_DUPFD: {
  1301. int arg_fd = (int)arg;
  1302. if (arg_fd < 0)
  1303. return -EINVAL;
  1304. int new_fd = alloc_fd(arg_fd);
  1305. if (new_fd < 0)
  1306. return new_fd;
  1307. m_fds[new_fd].set(*description);
  1308. break;
  1309. }
  1310. case F_GETFD:
  1311. return m_fds[fd].flags;
  1312. case F_SETFD:
  1313. m_fds[fd].flags = arg;
  1314. break;
  1315. case F_GETFL:
  1316. return description->file_flags();
  1317. case F_SETFL:
  1318. description->set_file_flags(arg);
  1319. break;
  1320. default:
  1321. ASSERT_NOT_REACHED();
  1322. }
  1323. return 0;
  1324. }
  1325. int Process::sys$fstat(int fd, stat* statbuf)
  1326. {
  1327. if (!validate_write_typed(statbuf))
  1328. return -EFAULT;
  1329. auto description = file_description(fd);
  1330. if (!description)
  1331. return -EBADF;
  1332. return description->fstat(*statbuf);
  1333. }
  1334. int Process::sys$lstat(const char* user_path, size_t path_length, stat* user_statbuf)
  1335. {
  1336. if (!validate_write_typed(user_statbuf))
  1337. return -EFAULT;
  1338. auto path = get_syscall_path_argument(user_path, path_length);
  1339. if (path.is_error())
  1340. return path.error();
  1341. auto metadata_or_error = VFS::the().lookup_metadata(path.value(), current_directory(), O_NOFOLLOW_NOERROR);
  1342. if (metadata_or_error.is_error())
  1343. return metadata_or_error.error();
  1344. stat statbuf;
  1345. auto result = metadata_or_error.value().stat(statbuf);
  1346. if (result.is_error())
  1347. return result;
  1348. copy_to_user(user_statbuf, &statbuf, sizeof(statbuf));
  1349. return 0;
  1350. }
  1351. int Process::sys$stat(const char* user_path, size_t path_length, stat* user_statbuf)
  1352. {
  1353. if (!validate_write_typed(user_statbuf))
  1354. return -EFAULT;
  1355. auto path = get_syscall_path_argument(user_path, path_length);
  1356. if (path.is_error())
  1357. return path.error();
  1358. auto metadata_or_error = VFS::the().lookup_metadata(path.value(), current_directory());
  1359. if (metadata_or_error.is_error())
  1360. return metadata_or_error.error();
  1361. stat statbuf;
  1362. auto result = metadata_or_error.value().stat(statbuf);
  1363. if (result.is_error())
  1364. return result;
  1365. copy_to_user(user_statbuf, &statbuf, sizeof(statbuf));
  1366. return 0;
  1367. }
  1368. template<typename DataType, typename SizeType>
  1369. bool Process::validate(const Syscall::MutableBufferArgument<DataType, SizeType>& buffer)
  1370. {
  1371. return validate_write(buffer.data, buffer.size);
  1372. }
  1373. String Process::validate_and_copy_string_from_user(const Syscall::StringArgument& string) const
  1374. {
  1375. if (!validate_read(string.characters, string.length))
  1376. return {};
  1377. SmapDisabler disabler;
  1378. size_t length = strnlen(string.characters, string.length);
  1379. return String(string.characters, length);
  1380. }
  1381. int Process::sys$readlink(const Syscall::SC_readlink_params* user_params)
  1382. {
  1383. if (!validate_read_typed(user_params))
  1384. return -EFAULT;
  1385. Syscall::SC_readlink_params params;
  1386. copy_from_user(&params, user_params, sizeof(params));
  1387. if (!validate(params.buffer))
  1388. return -EFAULT;
  1389. auto path = get_syscall_path_argument(params.path.characters, params.path.length);
  1390. if (path.is_error())
  1391. return path.error();
  1392. auto result = VFS::the().open(path.value(), O_RDONLY | O_NOFOLLOW_NOERROR, 0, current_directory());
  1393. if (result.is_error())
  1394. return result.error();
  1395. auto description = result.value();
  1396. if (!description->metadata().is_symlink())
  1397. return -EINVAL;
  1398. auto contents = description->read_entire_file();
  1399. if (!contents)
  1400. return -EIO; // FIXME: Get a more detailed error from VFS.
  1401. auto link_target = String::copy(contents);
  1402. if (link_target.length() + 1 > params.buffer.size)
  1403. return -ENAMETOOLONG;
  1404. copy_to_user(params.buffer.data, link_target.characters(), link_target.length() + 1);
  1405. return 0;
  1406. }
  1407. int Process::sys$chdir(const char* user_path, size_t path_length)
  1408. {
  1409. auto path = get_syscall_path_argument(user_path, path_length);
  1410. if (path.is_error())
  1411. return path.error();
  1412. auto directory_or_error = VFS::the().open_directory(path.value(), current_directory());
  1413. if (directory_or_error.is_error())
  1414. return directory_or_error.error();
  1415. m_cwd = *directory_or_error.value();
  1416. return 0;
  1417. }
  1418. int Process::sys$fchdir(int fd)
  1419. {
  1420. auto description = file_description(fd);
  1421. if (!description)
  1422. return -EBADF;
  1423. if (!description->is_directory())
  1424. return -ENOTDIR;
  1425. if (!description->metadata().may_execute(*this))
  1426. return -EACCES;
  1427. m_cwd = description->custody();
  1428. return 0;
  1429. }
  1430. int Process::sys$getcwd(char* buffer, ssize_t size)
  1431. {
  1432. if (size < 0)
  1433. return -EINVAL;
  1434. if (!validate_write(buffer, size))
  1435. return -EFAULT;
  1436. auto path = current_directory().absolute_path();
  1437. if ((size_t)size < path.length() + 1)
  1438. return -ERANGE;
  1439. copy_to_user(buffer, path.characters(), path.length() + 1);
  1440. return 0;
  1441. }
  1442. int Process::number_of_open_file_descriptors() const
  1443. {
  1444. int count = 0;
  1445. for (auto& description : m_fds) {
  1446. if (description)
  1447. ++count;
  1448. }
  1449. return count;
  1450. }
  1451. int Process::sys$open(const Syscall::SC_open_params* user_params)
  1452. {
  1453. if (!validate_read_typed(user_params))
  1454. return -EFAULT;
  1455. Syscall::SC_open_params params;
  1456. copy_from_user(&params, user_params, sizeof(params));
  1457. auto options = params.options;
  1458. auto mode = params.mode;
  1459. if (params.path_length <= 0)
  1460. return -EINVAL;
  1461. if (!validate_read(params.path, params.path_length))
  1462. return -EFAULT;
  1463. // Ignore everything except permission bits.
  1464. mode &= 04777;
  1465. String path = copy_string_from_user(params.path, params.path_length);
  1466. int fd = alloc_fd();
  1467. #ifdef DEBUG_IO
  1468. dbgprintf("%s(%u) sys$open(\"%s\") -> %d\n", name().characters(), pid(), path, fd);
  1469. #endif
  1470. if (fd < 0)
  1471. return fd;
  1472. auto result = VFS::the().open(path, options, mode & ~umask(), current_directory());
  1473. if (result.is_error())
  1474. return result.error();
  1475. auto description = result.value();
  1476. description->set_rw_mode(options);
  1477. description->set_file_flags(options);
  1478. u32 fd_flags = (options & O_CLOEXEC) ? FD_CLOEXEC : 0;
  1479. m_fds[fd].set(move(description), fd_flags);
  1480. return fd;
  1481. }
  1482. int Process::sys$openat(const Syscall::SC_openat_params* user_params)
  1483. {
  1484. if (!validate_read_typed(user_params))
  1485. return -EFAULT;
  1486. Syscall::SC_openat_params params;
  1487. copy_from_user(&params, user_params, sizeof(params));
  1488. int dirfd = params.dirfd;
  1489. int options = params.options;
  1490. u16 mode = params.mode;
  1491. // Ignore everything except permission bits.
  1492. mode &= 04777;
  1493. if (params.path_length <= 0)
  1494. return -EINVAL;
  1495. if (!validate_read(params.path, params.path_length))
  1496. return -EFAULT;
  1497. auto path = copy_string_from_user(params.path, params.path_length);
  1498. #ifdef DEBUG_IO
  1499. dbgprintf("%s(%u) sys$openat(%d, \"%s\")\n", dirfd, name().characters(), pid(), path);
  1500. #endif
  1501. int fd = alloc_fd();
  1502. if (fd < 0)
  1503. return fd;
  1504. RefPtr<Custody> base;
  1505. if (dirfd == AT_FDCWD) {
  1506. base = current_directory();
  1507. } else {
  1508. auto base_description = file_description(dirfd);
  1509. if (!base_description)
  1510. return -EBADF;
  1511. if (!base_description->is_directory())
  1512. return -ENOTDIR;
  1513. if (!base_description->custody())
  1514. return -EINVAL;
  1515. base = base_description->custody();
  1516. }
  1517. auto result = VFS::the().open(path, options, mode & ~umask(), *base);
  1518. if (result.is_error())
  1519. return result.error();
  1520. auto description = result.value();
  1521. description->set_rw_mode(options);
  1522. description->set_file_flags(options);
  1523. u32 fd_flags = (options & O_CLOEXEC) ? FD_CLOEXEC : 0;
  1524. m_fds[fd].set(move(description), fd_flags);
  1525. return fd;
  1526. }
  1527. int Process::alloc_fd(int first_candidate_fd)
  1528. {
  1529. int fd = -EMFILE;
  1530. for (int i = first_candidate_fd; i < (int)m_max_open_file_descriptors; ++i) {
  1531. if (!m_fds[i]) {
  1532. fd = i;
  1533. break;
  1534. }
  1535. }
  1536. return fd;
  1537. }
  1538. int Process::sys$pipe(int pipefd[2], int flags)
  1539. {
  1540. if (!validate_write_typed(pipefd))
  1541. return -EFAULT;
  1542. if (number_of_open_file_descriptors() + 2 > max_open_file_descriptors())
  1543. return -EMFILE;
  1544. // Reject flags other than O_CLOEXEC.
  1545. if ((flags & O_CLOEXEC) != flags)
  1546. return -EINVAL;
  1547. u32 fd_flags = (flags & O_CLOEXEC) ? FD_CLOEXEC : 0;
  1548. auto fifo = FIFO::create(m_uid);
  1549. int reader_fd = alloc_fd();
  1550. m_fds[reader_fd].set(fifo->open_direction(FIFO::Direction::Reader), fd_flags);
  1551. m_fds[reader_fd].description->set_readable(true);
  1552. copy_to_user(&pipefd[0], &reader_fd, sizeof(reader_fd));
  1553. int writer_fd = alloc_fd();
  1554. m_fds[writer_fd].set(fifo->open_direction(FIFO::Direction::Writer), fd_flags);
  1555. m_fds[writer_fd].description->set_writable(true);
  1556. copy_to_user(&pipefd[1], &writer_fd, sizeof(writer_fd));
  1557. return 0;
  1558. }
  1559. int Process::sys$killpg(int pgrp, int signum)
  1560. {
  1561. if (signum < 1 || signum >= 32)
  1562. return -EINVAL;
  1563. if (pgrp < 0)
  1564. return -EINVAL;
  1565. InterruptDisabler disabler;
  1566. return do_killpg(pgrp, signum);
  1567. }
  1568. int Process::sys$setuid(uid_t uid)
  1569. {
  1570. if (uid != m_uid && !is_superuser())
  1571. return -EPERM;
  1572. m_uid = uid;
  1573. m_euid = uid;
  1574. return 0;
  1575. }
  1576. int Process::sys$setgid(gid_t gid)
  1577. {
  1578. if (gid != m_gid && !is_superuser())
  1579. return -EPERM;
  1580. m_gid = gid;
  1581. m_egid = gid;
  1582. return 0;
  1583. }
  1584. unsigned Process::sys$alarm(unsigned seconds)
  1585. {
  1586. unsigned previous_alarm_remaining = 0;
  1587. if (m_alarm_deadline && m_alarm_deadline > g_uptime) {
  1588. previous_alarm_remaining = (m_alarm_deadline - g_uptime) / TICKS_PER_SECOND;
  1589. }
  1590. if (!seconds) {
  1591. m_alarm_deadline = 0;
  1592. return previous_alarm_remaining;
  1593. }
  1594. m_alarm_deadline = g_uptime + seconds * TICKS_PER_SECOND;
  1595. return previous_alarm_remaining;
  1596. }
  1597. int Process::sys$uname(utsname* buf)
  1598. {
  1599. if (!validate_write_typed(buf))
  1600. return -EFAULT;
  1601. LOCKER(*s_hostname_lock);
  1602. if (s_hostname->length() + 1 > sizeof(utsname::nodename))
  1603. return -ENAMETOOLONG;
  1604. copy_to_user(buf->sysname, "SerenityOS", 11);
  1605. copy_to_user(buf->release, "1.0-dev", 8);
  1606. copy_to_user(buf->version, "FIXME", 6);
  1607. copy_to_user(buf->machine, "i686", 5);
  1608. copy_to_user(buf->nodename, s_hostname->characters(), s_hostname->length() + 1);
  1609. return 0;
  1610. }
  1611. KResult Process::do_kill(Process& process, int signal)
  1612. {
  1613. // FIXME: Allow sending SIGCONT to everyone in the process group.
  1614. // FIXME: Should setuid processes have some special treatment here?
  1615. if (!is_superuser() && m_euid != process.m_uid && m_uid != process.m_uid)
  1616. return KResult(-EPERM);
  1617. if (process.is_ring0() && signal == SIGKILL) {
  1618. kprintf("%s(%u) attempted to send SIGKILL to ring 0 process %s(%u)\n", name().characters(), m_pid, process.name().characters(), process.pid());
  1619. return KResult(-EPERM);
  1620. }
  1621. if (signal != 0)
  1622. process.send_signal(signal, this);
  1623. return KSuccess;
  1624. }
  1625. KResult Process::do_killpg(pid_t pgrp, int signal)
  1626. {
  1627. ASSERT(pgrp >= 0);
  1628. // Send the signal to all processes in the given group.
  1629. if (pgrp == 0) {
  1630. // Send the signal to our own pgrp.
  1631. pgrp = pgid();
  1632. }
  1633. bool group_was_empty = true;
  1634. bool any_succeeded = false;
  1635. KResult error = KSuccess;
  1636. Process::for_each_in_pgrp(pgrp, [&](auto& process) {
  1637. group_was_empty = false;
  1638. KResult res = do_kill(process, signal);
  1639. if (res.is_success())
  1640. any_succeeded = true;
  1641. else
  1642. error = res;
  1643. return IterationDecision::Continue;
  1644. });
  1645. if (group_was_empty)
  1646. return KResult(-ESRCH);
  1647. if (any_succeeded)
  1648. return KSuccess;
  1649. return error;
  1650. }
  1651. int Process::sys$kill(pid_t pid, int signal)
  1652. {
  1653. if (signal < 0 || signal >= 32)
  1654. return -EINVAL;
  1655. if (pid <= 0)
  1656. return do_killpg(-pid, signal);
  1657. if (pid == -1) {
  1658. // FIXME: Send to all processes.
  1659. return -ENOTIMPL;
  1660. }
  1661. if (pid == m_pid) {
  1662. if (signal == 0)
  1663. return 0;
  1664. if (!current->should_ignore_signal(signal)) {
  1665. current->send_signal(signal, this);
  1666. (void)current->block<Thread::SemiPermanentBlocker>(Thread::SemiPermanentBlocker::Reason::Signal);
  1667. }
  1668. return 0;
  1669. }
  1670. InterruptDisabler disabler;
  1671. auto* peer = Process::from_pid(pid);
  1672. if (!peer)
  1673. return -ESRCH;
  1674. return do_kill(*peer, signal);
  1675. }
  1676. int Process::sys$usleep(useconds_t usec)
  1677. {
  1678. if (!usec)
  1679. return 0;
  1680. u64 wakeup_time = current->sleep(usec / 1000);
  1681. if (wakeup_time > g_uptime)
  1682. return -EINTR;
  1683. return 0;
  1684. }
  1685. int Process::sys$sleep(unsigned seconds)
  1686. {
  1687. if (!seconds)
  1688. return 0;
  1689. u64 wakeup_time = current->sleep(seconds * TICKS_PER_SECOND);
  1690. if (wakeup_time > g_uptime) {
  1691. u32 ticks_left_until_original_wakeup_time = wakeup_time - g_uptime;
  1692. return ticks_left_until_original_wakeup_time / TICKS_PER_SECOND;
  1693. }
  1694. return 0;
  1695. }
  1696. timeval kgettimeofday()
  1697. {
  1698. return const_cast<const timeval&>(((KernelInfoPage*)s_info_page_address_for_kernel.as_ptr())->now);
  1699. }
  1700. void kgettimeofday(timeval& tv)
  1701. {
  1702. tv = kgettimeofday();
  1703. }
  1704. int Process::sys$gettimeofday(timeval* tv)
  1705. {
  1706. if (!validate_write_typed(tv))
  1707. return -EFAULT;
  1708. *tv = kgettimeofday();
  1709. return 0;
  1710. }
  1711. uid_t Process::sys$getuid()
  1712. {
  1713. return m_uid;
  1714. }
  1715. gid_t Process::sys$getgid()
  1716. {
  1717. return m_gid;
  1718. }
  1719. uid_t Process::sys$geteuid()
  1720. {
  1721. return m_euid;
  1722. }
  1723. gid_t Process::sys$getegid()
  1724. {
  1725. return m_egid;
  1726. }
  1727. pid_t Process::sys$getpid()
  1728. {
  1729. return m_pid;
  1730. }
  1731. pid_t Process::sys$getppid()
  1732. {
  1733. return m_ppid;
  1734. }
  1735. mode_t Process::sys$umask(mode_t mask)
  1736. {
  1737. auto old_mask = m_umask;
  1738. m_umask = mask & 0777;
  1739. return old_mask;
  1740. }
  1741. int Process::reap(Process& process)
  1742. {
  1743. int exit_status;
  1744. {
  1745. InterruptDisabler disabler;
  1746. exit_status = (process.m_termination_status << 8) | process.m_termination_signal;
  1747. if (process.ppid()) {
  1748. auto* parent = Process::from_pid(process.ppid());
  1749. if (parent) {
  1750. parent->m_ticks_in_user_for_dead_children += process.m_ticks_in_user + process.m_ticks_in_user_for_dead_children;
  1751. parent->m_ticks_in_kernel_for_dead_children += process.m_ticks_in_kernel + process.m_ticks_in_kernel_for_dead_children;
  1752. }
  1753. }
  1754. dbgprintf("reap: %s(%u)\n", process.name().characters(), process.pid());
  1755. ASSERT(process.is_dead());
  1756. g_processes->remove(&process);
  1757. }
  1758. delete &process;
  1759. return exit_status;
  1760. }
  1761. pid_t Process::sys$waitpid(pid_t waitee, int* wstatus, int options)
  1762. {
  1763. dbgprintf("sys$waitpid(%d, %p, %d)\n", waitee, wstatus, options);
  1764. if (!options) {
  1765. // FIXME: This can't be right.. can it? Figure out how this should actually work.
  1766. options = WEXITED;
  1767. }
  1768. if (wstatus && !validate_write_typed(wstatus))
  1769. return -EFAULT;
  1770. int exit_status = 0;
  1771. {
  1772. InterruptDisabler disabler;
  1773. if (waitee != -1 && !Process::from_pid(waitee))
  1774. return -ECHILD;
  1775. }
  1776. if (options & WNOHANG) {
  1777. // FIXME: Figure out what WNOHANG should do with stopped children.
  1778. if (waitee == -1) {
  1779. pid_t reaped_pid = 0;
  1780. InterruptDisabler disabler;
  1781. for_each_child([&reaped_pid, &exit_status](Process& process) {
  1782. if (process.is_dead()) {
  1783. reaped_pid = process.pid();
  1784. exit_status = reap(process);
  1785. }
  1786. return IterationDecision::Continue;
  1787. });
  1788. return reaped_pid;
  1789. } else {
  1790. ASSERT(waitee > 0); // FIXME: Implement other PID specs.
  1791. InterruptDisabler disabler;
  1792. auto* waitee_process = Process::from_pid(waitee);
  1793. if (!waitee_process)
  1794. return -ECHILD;
  1795. if (waitee_process->is_dead()) {
  1796. exit_status = reap(*waitee_process);
  1797. return waitee;
  1798. }
  1799. return 0;
  1800. }
  1801. }
  1802. pid_t waitee_pid = waitee;
  1803. if (current->block<Thread::WaitBlocker>(options, waitee_pid) != Thread::BlockResult::WokeNormally)
  1804. return -EINTR;
  1805. InterruptDisabler disabler;
  1806. // NOTE: If waitee was -1, m_waitee_pid will have been filled in by the scheduler.
  1807. Process* waitee_process = Process::from_pid(waitee_pid);
  1808. if (!waitee_process)
  1809. return -ECHILD;
  1810. ASSERT(waitee_process);
  1811. if (waitee_process->is_dead()) {
  1812. exit_status = reap(*waitee_process);
  1813. } else {
  1814. ASSERT(waitee_process->any_thread().state() == Thread::State::Stopped);
  1815. exit_status = 0x7f;
  1816. }
  1817. if (wstatus)
  1818. copy_to_user(wstatus, &exit_status, sizeof(exit_status));
  1819. return waitee_pid;
  1820. }
  1821. bool Process::validate_read_from_kernel(VirtualAddress vaddr, ssize_t size) const
  1822. {
  1823. if (vaddr.is_null())
  1824. return false;
  1825. // We check extra carefully here since the first 4MB of the address space is identity-mapped.
  1826. // This code allows access outside of the known used address ranges to get caught.
  1827. if (is_kmalloc_address(vaddr.as_ptr()))
  1828. return true;
  1829. return MM.validate_kernel_read(*this, vaddr, size);
  1830. }
  1831. bool Process::validate_read(const void* address, ssize_t size) const
  1832. {
  1833. ASSERT(size >= 0);
  1834. VirtualAddress first_address((u32)address);
  1835. if (is_ring0()) {
  1836. if (is_kmalloc_address(address))
  1837. return true;
  1838. }
  1839. if (!size)
  1840. return false;
  1841. return MM.validate_user_read(*this, first_address, size);
  1842. }
  1843. bool Process::validate_write(void* address, ssize_t size) const
  1844. {
  1845. ASSERT(size >= 0);
  1846. VirtualAddress first_address((u32)address);
  1847. if (is_ring0()) {
  1848. if (is_kmalloc_address(address))
  1849. return true;
  1850. }
  1851. if (!size)
  1852. return false;
  1853. return MM.validate_user_write(*this, first_address, size);
  1854. }
  1855. pid_t Process::sys$getsid(pid_t pid)
  1856. {
  1857. if (pid == 0)
  1858. return m_sid;
  1859. InterruptDisabler disabler;
  1860. auto* process = Process::from_pid(pid);
  1861. if (!process)
  1862. return -ESRCH;
  1863. if (m_sid != process->m_sid)
  1864. return -EPERM;
  1865. return process->m_sid;
  1866. }
  1867. pid_t Process::sys$setsid()
  1868. {
  1869. InterruptDisabler disabler;
  1870. bool found_process_with_same_pgid_as_my_pid = false;
  1871. Process::for_each_in_pgrp(pid(), [&](auto&) {
  1872. found_process_with_same_pgid_as_my_pid = true;
  1873. return IterationDecision::Break;
  1874. });
  1875. if (found_process_with_same_pgid_as_my_pid)
  1876. return -EPERM;
  1877. m_sid = m_pid;
  1878. m_pgid = m_pid;
  1879. return m_sid;
  1880. }
  1881. pid_t Process::sys$getpgid(pid_t pid)
  1882. {
  1883. if (pid == 0)
  1884. return m_pgid;
  1885. InterruptDisabler disabler; // FIXME: Use a ProcessHandle
  1886. auto* process = Process::from_pid(pid);
  1887. if (!process)
  1888. return -ESRCH;
  1889. return process->m_pgid;
  1890. }
  1891. pid_t Process::sys$getpgrp()
  1892. {
  1893. return m_pgid;
  1894. }
  1895. static pid_t get_sid_from_pgid(pid_t pgid)
  1896. {
  1897. InterruptDisabler disabler;
  1898. auto* group_leader = Process::from_pid(pgid);
  1899. if (!group_leader)
  1900. return -1;
  1901. return group_leader->sid();
  1902. }
  1903. int Process::sys$setpgid(pid_t specified_pid, pid_t specified_pgid)
  1904. {
  1905. InterruptDisabler disabler; // FIXME: Use a ProcessHandle
  1906. pid_t pid = specified_pid ? specified_pid : m_pid;
  1907. if (specified_pgid < 0) {
  1908. // The value of the pgid argument is less than 0, or is not a value supported by the implementation.
  1909. return -EINVAL;
  1910. }
  1911. auto* process = Process::from_pid(pid);
  1912. if (!process)
  1913. return -ESRCH;
  1914. if (process != this && process->ppid() != m_pid) {
  1915. // The value of the pid argument does not match the process ID
  1916. // of the calling process or of a child process of the calling process.
  1917. return -ESRCH;
  1918. }
  1919. if (process->pid() == process->sid()) {
  1920. // The process indicated by the pid argument is a session leader.
  1921. return -EPERM;
  1922. }
  1923. if (process->ppid() == m_pid && process->sid() != sid()) {
  1924. // The value of the pid argument matches the process ID of a child
  1925. // process of the calling process and the child process is not in
  1926. // the same session as the calling process.
  1927. return -EPERM;
  1928. }
  1929. pid_t new_pgid = specified_pgid ? specified_pgid : process->m_pid;
  1930. pid_t current_sid = get_sid_from_pgid(process->m_pgid);
  1931. pid_t new_sid = get_sid_from_pgid(new_pgid);
  1932. if (current_sid != new_sid) {
  1933. // Can't move a process between sessions.
  1934. return -EPERM;
  1935. }
  1936. // FIXME: There are more EPERM conditions to check for here..
  1937. process->m_pgid = new_pgid;
  1938. return 0;
  1939. }
  1940. int Process::sys$ioctl(int fd, unsigned request, unsigned arg)
  1941. {
  1942. auto description = file_description(fd);
  1943. if (!description)
  1944. return -EBADF;
  1945. SmapDisabler disabler;
  1946. return description->file().ioctl(*description, request, arg);
  1947. }
  1948. int Process::sys$getdtablesize()
  1949. {
  1950. return m_max_open_file_descriptors;
  1951. }
  1952. int Process::sys$dup(int old_fd)
  1953. {
  1954. auto description = file_description(old_fd);
  1955. if (!description)
  1956. return -EBADF;
  1957. int new_fd = alloc_fd(0);
  1958. if (new_fd < 0)
  1959. return new_fd;
  1960. m_fds[new_fd].set(*description);
  1961. return new_fd;
  1962. }
  1963. int Process::sys$dup2(int old_fd, int new_fd)
  1964. {
  1965. auto description = file_description(old_fd);
  1966. if (!description)
  1967. return -EBADF;
  1968. if (new_fd < 0 || new_fd >= m_max_open_file_descriptors)
  1969. return -EINVAL;
  1970. m_fds[new_fd].set(*description);
  1971. return new_fd;
  1972. }
  1973. int Process::sys$sigprocmask(int how, const sigset_t* set, sigset_t* old_set)
  1974. {
  1975. if (old_set) {
  1976. if (!validate_write_typed(old_set))
  1977. return -EFAULT;
  1978. copy_to_user(old_set, &current->m_signal_mask, sizeof(current->m_signal_mask));
  1979. }
  1980. if (set) {
  1981. if (!validate_read_typed(set))
  1982. return -EFAULT;
  1983. sigset_t set_value;
  1984. copy_from_user(&set_value, set, sizeof(set_value));
  1985. switch (how) {
  1986. case SIG_BLOCK:
  1987. current->m_signal_mask &= ~set_value;
  1988. break;
  1989. case SIG_UNBLOCK:
  1990. current->m_signal_mask |= set_value;
  1991. break;
  1992. case SIG_SETMASK:
  1993. current->m_signal_mask = set_value;
  1994. break;
  1995. default:
  1996. return -EINVAL;
  1997. }
  1998. }
  1999. return 0;
  2000. }
  2001. int Process::sys$sigpending(sigset_t* set)
  2002. {
  2003. if (!validate_write_typed(set))
  2004. return -EFAULT;
  2005. copy_to_user(set, &current->m_pending_signals, sizeof(current->m_pending_signals));
  2006. return 0;
  2007. }
  2008. int Process::sys$sigaction(int signum, const sigaction* act, sigaction* old_act)
  2009. {
  2010. if (signum < 1 || signum >= 32 || signum == SIGKILL || signum == SIGSTOP)
  2011. return -EINVAL;
  2012. if (!validate_read_typed(act))
  2013. return -EFAULT;
  2014. InterruptDisabler disabler; // FIXME: This should use a narrower lock. Maybe a way to ignore signals temporarily?
  2015. auto& action = current->m_signal_action_data[signum];
  2016. if (old_act) {
  2017. if (!validate_write_typed(old_act))
  2018. return -EFAULT;
  2019. copy_to_user(&old_act->sa_flags, &action.flags, sizeof(action.flags));
  2020. copy_to_user(&old_act->sa_sigaction, &action.handler_or_sigaction, sizeof(action.handler_or_sigaction));
  2021. }
  2022. copy_from_user(&action.flags, &act->sa_flags, sizeof(action.flags));
  2023. copy_from_user(&action.handler_or_sigaction, &act->sa_sigaction, sizeof(action.flags));
  2024. return 0;
  2025. }
  2026. int Process::sys$getgroups(ssize_t count, gid_t* gids)
  2027. {
  2028. if (count < 0)
  2029. return -EINVAL;
  2030. if (!count)
  2031. return m_extra_gids.size();
  2032. if (count != (int)m_extra_gids.size())
  2033. return -EINVAL;
  2034. if (!validate_write_typed(gids, m_extra_gids.size()))
  2035. return -EFAULT;
  2036. size_t i = 0;
  2037. SmapDisabler disabler;
  2038. for (auto gid : m_extra_gids)
  2039. gids[i++] = gid;
  2040. return 0;
  2041. }
  2042. int Process::sys$setgroups(ssize_t count, const gid_t* gids)
  2043. {
  2044. if (count < 0)
  2045. return -EINVAL;
  2046. if (!is_superuser())
  2047. return -EPERM;
  2048. if (count && !validate_read(gids, count))
  2049. return -EFAULT;
  2050. m_extra_gids.clear();
  2051. SmapDisabler disabler;
  2052. for (int i = 0; i < count; ++i) {
  2053. if (gids[i] == m_gid)
  2054. continue;
  2055. m_extra_gids.set(gids[i]);
  2056. }
  2057. return 0;
  2058. }
  2059. int Process::sys$mkdir(const char* user_path, size_t path_length, mode_t mode)
  2060. {
  2061. auto path = get_syscall_path_argument(user_path, path_length);
  2062. if (path.is_error())
  2063. return path.error();
  2064. return VFS::the().mkdir(path.value(), mode & ~umask(), current_directory());
  2065. }
  2066. int Process::sys$realpath(const Syscall::SC_realpath_params* user_params)
  2067. {
  2068. if (!validate_read_typed(user_params))
  2069. return -EFAULT;
  2070. Syscall::SC_realpath_params params;
  2071. copy_from_user(&params, user_params, sizeof(params));
  2072. if (!validate_write(params.buffer, params.buffer_size))
  2073. return -EFAULT;
  2074. auto path = get_syscall_path_argument(params.path, params.path_length);
  2075. if (path.is_error())
  2076. return path.error();
  2077. auto custody_or_error = VFS::the().resolve_path(path.value(), current_directory());
  2078. if (custody_or_error.is_error())
  2079. return custody_or_error.error();
  2080. auto& custody = custody_or_error.value();
  2081. // FIXME: Once resolve_path is fixed to deal with .. and . , remove the use of FileSystemPath::canonical_path.
  2082. FileSystemPath canonical_path(custody->absolute_path());
  2083. if (!canonical_path.is_valid()) {
  2084. dbg() << "FileSystemPath failed to canonicalize " << custody->absolute_path();
  2085. ASSERT_NOT_REACHED();
  2086. }
  2087. if (canonical_path.string().length() + 1 > params.buffer_size)
  2088. return -ENAMETOOLONG;
  2089. copy_to_user(params.buffer, canonical_path.string().characters(), canonical_path.string().length() + 1);
  2090. return 0;
  2091. };
  2092. clock_t Process::sys$times(tms* times)
  2093. {
  2094. if (!validate_write_typed(times))
  2095. return -EFAULT;
  2096. copy_to_user(&times->tms_utime, &m_ticks_in_user, sizeof(m_ticks_in_user));
  2097. copy_to_user(&times->tms_stime, &m_ticks_in_kernel, sizeof(m_ticks_in_kernel));
  2098. copy_to_user(&times->tms_cutime, &m_ticks_in_user_for_dead_children, sizeof(m_ticks_in_user_for_dead_children));
  2099. copy_to_user(&times->tms_cstime, &m_ticks_in_kernel_for_dead_children, sizeof(m_ticks_in_kernel_for_dead_children));
  2100. return g_uptime & 0x7fffffff;
  2101. }
  2102. int Process::sys$select(const Syscall::SC_select_params* params)
  2103. {
  2104. // FIXME: Return -EINVAL if timeout is invalid.
  2105. if (!validate_read_typed(params))
  2106. return -EFAULT;
  2107. SmapDisabler disabler;
  2108. int nfds = params->nfds;
  2109. fd_set* readfds = params->readfds;
  2110. fd_set* writefds = params->writefds;
  2111. fd_set* exceptfds = params->exceptfds;
  2112. timeval* timeout = params->timeout;
  2113. if (writefds && !validate_write_typed(writefds))
  2114. return -EFAULT;
  2115. if (readfds && !validate_write_typed(readfds))
  2116. return -EFAULT;
  2117. if (exceptfds && !validate_write_typed(exceptfds))
  2118. return -EFAULT;
  2119. if (timeout && !validate_read_typed(timeout))
  2120. return -EFAULT;
  2121. if (nfds < 0)
  2122. return -EINVAL;
  2123. timeval computed_timeout;
  2124. bool select_has_timeout = false;
  2125. if (timeout && (timeout->tv_sec || timeout->tv_usec)) {
  2126. timeval_add(kgettimeofday(), *timeout, computed_timeout);
  2127. select_has_timeout = true;
  2128. }
  2129. Thread::SelectBlocker::FDVector rfds;
  2130. Thread::SelectBlocker::FDVector wfds;
  2131. Thread::SelectBlocker::FDVector efds;
  2132. auto transfer_fds = [&](auto* fds, auto& vector) -> int {
  2133. vector.clear_with_capacity();
  2134. if (!fds)
  2135. return 0;
  2136. for (int fd = 0; fd < nfds; ++fd) {
  2137. if (FD_ISSET(fd, fds)) {
  2138. if (!file_description(fd)) {
  2139. dbg() << *current << " sys$select: Bad fd number " << fd;
  2140. return -EBADF;
  2141. }
  2142. vector.append(fd);
  2143. }
  2144. }
  2145. return 0;
  2146. };
  2147. if (int error = transfer_fds(writefds, wfds))
  2148. return error;
  2149. if (int error = transfer_fds(readfds, rfds))
  2150. return error;
  2151. if (int error = transfer_fds(exceptfds, efds))
  2152. return error;
  2153. #if defined(DEBUG_IO) || defined(DEBUG_POLL_SELECT)
  2154. dbgprintf("%s<%u> selecting on (read:%u, write:%u), timeout=%p\n", name().characters(), pid(), rfds.size(), wfds.size(), timeout);
  2155. #endif
  2156. if (!timeout || select_has_timeout) {
  2157. if (current->block<Thread::SelectBlocker>(computed_timeout, select_has_timeout, rfds, wfds, efds) != Thread::BlockResult::WokeNormally)
  2158. return -EINTR;
  2159. }
  2160. int marked_fd_count = 0;
  2161. auto mark_fds = [&](auto* fds, auto& vector, auto should_mark) {
  2162. if (!fds)
  2163. return;
  2164. FD_ZERO(fds);
  2165. for (int fd : vector) {
  2166. if (auto description = file_description(fd); description && should_mark(*description)) {
  2167. FD_SET(fd, fds);
  2168. ++marked_fd_count;
  2169. }
  2170. }
  2171. };
  2172. mark_fds(readfds, rfds, [](auto& description) { return description.can_read(); });
  2173. mark_fds(writefds, wfds, [](auto& description) { return description.can_write(); });
  2174. // FIXME: We should also mark exceptfds as appropriate.
  2175. return marked_fd_count;
  2176. }
  2177. int Process::sys$poll(pollfd* fds, int nfds, int timeout)
  2178. {
  2179. if (!validate_read_typed(fds))
  2180. return -EFAULT;
  2181. SmapDisabler disabler;
  2182. Thread::SelectBlocker::FDVector rfds;
  2183. Thread::SelectBlocker::FDVector wfds;
  2184. for (int i = 0; i < nfds; ++i) {
  2185. if (fds[i].events & POLLIN)
  2186. rfds.append(fds[i].fd);
  2187. if (fds[i].events & POLLOUT)
  2188. wfds.append(fds[i].fd);
  2189. }
  2190. timeval actual_timeout;
  2191. bool has_timeout = false;
  2192. if (timeout >= 0) {
  2193. // poll is in ms, we want s/us.
  2194. struct timeval tvtimeout;
  2195. tvtimeout.tv_sec = 0;
  2196. while (timeout >= 1000) {
  2197. tvtimeout.tv_sec += 1;
  2198. timeout -= 1000;
  2199. }
  2200. tvtimeout.tv_usec = timeout * 1000;
  2201. timeval_add(kgettimeofday(), tvtimeout, actual_timeout);
  2202. has_timeout = true;
  2203. }
  2204. #if defined(DEBUG_IO) || defined(DEBUG_POLL_SELECT)
  2205. dbgprintf("%s<%u> polling on (read:%u, write:%u), timeout=%d\n", name().characters(), pid(), rfds.size(), wfds.size(), timeout);
  2206. #endif
  2207. if (has_timeout || timeout < 0) {
  2208. if (current->block<Thread::SelectBlocker>(actual_timeout, has_timeout, rfds, wfds, Thread::SelectBlocker::FDVector()) != Thread::BlockResult::WokeNormally)
  2209. return -EINTR;
  2210. }
  2211. int fds_with_revents = 0;
  2212. for (int i = 0; i < nfds; ++i) {
  2213. auto description = file_description(fds[i].fd);
  2214. if (!description) {
  2215. fds[i].revents = POLLNVAL;
  2216. continue;
  2217. }
  2218. fds[i].revents = 0;
  2219. if (fds[i].events & POLLIN && description->can_read())
  2220. fds[i].revents |= POLLIN;
  2221. if (fds[i].events & POLLOUT && description->can_write())
  2222. fds[i].revents |= POLLOUT;
  2223. if (fds[i].revents)
  2224. ++fds_with_revents;
  2225. }
  2226. return fds_with_revents;
  2227. }
  2228. Custody& Process::current_directory()
  2229. {
  2230. if (!m_cwd)
  2231. m_cwd = VFS::the().root_custody();
  2232. return *m_cwd;
  2233. }
  2234. int Process::sys$link(const Syscall::SC_link_params* user_params)
  2235. {
  2236. if (!validate_read_typed(user_params))
  2237. return -EFAULT;
  2238. Syscall::SC_link_params params;
  2239. copy_from_user(&params, user_params, sizeof(params));
  2240. auto old_path = validate_and_copy_string_from_user(params.old_path);
  2241. auto new_path = validate_and_copy_string_from_user(params.new_path);
  2242. if (old_path.is_null() || new_path.is_null())
  2243. return -EFAULT;
  2244. return VFS::the().link(old_path, new_path, current_directory());
  2245. }
  2246. int Process::sys$unlink(const char* user_path, size_t path_length)
  2247. {
  2248. if (!validate_read(user_path, path_length))
  2249. return -EFAULT;
  2250. auto path = get_syscall_path_argument(user_path, path_length);
  2251. if (path.is_error())
  2252. return path.error();
  2253. return VFS::the().unlink(path.value(), current_directory());
  2254. }
  2255. int Process::sys$symlink(const Syscall::SC_symlink_params* user_params)
  2256. {
  2257. if (!validate_read_typed(user_params))
  2258. return -EFAULT;
  2259. Syscall::SC_symlink_params params;
  2260. copy_from_user(&params, user_params);
  2261. auto target = get_syscall_path_argument(params.target.characters, params.target.length);
  2262. if (target.is_error())
  2263. return target.error();
  2264. auto linkpath = get_syscall_path_argument(params.linkpath.characters, params.linkpath.length);
  2265. if (linkpath.is_error())
  2266. return linkpath.error();
  2267. return VFS::the().symlink(target.value(), linkpath.value(), current_directory());
  2268. }
  2269. KResultOr<String> Process::get_syscall_path_argument(const char* user_path, size_t path_length)
  2270. {
  2271. if (path_length == 0)
  2272. return KResult(-EINVAL);
  2273. if (path_length > PATH_MAX)
  2274. return KResult(-ENAMETOOLONG);
  2275. if (!validate_read(user_path, path_length))
  2276. return KResult(-EFAULT);
  2277. return copy_string_from_user(user_path, path_length);
  2278. }
  2279. int Process::sys$rmdir(const char* user_path, size_t path_length)
  2280. {
  2281. auto path = get_syscall_path_argument(user_path, path_length);
  2282. if (path.is_error())
  2283. return path.error();
  2284. return VFS::the().rmdir(path.value(), current_directory());
  2285. }
  2286. int Process::sys$chmod(const char* user_path, size_t path_length, mode_t mode)
  2287. {
  2288. auto path = get_syscall_path_argument(user_path, path_length);
  2289. if (path.is_error())
  2290. return path.error();
  2291. return VFS::the().chmod(path.value(), mode, current_directory());
  2292. }
  2293. int Process::sys$fchmod(int fd, mode_t mode)
  2294. {
  2295. auto description = file_description(fd);
  2296. if (!description)
  2297. return -EBADF;
  2298. return description->chmod(mode);
  2299. }
  2300. int Process::sys$fchown(int fd, uid_t uid, gid_t gid)
  2301. {
  2302. auto description = file_description(fd);
  2303. if (!description)
  2304. return -EBADF;
  2305. return description->chown(uid, gid);
  2306. }
  2307. int Process::sys$chown(const Syscall::SC_chown_params* user_params)
  2308. {
  2309. if (!validate_read_typed(user_params))
  2310. return -EFAULT;
  2311. Syscall::SC_chown_params params;
  2312. copy_from_user(&params, user_params, sizeof(params));
  2313. auto path = get_syscall_path_argument(params.path.characters, params.path.length);
  2314. if (path.is_error())
  2315. return path.error();
  2316. return VFS::the().chown(path.value(), params.uid, params.gid, current_directory());
  2317. }
  2318. void Process::finalize()
  2319. {
  2320. ASSERT(current == g_finalizer);
  2321. dbgprintf("Finalizing Process %s(%u)\n", m_name.characters(), m_pid);
  2322. m_fds.clear();
  2323. m_tty = nullptr;
  2324. m_executable = nullptr;
  2325. m_cwd = nullptr;
  2326. m_root_directory = nullptr;
  2327. m_elf_loader = nullptr;
  2328. disown_all_shared_buffers();
  2329. {
  2330. InterruptDisabler disabler;
  2331. if (auto* parent_thread = Thread::from_tid(m_ppid)) {
  2332. if (parent_thread->m_signal_action_data[SIGCHLD].flags & SA_NOCLDWAIT) {
  2333. // NOTE: If the parent doesn't care about this process, let it go.
  2334. m_ppid = 0;
  2335. } else {
  2336. parent_thread->send_signal(SIGCHLD, this);
  2337. }
  2338. }
  2339. }
  2340. m_dead = true;
  2341. }
  2342. void Process::die()
  2343. {
  2344. // Let go of the TTY, otherwise a slave PTY may keep the master PTY from
  2345. // getting an EOF when the last process using the slave PTY dies.
  2346. // If the master PTY owner relies on an EOF to know when to wait() on a
  2347. // slave owner, we have to allow the PTY pair to be torn down.
  2348. m_tty = nullptr;
  2349. if (m_tracer)
  2350. m_tracer->set_dead();
  2351. {
  2352. // Tell the threads to unwind and die.
  2353. InterruptDisabler disabler;
  2354. for_each_thread([](Thread& thread) {
  2355. thread.set_should_die();
  2356. return IterationDecision::Continue;
  2357. });
  2358. }
  2359. }
  2360. size_t Process::amount_dirty_private() const
  2361. {
  2362. // FIXME: This gets a bit more complicated for Regions sharing the same underlying VMObject.
  2363. // The main issue I'm thinking of is when the VMObject has physical pages that none of the Regions are mapping.
  2364. // That's probably a situation that needs to be looked at in general.
  2365. size_t amount = 0;
  2366. for (auto& region : m_regions) {
  2367. if (!region.is_shared())
  2368. amount += region.amount_dirty();
  2369. }
  2370. return amount;
  2371. }
  2372. size_t Process::amount_clean_inode() const
  2373. {
  2374. HashTable<const InodeVMObject*> vmobjects;
  2375. for (auto& region : m_regions) {
  2376. if (region.vmobject().is_inode())
  2377. vmobjects.set(&static_cast<const InodeVMObject&>(region.vmobject()));
  2378. }
  2379. size_t amount = 0;
  2380. for (auto& vmobject : vmobjects)
  2381. amount += vmobject->amount_clean();
  2382. return amount;
  2383. }
  2384. size_t Process::amount_virtual() const
  2385. {
  2386. size_t amount = 0;
  2387. for (auto& region : m_regions) {
  2388. amount += region.size();
  2389. }
  2390. return amount;
  2391. }
  2392. size_t Process::amount_resident() const
  2393. {
  2394. // FIXME: This will double count if multiple regions use the same physical page.
  2395. size_t amount = 0;
  2396. for (auto& region : m_regions) {
  2397. amount += region.amount_resident();
  2398. }
  2399. return amount;
  2400. }
  2401. size_t Process::amount_shared() const
  2402. {
  2403. // FIXME: This will double count if multiple regions use the same physical page.
  2404. // FIXME: It doesn't work at the moment, since it relies on PhysicalPage ref counts,
  2405. // and each PhysicalPage is only reffed by its VMObject. This needs to be refactored
  2406. // so that every Region contributes +1 ref to each of its PhysicalPages.
  2407. size_t amount = 0;
  2408. for (auto& region : m_regions) {
  2409. amount += region.amount_shared();
  2410. }
  2411. return amount;
  2412. }
  2413. size_t Process::amount_purgeable_volatile() const
  2414. {
  2415. size_t amount = 0;
  2416. for (auto& region : m_regions) {
  2417. if (region.vmobject().is_purgeable() && static_cast<const PurgeableVMObject&>(region.vmobject()).is_volatile())
  2418. amount += region.amount_resident();
  2419. }
  2420. return amount;
  2421. }
  2422. size_t Process::amount_purgeable_nonvolatile() const
  2423. {
  2424. size_t amount = 0;
  2425. for (auto& region : m_regions) {
  2426. if (region.vmobject().is_purgeable() && !static_cast<const PurgeableVMObject&>(region.vmobject()).is_volatile())
  2427. amount += region.amount_resident();
  2428. }
  2429. return amount;
  2430. }
  2431. int Process::sys$socket(int domain, int type, int protocol)
  2432. {
  2433. if ((type & SOCK_TYPE_MASK) == SOCK_RAW && !is_superuser())
  2434. return -EACCES;
  2435. int fd = alloc_fd();
  2436. if (fd < 0)
  2437. return fd;
  2438. auto result = Socket::create(domain, type, protocol);
  2439. if (result.is_error())
  2440. return result.error();
  2441. auto description = FileDescription::create(*result.value());
  2442. description->set_readable(true);
  2443. description->set_writable(true);
  2444. unsigned flags = 0;
  2445. if (type & SOCK_CLOEXEC)
  2446. flags |= FD_CLOEXEC;
  2447. if (type & SOCK_NONBLOCK)
  2448. description->set_blocking(false);
  2449. m_fds[fd].set(move(description), flags);
  2450. return fd;
  2451. }
  2452. int Process::sys$bind(int sockfd, const sockaddr* address, socklen_t address_length)
  2453. {
  2454. if (!validate_read(address, address_length))
  2455. return -EFAULT;
  2456. auto description = file_description(sockfd);
  2457. if (!description)
  2458. return -EBADF;
  2459. if (!description->is_socket())
  2460. return -ENOTSOCK;
  2461. SmapDisabler disabler;
  2462. auto& socket = *description->socket();
  2463. return socket.bind(address, address_length);
  2464. }
  2465. int Process::sys$listen(int sockfd, int backlog)
  2466. {
  2467. auto description = file_description(sockfd);
  2468. if (!description)
  2469. return -EBADF;
  2470. if (!description->is_socket())
  2471. return -ENOTSOCK;
  2472. auto& socket = *description->socket();
  2473. if (socket.is_connected())
  2474. return -EINVAL;
  2475. return socket.listen(backlog);
  2476. }
  2477. int Process::sys$accept(int accepting_socket_fd, sockaddr* address, socklen_t* address_size)
  2478. {
  2479. if (!validate_write_typed(address_size))
  2480. return -EFAULT;
  2481. SmapDisabler disabler;
  2482. if (!validate_write(address, *address_size))
  2483. return -EFAULT;
  2484. int accepted_socket_fd = alloc_fd();
  2485. if (accepted_socket_fd < 0)
  2486. return accepted_socket_fd;
  2487. auto accepting_socket_description = file_description(accepting_socket_fd);
  2488. if (!accepting_socket_description)
  2489. return -EBADF;
  2490. if (!accepting_socket_description->is_socket())
  2491. return -ENOTSOCK;
  2492. auto& socket = *accepting_socket_description->socket();
  2493. if (!socket.can_accept()) {
  2494. if (accepting_socket_description->is_blocking()) {
  2495. if (current->block<Thread::AcceptBlocker>(*accepting_socket_description) != Thread::BlockResult::WokeNormally)
  2496. return -EINTR;
  2497. } else {
  2498. return -EAGAIN;
  2499. }
  2500. }
  2501. auto accepted_socket = socket.accept();
  2502. ASSERT(accepted_socket);
  2503. bool success = accepted_socket->get_peer_address(address, address_size);
  2504. ASSERT(success);
  2505. auto accepted_socket_description = FileDescription::create(*accepted_socket);
  2506. accepted_socket_description->set_readable(true);
  2507. accepted_socket_description->set_writable(true);
  2508. // NOTE: The accepted socket inherits fd flags from the accepting socket.
  2509. // I'm not sure if this matches other systems but it makes sense to me.
  2510. accepted_socket_description->set_blocking(accepting_socket_description->is_blocking());
  2511. m_fds[accepted_socket_fd].set(move(accepted_socket_description), m_fds[accepting_socket_fd].flags);
  2512. // NOTE: Moving this state to Completed is what causes connect() to unblock on the client side.
  2513. accepted_socket->set_setup_state(Socket::SetupState::Completed);
  2514. return accepted_socket_fd;
  2515. }
  2516. int Process::sys$connect(int sockfd, const sockaddr* address, socklen_t address_size)
  2517. {
  2518. if (!validate_read(address, address_size))
  2519. return -EFAULT;
  2520. int fd = alloc_fd();
  2521. if (fd < 0)
  2522. return fd;
  2523. auto description = file_description(sockfd);
  2524. if (!description)
  2525. return -EBADF;
  2526. if (!description->is_socket())
  2527. return -ENOTSOCK;
  2528. auto& socket = *description->socket();
  2529. SmapDisabler disabler;
  2530. return socket.connect(*description, address, address_size, description->is_blocking() ? ShouldBlock::Yes : ShouldBlock::No);
  2531. }
  2532. ssize_t Process::sys$sendto(const Syscall::SC_sendto_params* params)
  2533. {
  2534. if (!validate_read_typed(params))
  2535. return -EFAULT;
  2536. SmapDisabler disabler;
  2537. int sockfd = params->sockfd;
  2538. const void* data = params->data;
  2539. size_t data_length = params->data_length;
  2540. int flags = params->flags;
  2541. const sockaddr* addr = params->addr;
  2542. socklen_t addr_length = params->addr_length;
  2543. if (!validate_read(data, data_length))
  2544. return -EFAULT;
  2545. if (addr && !validate_read(addr, addr_length))
  2546. return -EFAULT;
  2547. auto description = file_description(sockfd);
  2548. if (!description)
  2549. return -EBADF;
  2550. if (!description->is_socket())
  2551. return -ENOTSOCK;
  2552. auto& socket = *description->socket();
  2553. return socket.sendto(*description, data, data_length, flags, addr, addr_length);
  2554. }
  2555. ssize_t Process::sys$recvfrom(const Syscall::SC_recvfrom_params* params)
  2556. {
  2557. if (!validate_read_typed(params))
  2558. return -EFAULT;
  2559. SmapDisabler disabler;
  2560. int sockfd = params->sockfd;
  2561. void* buffer = params->buffer;
  2562. size_t buffer_length = params->buffer_length;
  2563. int flags = params->flags;
  2564. sockaddr* addr = params->addr;
  2565. socklen_t* addr_length = params->addr_length;
  2566. if (!validate_write(buffer, buffer_length))
  2567. return -EFAULT;
  2568. if (addr_length) {
  2569. if (!validate_write_typed(addr_length))
  2570. return -EFAULT;
  2571. if (!validate_write(addr, *addr_length))
  2572. return -EFAULT;
  2573. } else if (addr) {
  2574. return -EINVAL;
  2575. }
  2576. auto description = file_description(sockfd);
  2577. if (!description)
  2578. return -EBADF;
  2579. if (!description->is_socket())
  2580. return -ENOTSOCK;
  2581. auto& socket = *description->socket();
  2582. bool original_blocking = description->is_blocking();
  2583. if (flags & MSG_DONTWAIT)
  2584. description->set_blocking(false);
  2585. auto nrecv = socket.recvfrom(*description, buffer, buffer_length, flags, addr, addr_length);
  2586. if (flags & MSG_DONTWAIT)
  2587. description->set_blocking(original_blocking);
  2588. return nrecv;
  2589. }
  2590. int Process::sys$getsockname(int sockfd, sockaddr* addr, socklen_t* addrlen)
  2591. {
  2592. if (!validate_read_typed(addrlen))
  2593. return -EFAULT;
  2594. SmapDisabler disabler;
  2595. if (*addrlen <= 0)
  2596. return -EINVAL;
  2597. if (!validate_write(addr, *addrlen))
  2598. return -EFAULT;
  2599. auto description = file_description(sockfd);
  2600. if (!description)
  2601. return -EBADF;
  2602. if (!description->is_socket())
  2603. return -ENOTSOCK;
  2604. auto& socket = *description->socket();
  2605. if (!socket.get_local_address(addr, addrlen))
  2606. return -EINVAL; // FIXME: Should this be another error? I'm not sure.
  2607. return 0;
  2608. }
  2609. int Process::sys$getpeername(int sockfd, sockaddr* addr, socklen_t* addrlen)
  2610. {
  2611. if (!validate_read_typed(addrlen))
  2612. return -EFAULT;
  2613. SmapDisabler disabler;
  2614. if (*addrlen <= 0)
  2615. return -EINVAL;
  2616. if (!validate_write(addr, *addrlen))
  2617. return -EFAULT;
  2618. auto description = file_description(sockfd);
  2619. if (!description)
  2620. return -EBADF;
  2621. if (!description->is_socket())
  2622. return -ENOTSOCK;
  2623. auto& socket = *description->socket();
  2624. if (socket.setup_state() != Socket::SetupState::Completed)
  2625. return -ENOTCONN;
  2626. if (!socket.get_peer_address(addr, addrlen))
  2627. return -EINVAL; // FIXME: Should this be another error? I'm not sure.
  2628. return 0;
  2629. }
  2630. int Process::sys$sched_setparam(pid_t pid, const struct sched_param* param)
  2631. {
  2632. if (!validate_read_typed(param))
  2633. return -EFAULT;
  2634. int desired_priority;
  2635. copy_from_user(&desired_priority, &param->sched_priority, sizeof(desired_priority));
  2636. InterruptDisabler disabler;
  2637. auto* peer = this;
  2638. if (pid != 0)
  2639. peer = Process::from_pid(pid);
  2640. if (!peer)
  2641. return -ESRCH;
  2642. if (!is_superuser() && m_euid != peer->m_uid && m_uid != peer->m_uid)
  2643. return -EPERM;
  2644. if (desired_priority < THREAD_PRIORITY_MIN || desired_priority > THREAD_PRIORITY_MAX)
  2645. return -EINVAL;
  2646. peer->any_thread().set_priority((u32)desired_priority);
  2647. return 0;
  2648. }
  2649. int Process::sys$sched_getparam(pid_t pid, struct sched_param* param)
  2650. {
  2651. if (!validate_write_typed(param))
  2652. return -EFAULT;
  2653. InterruptDisabler disabler;
  2654. auto* peer = this;
  2655. if (pid != 0)
  2656. peer = Process::from_pid(pid);
  2657. if (!peer)
  2658. return -ESRCH;
  2659. if (!is_superuser() && m_euid != peer->m_uid && m_uid != peer->m_uid)
  2660. return -EPERM;
  2661. // FIXME: This doesn't seem like the way to get the right thread!
  2662. int priority = peer->any_thread().priority();
  2663. copy_to_user(&param->sched_priority, &priority, sizeof(priority));
  2664. return 0;
  2665. }
  2666. int Process::sys$getsockopt(const Syscall::SC_getsockopt_params* params)
  2667. {
  2668. if (!validate_read_typed(params))
  2669. return -EFAULT;
  2670. SmapDisabler disabler;
  2671. int sockfd = params->sockfd;
  2672. int level = params->level;
  2673. int option = params->option;
  2674. void* value = params->value;
  2675. socklen_t* value_size = params->value_size;
  2676. if (!validate_write_typed(value_size))
  2677. return -EFAULT;
  2678. if (!validate_write(value, *value_size))
  2679. return -EFAULT;
  2680. auto description = file_description(sockfd);
  2681. if (!description)
  2682. return -EBADF;
  2683. if (!description->is_socket())
  2684. return -ENOTSOCK;
  2685. auto& socket = *description->socket();
  2686. return socket.getsockopt(*description, level, option, value, value_size);
  2687. }
  2688. int Process::sys$setsockopt(const Syscall::SC_setsockopt_params* params)
  2689. {
  2690. if (!validate_read_typed(params))
  2691. return -EFAULT;
  2692. SmapDisabler disabler;
  2693. int sockfd = params->sockfd;
  2694. int level = params->level;
  2695. int option = params->option;
  2696. const void* value = params->value;
  2697. socklen_t value_size = params->value_size;
  2698. if (!validate_read(value, value_size))
  2699. return -EFAULT;
  2700. auto description = file_description(sockfd);
  2701. if (!description)
  2702. return -EBADF;
  2703. if (!description->is_socket())
  2704. return -ENOTSOCK;
  2705. auto& socket = *description->socket();
  2706. return socket.setsockopt(level, option, value, value_size);
  2707. }
  2708. void Process::disown_all_shared_buffers()
  2709. {
  2710. LOCKER(shared_buffers().lock());
  2711. Vector<SharedBuffer*, 32> buffers_to_disown;
  2712. for (auto& it : shared_buffers().resource())
  2713. buffers_to_disown.append(it.value.ptr());
  2714. for (auto* shared_buffer : buffers_to_disown)
  2715. shared_buffer->disown(m_pid);
  2716. }
  2717. int Process::sys$create_shared_buffer(int size, void** buffer)
  2718. {
  2719. if (!size || size < 0)
  2720. return -EINVAL;
  2721. size = PAGE_ROUND_UP(size);
  2722. if (!validate_write_typed(buffer))
  2723. return -EFAULT;
  2724. LOCKER(shared_buffers().lock());
  2725. static int s_next_shared_buffer_id;
  2726. int shared_buffer_id = ++s_next_shared_buffer_id;
  2727. auto shared_buffer = make<SharedBuffer>(shared_buffer_id, size);
  2728. shared_buffer->share_with(m_pid);
  2729. void* address = shared_buffer->ref_for_process_and_get_address(*this);
  2730. {
  2731. SmapDisabler disabler;
  2732. *buffer = address;
  2733. }
  2734. ASSERT((int)shared_buffer->size() >= size);
  2735. #ifdef SHARED_BUFFER_DEBUG
  2736. kprintf("%s(%u): Created shared buffer %d @ %p (%u bytes, vmobject is %u)\n", name().characters(), pid(), shared_buffer_id, *buffer, size, shared_buffer->size());
  2737. #endif
  2738. shared_buffers().resource().set(shared_buffer_id, move(shared_buffer));
  2739. return shared_buffer_id;
  2740. }
  2741. int Process::sys$share_buffer_with(int shared_buffer_id, pid_t peer_pid)
  2742. {
  2743. if (!peer_pid || peer_pid < 0 || peer_pid == m_pid)
  2744. return -EINVAL;
  2745. LOCKER(shared_buffers().lock());
  2746. auto it = shared_buffers().resource().find(shared_buffer_id);
  2747. if (it == shared_buffers().resource().end())
  2748. return -EINVAL;
  2749. auto& shared_buffer = *(*it).value;
  2750. if (!shared_buffer.is_shared_with(m_pid))
  2751. return -EPERM;
  2752. {
  2753. InterruptDisabler disabler;
  2754. auto* peer = Process::from_pid(peer_pid);
  2755. if (!peer)
  2756. return -ESRCH;
  2757. }
  2758. shared_buffer.share_with(peer_pid);
  2759. return 0;
  2760. }
  2761. int Process::sys$share_buffer_globally(int shared_buffer_id)
  2762. {
  2763. LOCKER(shared_buffers().lock());
  2764. auto it = shared_buffers().resource().find(shared_buffer_id);
  2765. if (it == shared_buffers().resource().end())
  2766. return -EINVAL;
  2767. auto& shared_buffer = *(*it).value;
  2768. if (!shared_buffer.is_shared_with(m_pid))
  2769. return -EPERM;
  2770. shared_buffer.share_globally();
  2771. return 0;
  2772. }
  2773. int Process::sys$release_shared_buffer(int shared_buffer_id)
  2774. {
  2775. LOCKER(shared_buffers().lock());
  2776. auto it = shared_buffers().resource().find(shared_buffer_id);
  2777. if (it == shared_buffers().resource().end())
  2778. return -EINVAL;
  2779. auto& shared_buffer = *(*it).value;
  2780. if (!shared_buffer.is_shared_with(m_pid))
  2781. return -EPERM;
  2782. #ifdef SHARED_BUFFER_DEBUG
  2783. kprintf("%s(%u): Releasing shared buffer %d, buffer count: %u\n", name().characters(), pid(), shared_buffer_id, shared_buffers().resource().size());
  2784. #endif
  2785. shared_buffer.deref_for_process(*this);
  2786. return 0;
  2787. }
  2788. void* Process::sys$get_shared_buffer(int shared_buffer_id)
  2789. {
  2790. LOCKER(shared_buffers().lock());
  2791. auto it = shared_buffers().resource().find(shared_buffer_id);
  2792. if (it == shared_buffers().resource().end())
  2793. return (void*)-EINVAL;
  2794. auto& shared_buffer = *(*it).value;
  2795. if (!shared_buffer.is_shared_with(m_pid))
  2796. return (void*)-EPERM;
  2797. #ifdef SHARED_BUFFER_DEBUG
  2798. kprintf("%s(%u): Retaining shared buffer %d, buffer count: %u\n", name().characters(), pid(), shared_buffer_id, shared_buffers().resource().size());
  2799. #endif
  2800. return shared_buffer.ref_for_process_and_get_address(*this);
  2801. }
  2802. int Process::sys$seal_shared_buffer(int shared_buffer_id)
  2803. {
  2804. LOCKER(shared_buffers().lock());
  2805. auto it = shared_buffers().resource().find(shared_buffer_id);
  2806. if (it == shared_buffers().resource().end())
  2807. return -EINVAL;
  2808. auto& shared_buffer = *(*it).value;
  2809. if (!shared_buffer.is_shared_with(m_pid))
  2810. return -EPERM;
  2811. #ifdef SHARED_BUFFER_DEBUG
  2812. kprintf("%s(%u): Sealing shared buffer %d\n", name().characters(), pid(), shared_buffer_id);
  2813. #endif
  2814. shared_buffer.seal();
  2815. return 0;
  2816. }
  2817. int Process::sys$get_shared_buffer_size(int shared_buffer_id)
  2818. {
  2819. LOCKER(shared_buffers().lock());
  2820. auto it = shared_buffers().resource().find(shared_buffer_id);
  2821. if (it == shared_buffers().resource().end())
  2822. return -EINVAL;
  2823. auto& shared_buffer = *(*it).value;
  2824. if (!shared_buffer.is_shared_with(m_pid))
  2825. return -EPERM;
  2826. #ifdef SHARED_BUFFER_DEBUG
  2827. kprintf("%s(%u): Get shared buffer %d size: %u\n", name().characters(), pid(), shared_buffer_id, shared_buffers().resource().size());
  2828. #endif
  2829. return shared_buffer.size();
  2830. }
  2831. int Process::sys$set_shared_buffer_volatile(int shared_buffer_id, bool state)
  2832. {
  2833. LOCKER(shared_buffers().lock());
  2834. auto it = shared_buffers().resource().find(shared_buffer_id);
  2835. if (it == shared_buffers().resource().end())
  2836. return -EINVAL;
  2837. auto& shared_buffer = *(*it).value;
  2838. if (!shared_buffer.is_shared_with(m_pid))
  2839. return -EPERM;
  2840. #ifdef SHARED_BUFFER_DEBUG
  2841. kprintf("%s(%u): Set shared buffer %d volatile: %u\n", name().characters(), pid(), shared_buffer_id, state);
  2842. #endif
  2843. if (!state) {
  2844. bool was_purged = shared_buffer.vmobject().was_purged();
  2845. shared_buffer.vmobject().set_volatile(state);
  2846. shared_buffer.vmobject().set_was_purged(false);
  2847. return was_purged ? 1 : 0;
  2848. }
  2849. shared_buffer.vmobject().set_volatile(true);
  2850. return 0;
  2851. }
  2852. void Process::terminate_due_to_signal(u8 signal)
  2853. {
  2854. ASSERT_INTERRUPTS_DISABLED();
  2855. ASSERT(signal < 32);
  2856. dbgprintf("terminate_due_to_signal %s(%u) <- %u\n", name().characters(), pid(), signal);
  2857. m_termination_status = 0;
  2858. m_termination_signal = signal;
  2859. die();
  2860. }
  2861. void Process::send_signal(u8 signal, Process* sender)
  2862. {
  2863. InterruptDisabler disabler;
  2864. auto* thread = Thread::from_tid(m_pid);
  2865. if (!thread)
  2866. thread = &any_thread();
  2867. thread->send_signal(signal, sender);
  2868. }
  2869. int Process::sys$create_thread(void* (*entry)(void*), void* argument, const Syscall::SC_create_thread_params* params)
  2870. {
  2871. if (!validate_read((const void*)entry, sizeof(void*)))
  2872. return -EFAULT;
  2873. if (!validate_read_typed(params))
  2874. return -EFAULT;
  2875. stac();
  2876. unsigned detach_state = params->m_detach_state;
  2877. int schedule_priority = params->m_schedule_priority;
  2878. void* stack_location = params->m_stack_location;
  2879. unsigned stack_size = params->m_stack_size;
  2880. clac();
  2881. if (!validate_write(stack_location, stack_size))
  2882. return -EFAULT;
  2883. u32 user_stack_address = reinterpret_cast<u32>(stack_location) + stack_size;
  2884. if (!MM.validate_user_stack(*this, VirtualAddress(user_stack_address - 4)))
  2885. return -EFAULT;
  2886. // FIXME: return EAGAIN if Thread::all_threads().size() is greater than PTHREAD_THREADS_MAX
  2887. int requested_thread_priority = schedule_priority;
  2888. if (requested_thread_priority < THREAD_PRIORITY_MIN || requested_thread_priority > THREAD_PRIORITY_MAX)
  2889. return -EINVAL;
  2890. bool is_thread_joinable = (0 == detach_state);
  2891. // FIXME: Do something with guard pages?
  2892. auto* thread = new Thread(*this);
  2893. // We know this thread is not the main_thread,
  2894. // So give it a unique name until the user calls $set_thread_name on it
  2895. // length + 4 to give space for our extra junk at the end
  2896. StringBuilder builder(m_name.length() + 4);
  2897. builder.append(m_name);
  2898. builder.appendf("[%d]", thread->tid());
  2899. thread->set_name(builder.to_string());
  2900. thread->set_priority(requested_thread_priority);
  2901. thread->set_joinable(is_thread_joinable);
  2902. auto& tss = thread->tss();
  2903. tss.eip = (u32)entry;
  2904. tss.eflags = 0x0202;
  2905. tss.cr3 = page_directory().cr3();
  2906. tss.esp = user_stack_address;
  2907. // NOTE: The stack needs to be 16-byte aligned.
  2908. thread->push_value_on_stack((u32)argument);
  2909. thread->push_value_on_stack(0);
  2910. thread->make_thread_specific_region({});
  2911. thread->set_state(Thread::State::Runnable);
  2912. return thread->tid();
  2913. }
  2914. void Process::sys$exit_thread(void* exit_value)
  2915. {
  2916. cli();
  2917. current->m_exit_value = exit_value;
  2918. current->set_should_die();
  2919. big_lock().unlock_if_locked();
  2920. current->die_if_needed();
  2921. ASSERT_NOT_REACHED();
  2922. }
  2923. int Process::sys$detach_thread(int tid)
  2924. {
  2925. auto* thread = Thread::from_tid(tid);
  2926. if (!thread || thread->pid() != pid())
  2927. return -ESRCH;
  2928. if (!thread->is_joinable())
  2929. return -EINVAL;
  2930. thread->set_joinable(false);
  2931. return 0;
  2932. }
  2933. int Process::sys$join_thread(int tid, void** exit_value)
  2934. {
  2935. if (exit_value && !validate_write_typed(exit_value))
  2936. return -EFAULT;
  2937. auto* thread = Thread::from_tid(tid);
  2938. if (!thread || thread->pid() != pid())
  2939. return -ESRCH;
  2940. if (thread == current)
  2941. return -EDEADLK;
  2942. if (thread->m_joinee == current)
  2943. return -EDEADLK;
  2944. ASSERT(thread->m_joiner != current);
  2945. if (thread->m_joiner)
  2946. return -EINVAL;
  2947. if (!thread->is_joinable())
  2948. return -EINVAL;
  2949. void* joinee_exit_value = nullptr;
  2950. // NOTE: pthread_join() cannot be interrupted by signals. Only by death.
  2951. for (;;) {
  2952. auto result = current->block<Thread::JoinBlocker>(*thread, joinee_exit_value);
  2953. if (result == Thread::BlockResult::InterruptedByDeath) {
  2954. // NOTE: This cleans things up so that Thread::finalize() won't
  2955. // get confused about a missing joiner when finalizing the joinee.
  2956. InterruptDisabler disabler;
  2957. current->m_joinee->m_joiner = nullptr;
  2958. current->m_joinee = nullptr;
  2959. return 0;
  2960. }
  2961. }
  2962. // NOTE: 'thread' is very possibly deleted at this point. Clear it just to be safe.
  2963. thread = nullptr;
  2964. if (exit_value)
  2965. copy_to_user(exit_value, &joinee_exit_value, sizeof(joinee_exit_value));
  2966. return 0;
  2967. }
  2968. int Process::sys$set_thread_name(int tid, const char* buffer, int buffer_size)
  2969. {
  2970. if (buffer_size < 0)
  2971. return -EINVAL;
  2972. if (!validate_read(buffer, buffer_size))
  2973. return -EFAULT;
  2974. auto name = copy_string_from_user(buffer, buffer_size);
  2975. const size_t max_thread_name_size = 64;
  2976. if (name.length() > max_thread_name_size)
  2977. return -EINVAL;
  2978. auto* thread = Thread::from_tid(tid);
  2979. if (!thread || thread->pid() != pid())
  2980. return -ESRCH;
  2981. thread->set_name(name);
  2982. return 0;
  2983. }
  2984. int Process::sys$get_thread_name(int tid, char* buffer, int buffer_size)
  2985. {
  2986. if (buffer_size <= 0)
  2987. return -EINVAL;
  2988. if (!validate_write(buffer, buffer_size))
  2989. return -EFAULT;
  2990. auto* thread = Thread::from_tid(tid);
  2991. if (!thread || thread->pid() != pid())
  2992. return -ESRCH;
  2993. if (thread->name().length() + 1 > (size_t)buffer_size)
  2994. return -ENAMETOOLONG;
  2995. copy_to_user(buffer, thread->name().characters(), thread->name().length() + 1);
  2996. return 0;
  2997. }
  2998. int Process::sys$gettid()
  2999. {
  3000. return current->tid();
  3001. }
  3002. int Process::sys$donate(int tid)
  3003. {
  3004. if (tid < 0)
  3005. return -EINVAL;
  3006. InterruptDisabler disabler;
  3007. auto* thread = Thread::from_tid(tid);
  3008. if (!thread || thread->pid() != pid())
  3009. return -ESRCH;
  3010. Scheduler::donate_to(thread, "sys$donate");
  3011. return 0;
  3012. }
  3013. int Process::sys$rename(const Syscall::SC_rename_params* user_params)
  3014. {
  3015. if (!validate_read_typed(user_params))
  3016. return -EFAULT;
  3017. Syscall::SC_rename_params params;
  3018. copy_from_user(&params, user_params);
  3019. auto old_path = get_syscall_path_argument(params.old_path.characters, params.old_path.length);
  3020. if (old_path.is_error())
  3021. return old_path.error();
  3022. auto new_path = get_syscall_path_argument(params.new_path.characters, params.new_path.length);
  3023. if (new_path.is_error())
  3024. return new_path.error();
  3025. return VFS::the().rename(old_path.value(), new_path.value(), current_directory());
  3026. }
  3027. int Process::sys$ftruncate(int fd, off_t length)
  3028. {
  3029. if (length < 0)
  3030. return -EINVAL;
  3031. auto description = file_description(fd);
  3032. if (!description)
  3033. return -EBADF;
  3034. if (!description->is_writable())
  3035. return -EBADF;
  3036. return description->truncate(length);
  3037. }
  3038. int Process::sys$watch_file(const char* user_path, size_t path_length)
  3039. {
  3040. auto path = get_syscall_path_argument(user_path, path_length);
  3041. if (path.is_error())
  3042. return path.error();
  3043. auto custody_or_error = VFS::the().resolve_path(path.value(), current_directory());
  3044. if (custody_or_error.is_error())
  3045. return custody_or_error.error();
  3046. auto& custody = custody_or_error.value();
  3047. auto& inode = custody->inode();
  3048. if (!inode.fs().supports_watchers())
  3049. return -ENOTSUP;
  3050. int fd = alloc_fd();
  3051. if (fd < 0)
  3052. return fd;
  3053. m_fds[fd].set(FileDescription::create(*InodeWatcher::create(inode)));
  3054. m_fds[fd].description->set_readable(true);
  3055. return fd;
  3056. }
  3057. int Process::sys$systrace(pid_t pid)
  3058. {
  3059. InterruptDisabler disabler;
  3060. auto* peer = Process::from_pid(pid);
  3061. if (!peer)
  3062. return -ESRCH;
  3063. if (peer->uid() != m_euid)
  3064. return -EACCES;
  3065. int fd = alloc_fd();
  3066. if (fd < 0)
  3067. return fd;
  3068. auto description = FileDescription::create(peer->ensure_tracer());
  3069. description->set_readable(true);
  3070. m_fds[fd].set(move(description), 0);
  3071. return fd;
  3072. }
  3073. int Process::sys$halt()
  3074. {
  3075. if (!is_superuser())
  3076. return -EPERM;
  3077. dbgprintf("acquiring FS locks...\n");
  3078. FS::lock_all();
  3079. dbgprintf("syncing mounted filesystems...\n");
  3080. FS::sync();
  3081. dbgprintf("attempting system shutdown...\n");
  3082. IO::out16(0x604, 0x2000);
  3083. return ESUCCESS;
  3084. }
  3085. int Process::sys$reboot()
  3086. {
  3087. if (!is_superuser())
  3088. return -EPERM;
  3089. dbgprintf("acquiring FS locks...\n");
  3090. FS::lock_all();
  3091. dbgprintf("syncing mounted filesystems...\n");
  3092. FS::sync();
  3093. dbgprintf("attempting reboot via KB Controller...\n");
  3094. IO::out8(0x64, 0xFE);
  3095. return ESUCCESS;
  3096. }
  3097. int Process::sys$mount(const Syscall::SC_mount_params* user_params)
  3098. {
  3099. if (!is_superuser())
  3100. return -EPERM;
  3101. if (!validate_read_typed(user_params))
  3102. return -EFAULT;
  3103. Syscall::SC_mount_params params;
  3104. copy_from_user(&params, user_params);
  3105. auto source = validate_and_copy_string_from_user(params.source);
  3106. auto target = validate_and_copy_string_from_user(params.target);
  3107. auto fs_type = validate_and_copy_string_from_user(params.fs_type);
  3108. if (source.is_null() || target.is_null() || fs_type.is_null())
  3109. return -EFAULT;
  3110. dbg() << "mount " << fs_type << ": source " << source << " @ " << target;
  3111. auto custody_or_error = VFS::the().resolve_path(target, current_directory());
  3112. if (custody_or_error.is_error())
  3113. return custody_or_error.error();
  3114. auto& target_custody = custody_or_error.value();
  3115. RefPtr<FS> fs;
  3116. if (fs_type == "ext2" || fs_type == "Ext2FS") {
  3117. auto metadata_or_error = VFS::the().lookup_metadata(source, current_directory());
  3118. if (metadata_or_error.is_error())
  3119. return metadata_or_error.error();
  3120. auto major = metadata_or_error.value().major_device;
  3121. auto minor = metadata_or_error.value().minor_device;
  3122. auto* device = Device::get_device(major, minor);
  3123. if (!device) {
  3124. dbg() << "mount: device (" << major << "," << minor << ") not found";
  3125. return -ENODEV;
  3126. }
  3127. if (!device->is_disk_device()) {
  3128. dbg() << "mount: device (" << major << "," << minor << ") is not a DiskDevice";
  3129. return -ENODEV;
  3130. }
  3131. auto& disk_device = static_cast<DiskDevice&>(*device);
  3132. dbg() << "mount: attempting to mount device (" << major << "," << minor << ") on " << target;
  3133. fs = Ext2FS::create(disk_device);
  3134. } else if (fs_type == "proc" || fs_type == "ProcFS") {
  3135. fs = ProcFS::create();
  3136. } else if (fs_type == "devpts" || fs_type == "DevPtsFS") {
  3137. fs = DevPtsFS::create();
  3138. } else if (fs_type == "tmp" || fs_type == "TmpFS") {
  3139. fs = TmpFS::create();
  3140. } else {
  3141. return -ENODEV;
  3142. }
  3143. if (!fs->initialize()) {
  3144. dbg() << "mount: failed to initialize " << fs_type << " filesystem on " << source;
  3145. return -ENODEV;
  3146. }
  3147. auto result = VFS::the().mount(fs.release_nonnull(), target_custody);
  3148. dbg() << "mount: successfully mounted " << source << " on " << target;
  3149. return result;
  3150. }
  3151. int Process::sys$umount(const char* user_mountpoint, size_t mountpoint_length)
  3152. {
  3153. if (!is_superuser())
  3154. return -EPERM;
  3155. if (!validate_read(user_mountpoint, mountpoint_length))
  3156. return -EFAULT;
  3157. auto mountpoint = get_syscall_path_argument(user_mountpoint, mountpoint_length);
  3158. if (mountpoint.is_error())
  3159. return mountpoint.error();
  3160. auto metadata_or_error = VFS::the().lookup_metadata(mountpoint.value(), current_directory());
  3161. if (metadata_or_error.is_error())
  3162. return metadata_or_error.error();
  3163. auto guest_inode_id = metadata_or_error.value().inode;
  3164. return VFS::the().unmount(guest_inode_id);
  3165. }
  3166. ProcessTracer& Process::ensure_tracer()
  3167. {
  3168. if (!m_tracer)
  3169. m_tracer = ProcessTracer::create(m_pid);
  3170. return *m_tracer;
  3171. }
  3172. void Process::FileDescriptionAndFlags::clear()
  3173. {
  3174. description = nullptr;
  3175. flags = 0;
  3176. }
  3177. void Process::FileDescriptionAndFlags::set(NonnullRefPtr<FileDescription>&& d, u32 f)
  3178. {
  3179. description = move(d);
  3180. flags = f;
  3181. }
  3182. int Process::sys$mknod(const Syscall::SC_mknod_params* user_params)
  3183. {
  3184. if (!validate_read_typed(user_params))
  3185. return -EFAULT;
  3186. Syscall::SC_mknod_params params;
  3187. copy_from_user(&params, user_params);
  3188. if (!is_superuser() && !is_regular_file(params.mode) && !is_fifo(params.mode) && !is_socket(params.mode))
  3189. return -EPERM;
  3190. auto path = get_syscall_path_argument(params.path.characters, params.path.length);
  3191. if (path.is_error())
  3192. return path.error();
  3193. return VFS::the().mknod(path.value(), params.mode & ~umask(), params.dev, current_directory());
  3194. }
  3195. int Process::sys$dump_backtrace()
  3196. {
  3197. dump_backtrace();
  3198. return 0;
  3199. }
  3200. int Process::sys$dbgputch(u8 ch)
  3201. {
  3202. IO::out8(0xe9, ch);
  3203. return 0;
  3204. }
  3205. int Process::sys$dbgputstr(const u8* characters, int length)
  3206. {
  3207. if (!length)
  3208. return 0;
  3209. if (!validate_read(characters, length))
  3210. return -EFAULT;
  3211. SmapDisabler disabler;
  3212. for (int i = 0; i < length; ++i)
  3213. IO::out8(0xe9, characters[i]);
  3214. return 0;
  3215. }
  3216. KBuffer Process::backtrace(ProcessInspectionHandle& handle) const
  3217. {
  3218. KBufferBuilder builder;
  3219. for_each_thread([&](Thread& thread) {
  3220. builder.appendf("Thread %d (%s):\n", thread.tid(), thread.name().characters());
  3221. builder.append(thread.backtrace(handle));
  3222. return IterationDecision::Continue;
  3223. });
  3224. return builder.build();
  3225. }
  3226. int Process::sys$set_process_icon(int icon_id)
  3227. {
  3228. LOCKER(shared_buffers().lock());
  3229. auto it = shared_buffers().resource().find(icon_id);
  3230. if (it == shared_buffers().resource().end())
  3231. return -EINVAL;
  3232. auto& shared_buffer = *(*it).value;
  3233. if (!shared_buffer.is_shared_with(m_pid))
  3234. return -EPERM;
  3235. m_icon_id = icon_id;
  3236. return 0;
  3237. }
  3238. int Process::sys$get_process_name(char* buffer, int buffer_size)
  3239. {
  3240. if (buffer_size <= 0)
  3241. return -EINVAL;
  3242. if (!validate_write(buffer, buffer_size))
  3243. return -EFAULT;
  3244. if (m_name.length() + 1 > (size_t)buffer_size)
  3245. return -ENAMETOOLONG;
  3246. copy_to_user(buffer, m_name.characters(), m_name.length() + 1);
  3247. return 0;
  3248. }
  3249. // We don't use the flag yet, but we could use it for distinguishing
  3250. // random source like Linux, unlike the OpenBSD equivalent. However, if we
  3251. // do, we should be able of the caveats that Linux has dealt with.
  3252. int Process::sys$getrandom(void* buffer, size_t buffer_size, unsigned int flags __attribute__((unused)))
  3253. {
  3254. if (buffer_size <= 0)
  3255. return -EINVAL;
  3256. if (!validate_write(buffer, buffer_size))
  3257. return -EFAULT;
  3258. get_good_random_bytes((u8*)buffer, buffer_size);
  3259. return 0;
  3260. }
  3261. int Process::sys$setkeymap(const Syscall::SC_setkeymap_params* params)
  3262. {
  3263. if (!is_superuser())
  3264. return -EPERM;
  3265. if (!validate_read_typed(params))
  3266. return -EFAULT;
  3267. const char* map = params->map;
  3268. const char* shift_map = params->shift_map;
  3269. const char* alt_map = params->alt_map;
  3270. const char* altgr_map = params->altgr_map;
  3271. if (!validate_read(map, 0x80))
  3272. return -EFAULT;
  3273. if (!validate_read(shift_map, 0x80))
  3274. return -EFAULT;
  3275. if (!validate_read(alt_map, 0x80))
  3276. return -EFAULT;
  3277. if (!validate_read(altgr_map, 0x80))
  3278. return -EFAULT;
  3279. KeyboardDevice::the().set_maps(map, shift_map, alt_map, altgr_map);
  3280. return 0;
  3281. }
  3282. int Process::sys$clock_gettime(clockid_t clock_id, timespec* ts)
  3283. {
  3284. if (!validate_write_typed(ts))
  3285. return -EFAULT;
  3286. SmapDisabler disabler;
  3287. switch (clock_id) {
  3288. case CLOCK_MONOTONIC:
  3289. ts->tv_sec = g_uptime / TICKS_PER_SECOND;
  3290. ts->tv_nsec = (g_uptime % TICKS_PER_SECOND) * 1000000;
  3291. break;
  3292. default:
  3293. return -EINVAL;
  3294. }
  3295. return 0;
  3296. }
  3297. int Process::sys$clock_nanosleep(const Syscall::SC_clock_nanosleep_params* params)
  3298. {
  3299. if (!validate_read_typed(params))
  3300. return -EFAULT;
  3301. stac();
  3302. int clock_id = params->clock_id;
  3303. int flags = params->flags;
  3304. const timespec* requested_sleep = params->requested_sleep;
  3305. timespec* remaining_sleep = params->remaining_sleep;
  3306. clac();
  3307. if (requested_sleep && !validate_read_typed(requested_sleep))
  3308. return -EFAULT;
  3309. if (remaining_sleep && !validate_write_typed(remaining_sleep))
  3310. return -EFAULT;
  3311. bool is_absolute = flags & TIMER_ABSTIME;
  3312. SmapDisabler disabler;
  3313. switch (clock_id) {
  3314. case CLOCK_MONOTONIC: {
  3315. u64 wakeup_time;
  3316. if (is_absolute) {
  3317. u64 time_to_wake = (requested_sleep->tv_sec * 1000 + requested_sleep->tv_nsec / 1000000);
  3318. wakeup_time = current->sleep_until(time_to_wake);
  3319. } else {
  3320. u32 ticks_to_sleep = (requested_sleep->tv_sec * 1000 + requested_sleep->tv_nsec / 1000000);
  3321. if (!ticks_to_sleep)
  3322. return 0;
  3323. wakeup_time = current->sleep(ticks_to_sleep);
  3324. }
  3325. if (wakeup_time > g_uptime) {
  3326. u32 ticks_left = wakeup_time - g_uptime;
  3327. if (!is_absolute && remaining_sleep) {
  3328. remaining_sleep->tv_sec = ticks_left / TICKS_PER_SECOND;
  3329. ticks_left -= remaining_sleep->tv_sec * TICKS_PER_SECOND;
  3330. remaining_sleep->tv_nsec = ticks_left * 1000000;
  3331. }
  3332. return -EINTR;
  3333. }
  3334. return 0;
  3335. }
  3336. default:
  3337. return -EINVAL;
  3338. }
  3339. }
  3340. int Process::sys$sync()
  3341. {
  3342. VFS::the().sync();
  3343. return 0;
  3344. }
  3345. int Process::sys$yield()
  3346. {
  3347. current->yield_without_holding_big_lock();
  3348. return 0;
  3349. }
  3350. int Process::sys$beep()
  3351. {
  3352. PCSpeaker::tone_on(440);
  3353. u64 wakeup_time = current->sleep(100);
  3354. PCSpeaker::tone_off();
  3355. if (wakeup_time > g_uptime)
  3356. return -EINTR;
  3357. return 0;
  3358. }
  3359. int Process::sys$module_load(const char* user_path, size_t path_length)
  3360. {
  3361. if (!is_superuser())
  3362. return -EPERM;
  3363. auto path = get_syscall_path_argument(user_path, path_length);
  3364. if (path.is_error())
  3365. return path.error();
  3366. auto description_or_error = VFS::the().open(path.value(), 0, 0, current_directory());
  3367. if (description_or_error.is_error())
  3368. return description_or_error.error();
  3369. auto& description = description_or_error.value();
  3370. auto payload = description->read_entire_file();
  3371. auto storage = KBuffer::create_with_size(payload.size());
  3372. memcpy(storage.data(), payload.data(), payload.size());
  3373. payload.clear();
  3374. auto elf_image = make<ELFImage>(storage.data(), storage.size());
  3375. if (!elf_image->parse())
  3376. return -ENOEXEC;
  3377. HashMap<String, u8*> section_storage_by_name;
  3378. auto module = make<Module>();
  3379. elf_image->for_each_section_of_type(SHT_PROGBITS, [&](const ELFImage::Section& section) {
  3380. auto section_storage = KBuffer::copy(section.raw_data(), section.size(), Region::Access::Read | Region::Access::Write | Region::Access::Execute);
  3381. section_storage_by_name.set(section.name(), section_storage.data());
  3382. module->sections.append(move(section_storage));
  3383. return IterationDecision::Continue;
  3384. });
  3385. bool missing_symbols = false;
  3386. elf_image->for_each_section_of_type(SHT_PROGBITS, [&](const ELFImage::Section& section) {
  3387. auto* section_storage = section_storage_by_name.get(section.name()).value_or(nullptr);
  3388. ASSERT(section_storage);
  3389. section.relocations().for_each_relocation([&](const ELFImage::Relocation& relocation) {
  3390. auto& patch_ptr = *reinterpret_cast<ptrdiff_t*>(section_storage + relocation.offset());
  3391. switch (relocation.type()) {
  3392. case R_386_PC32: {
  3393. // PC-relative relocation
  3394. dbg() << "PC-relative relocation: " << relocation.symbol().name();
  3395. u32 symbol_address = address_for_kernel_symbol(relocation.symbol().name());
  3396. if (symbol_address == 0)
  3397. missing_symbols = true;
  3398. dbg() << " Symbol address: " << (void*)symbol_address;
  3399. ptrdiff_t relative_offset = (char*)symbol_address - ((char*)&patch_ptr + 4);
  3400. patch_ptr = relative_offset;
  3401. break;
  3402. }
  3403. case R_386_32: // Absolute relocation
  3404. dbg() << "Absolute relocation: '" << relocation.symbol().name() << "' value:" << relocation.symbol().value() << ", index:" << relocation.symbol_index();
  3405. if (relocation.symbol().bind() == STB_LOCAL) {
  3406. auto* section_storage_containing_symbol = section_storage_by_name.get(relocation.symbol().section().name()).value_or(nullptr);
  3407. ASSERT(section_storage_containing_symbol);
  3408. u32 symbol_address = (ptrdiff_t)(section_storage_containing_symbol + relocation.symbol().value());
  3409. if (symbol_address == 0)
  3410. missing_symbols = true;
  3411. dbg() << " Symbol address: " << (void*)symbol_address;
  3412. patch_ptr += symbol_address;
  3413. } else if (relocation.symbol().bind() == STB_GLOBAL) {
  3414. u32 symbol_address = address_for_kernel_symbol(relocation.symbol().name());
  3415. if (symbol_address == 0)
  3416. missing_symbols = true;
  3417. dbg() << " Symbol address: " << (void*)symbol_address;
  3418. patch_ptr += symbol_address;
  3419. } else {
  3420. ASSERT_NOT_REACHED();
  3421. }
  3422. break;
  3423. }
  3424. return IterationDecision::Continue;
  3425. });
  3426. return IterationDecision::Continue;
  3427. });
  3428. if (missing_symbols)
  3429. return -ENOENT;
  3430. auto* text_base = section_storage_by_name.get(".text").value_or(nullptr);
  3431. if (!text_base) {
  3432. dbg() << "No .text section found in module!";
  3433. return -EINVAL;
  3434. }
  3435. elf_image->for_each_symbol([&](const ELFImage::Symbol& symbol) {
  3436. dbg() << " - " << symbol.type() << " '" << symbol.name() << "' @ " << (void*)symbol.value() << ", size=" << symbol.size();
  3437. if (!strcmp(symbol.name(), "module_init")) {
  3438. module->module_init = (ModuleInitPtr)(text_base + symbol.value());
  3439. } else if (!strcmp(symbol.name(), "module_fini")) {
  3440. module->module_fini = (ModuleFiniPtr)(text_base + symbol.value());
  3441. } else if (!strcmp(symbol.name(), "module_name")) {
  3442. const u8* storage = section_storage_by_name.get(symbol.section().name()).value_or(nullptr);
  3443. if (storage)
  3444. module->name = String((const char*)(storage + symbol.value()));
  3445. }
  3446. return IterationDecision::Continue;
  3447. });
  3448. if (!module->module_init)
  3449. return -EINVAL;
  3450. if (g_modules->contains(module->name)) {
  3451. dbg() << "a module with the name " << module->name << " is already loaded; please unload it first";
  3452. return -EEXIST;
  3453. }
  3454. module->module_init();
  3455. auto name = module->name;
  3456. g_modules->set(name, move(module));
  3457. return 0;
  3458. }
  3459. int Process::sys$module_unload(const char* name, size_t name_length)
  3460. {
  3461. if (!is_superuser())
  3462. return -EPERM;
  3463. if (!validate_read(name, name_length))
  3464. return -EFAULT;
  3465. auto module_name = copy_string_from_user(name, name_length);
  3466. auto it = g_modules->find(module_name);
  3467. if (it == g_modules->end())
  3468. return -ENOENT;
  3469. if (it->value->module_fini)
  3470. it->value->module_fini();
  3471. g_modules->remove(it);
  3472. return 0;
  3473. }
  3474. int Process::sys$profiling_enable(pid_t pid)
  3475. {
  3476. InterruptDisabler disabler;
  3477. auto* process = Process::from_pid(pid);
  3478. if (!process)
  3479. return -ESRCH;
  3480. if (!is_superuser() && process->uid() != m_uid)
  3481. return -EPERM;
  3482. Profiling::start(*process);
  3483. process->set_profiling(true);
  3484. return 0;
  3485. }
  3486. int Process::sys$profiling_disable(pid_t pid)
  3487. {
  3488. InterruptDisabler disabler;
  3489. auto* process = Process::from_pid(pid);
  3490. if (!process)
  3491. return -ESRCH;
  3492. if (!is_superuser() && process->uid() != m_uid)
  3493. return -EPERM;
  3494. process->set_profiling(false);
  3495. Profiling::stop();
  3496. return 0;
  3497. }
  3498. void* Process::sys$get_kernel_info_page()
  3499. {
  3500. return s_info_page_address_for_userspace.as_ptr();
  3501. }
  3502. Thread& Process::any_thread()
  3503. {
  3504. Thread* found_thread = nullptr;
  3505. for_each_thread([&](auto& thread) {
  3506. found_thread = &thread;
  3507. return IterationDecision::Break;
  3508. });
  3509. ASSERT(found_thread);
  3510. return *found_thread;
  3511. }
  3512. WaitQueue& Process::futex_queue(i32* userspace_address)
  3513. {
  3514. auto& queue = m_futex_queues.ensure((u32)userspace_address);
  3515. if (!queue)
  3516. queue = make<WaitQueue>();
  3517. return *queue;
  3518. }
  3519. int Process::sys$futex(const Syscall::SC_futex_params* user_params)
  3520. {
  3521. if (!validate_read_typed(user_params))
  3522. return -EFAULT;
  3523. Syscall::SC_futex_params params;
  3524. copy_from_user(&params, user_params, sizeof(params));
  3525. i32* userspace_address = params.userspace_address;
  3526. int futex_op = params.futex_op;
  3527. i32 value = params.val;
  3528. const timespec* user_timeout = params.timeout;
  3529. if (!validate_read_typed(userspace_address))
  3530. return -EFAULT;
  3531. if (user_timeout && !validate_read_typed(user_timeout))
  3532. return -EFAULT;
  3533. timespec timeout { 0, 0 };
  3534. if (user_timeout)
  3535. copy_from_user(&timeout, user_timeout, sizeof(timeout));
  3536. i32 user_value;
  3537. switch (futex_op) {
  3538. case FUTEX_WAIT:
  3539. copy_from_user(&user_value, userspace_address, sizeof(user_value));
  3540. if (user_value != value)
  3541. return -EAGAIN;
  3542. // FIXME: This is supposed to be interruptible by a signal, but right now WaitQueue cannot be interrupted.
  3543. // FIXME: Support timeout!
  3544. current->wait_on(futex_queue(userspace_address));
  3545. break;
  3546. case FUTEX_WAKE:
  3547. if (value == 0)
  3548. return 0;
  3549. if (value == 1) {
  3550. futex_queue(userspace_address).wake_one();
  3551. } else {
  3552. // FIXME: Wake exactly (value) waiters.
  3553. futex_queue(userspace_address).wake_all();
  3554. }
  3555. break;
  3556. }
  3557. return 0;
  3558. }
  3559. int Process::sys$set_thread_boost(int tid, int amount)
  3560. {
  3561. if (amount < 0 || amount > 20)
  3562. return -EINVAL;
  3563. InterruptDisabler disabler;
  3564. auto* thread = Thread::from_tid(tid);
  3565. if (!thread)
  3566. return -ESRCH;
  3567. if (thread->state() == Thread::State::Dead || thread->state() == Thread::State::Dying)
  3568. return -ESRCH;
  3569. if (!is_superuser() && thread->process().uid() != euid())
  3570. return -EPERM;
  3571. thread->set_priority_boost(amount);
  3572. return 0;
  3573. }
  3574. int Process::sys$set_process_boost(pid_t pid, int amount)
  3575. {
  3576. if (amount < 0 || amount > 20)
  3577. return -EINVAL;
  3578. InterruptDisabler disabler;
  3579. auto* process = Process::from_pid(pid);
  3580. if (!process || process->is_dead())
  3581. return -ESRCH;
  3582. if (!is_superuser() && process->uid() != euid())
  3583. return -EPERM;
  3584. process->m_priority_boost = amount;
  3585. return 0;
  3586. }
  3587. int Process::sys$chroot(const char* user_path, size_t path_length)
  3588. {
  3589. if (!is_superuser())
  3590. return -EPERM;
  3591. auto path = get_syscall_path_argument(user_path, path_length);
  3592. if (path.is_error())
  3593. return path.error();
  3594. auto directory_or_error = VFS::the().open_directory(path.value(), current_directory());
  3595. if (directory_or_error.is_error())
  3596. return directory_or_error.error();
  3597. m_root_directory_for_procfs = directory_or_error.value();
  3598. set_root_directory(Custody::create(nullptr, "", directory_or_error.value()->inode()));
  3599. return 0;
  3600. }
  3601. Custody& Process::root_directory()
  3602. {
  3603. if (!m_root_directory)
  3604. m_root_directory = VFS::the().root_custody();
  3605. return *m_root_directory;
  3606. }
  3607. Custody& Process::root_directory_for_procfs()
  3608. {
  3609. if (!m_root_directory_for_procfs)
  3610. m_root_directory_for_procfs = root_directory();
  3611. return *m_root_directory_for_procfs;
  3612. }
  3613. void Process::set_root_directory(const Custody& root)
  3614. {
  3615. m_root_directory = root;
  3616. }