Förklara följande systemanrop, vad de gör, varför de är nödvändiga. Förklara hur de samverkar.

=================================

a) fork() skapar en ny process (barnprocess) som är en exakt kopia av anropade processen (föräldrarprocess). Förutom att barnprocessen har ett eget unikt procces id(PID) har den även egen plats i minnet. Den är nödvändig eftersom att det är den enda metoden att kunna skapa en process i ett UNIX system.

b) Om en barnprocess kör exec() ersätts barnprocessen med en ny extern process som i sin tur tar över den körande barnprocessens innehåll. Detta är nödvändigt om man vill kunna exekvera externa kommandon från den körande processen.

c) wait() Detta anrop är när en förälder väntar in ett barn som avslutas. Om wait() misslyckas att utföras så kommer det avslutade barnet att bli en Zombie, en levande död. En avslutad process som finns kvar i systemeet och tar upp ondödigt med administriva resurser. Zombier bör alltid undvikas.

BEDÖMNING: Lite oprecist vad ett "externt kommando" är. Samverkan är inte heller beskriven, annars bra svar.


================

a) fork() skapar en child-process som är en exakt kopia till den föräldraprocess som fork() anropas från förutom att child-processen har ett annat pid.

fork() är nödvändig eftersom vi överhuvudtaget ska kunna skapa nya processer (förutom init).

b) När ett program som körs av en process gör ett systemanrop ur exec()-familjen upphör det programmet att exekvera och processen börjar istället exekvera ett nytt program (det som anropats och förutsatt att det inte uppstår något fel).

exec() är nödvändig för att på ett säkert sätt kunna starta nya program i de skapade childprocesserna.

c) wait() kan användas till att pausa och vänta in att barnprocesser till en föräldraprocess kör klart och avslutas innan föräldraprocessen fortsätter.

wait() är nödvändig för att kunna ha en större kontroll över hur processerna fortlöper och i vilken ordning samt för att till exempel undvika att något barn blir en zombie, det vill säga ett avslutat program som inte rensats bort från systemet och därför ockuperar minne.​

BEDÖMNING: exec är lite vagt beskrivet, vad är "programmet"? Vad menas med att på ett "säkert sätt" start nya program? Samverkan är inte heller beskriven. Annars bra svar.

======================

a) fork() skapar en barnprocess under en förälder för att utföra arbeten parallellt eller i
samarbete med föräldern. Detta kan vara nödvändigt då man vill utföra fler arbeten
samtidigt, eller om man vill att föräldern ska vänta på en speciell process innan föräldern
gör sitt. Man kan även ha flera instanser utav samma process ifall föräldern har flera barn.
b) exec() skriver över den nuvarande processen och kör sedan en annan, den som kallades,
t.ex. kan man kalla ls i en exec() och då stoppas processen som kördes, och ls körs istället.
Detta är nödvändigt då vi t.ex. vill utföra en beräkning och sedan köra en annan process
för att då avsluta den nuvarande processen.
c) wait() är när en förälder väntar in ett barn som har avslutats. Om wait() misslyckas att
utföras kommer det avslutade barnet att bli en Zombie, en levande dör. Det avslutade
programmet finns kvar i systemet och tar upp onödiga resurser. Zombier bör alltid
undvikas.
Systemanropen samverkar t.ex. att en barnprocess skapas genom fork(), föräldern väntar
(wait()) på att barnet är färdigt och sedan gör en exec() för att gå vidare till en annan
process.

BEDÖMNING: Kan bli klarare vad som menas med "under" en förälder. Varför är fork() nödvändigt alls? exec är nödvändig för att fork bara kopierar föräldraprocessen. wait ok. I samverkan verkar det som om föräldern gör exec, så är det inte. Hmmm, mediokert svar.

=================

A) fork() skapar en barnprocess från en förälder, detta gör att man kan utföra flera uppgifter parallelt med varandra. Föräldern kan antingen hjälpa barnen med att utföra uppgifter eller vänta på att barnen avslutar sina uppgifter och sedan presentera resultatet för användaren. Att göra processer som gör enskilda uppgifter och sedan avslutas är mer effektivt än en process som kan göra allt.

B) exec() Processer som kör exec() får sin kod utbytt mot en annan kod, vilket ger den en annan uppgift att utföra. När man använder fork() skapas en exakt kopia av förälderns kod i barnprocessen, för att barnet ska kunna göra något vettigt så byts koden ut mot något annat än förälderns. Detta kommando är nödvändigt eftersom om man inte använder det så gör barnet samma sak som föräldern.

C) wait() används för att avsluta barnprocesser som är klara med sin uppgift, utan en wait() så blir barnprocessen en zombie, en levande död. En avslutad process som finns kvar i systemet tar upp onödigt med administriva resurser. Zombier bör alltid undvikas.

BEDÖMNING: Varför är fork nödvändigt? exec bra. wait bra. Samverkan inte beskriven.

=========================

(a) Systemanropet fork() skapar en identisk kopia av en process. Kopian kallas barnprocess och den skapande processen kallas föräldraprocess. Endast processid skiljer dom åt och detta fås via returvärdet av systemanropet. Detta är nödvändigt för att kunna dela upp ett program i flera processer och skilja dom åt med hjälp av deras pid.
(b) exec() byter ut koden i en processbild. Koden ersätts med instruktionerna anropade i exec(). Detta är nödvändigt för att kunna implementera programkod i separata processer . Olika processer kan hantera olika uppgifter i ett program.
(c) wait() gör att föräldraprocessen väntar på att barnprocessen avslutas innan det fortsätter att köra. Vid uteblivet wait()-anrop i föräldraprocessen kommer en Zombie skapas av barnprocessen efter att barnet anropat exit().
Exempel på samverkan:
Vi anropar fork() för att skapa en barnprocess. Barnprocessen använder sedan exec() för att byta ut instruktionerna i sin processbild. I detta fall finns ett exit()-anrop med i de nya instruktionerna. Samtidigt finns ett wait()-anrop i föräldraprocessen. Då barnprocessen exekverar exit()-anropet, undersöks samtidigt om wait()-anropet gjorts i föräldraprocessen. Om detta är fallet, kommer barnprocessen avslutas korrekt och programmet återgår till en process (föräldraprocessen). Om föräldraprocessen inte hunnit göra wait()-anropet innan eller samtidigt som barnprocessen gör gjort sitt exit()-anrop, så kommer barnprocessen förvandlas till en Zombie fram tills att föräldraprocessen anropar wait().

BEDÖMNING: Oklar vad som förklaras kring nödvändigheten av fork. Oklart precis varför exec är nödvändig. Samverkan bra beskriven.


===========================

fork() skapar en kopia av förälderns processbild så att den kan köra två processer parallellt. Kortfattat används systemanropet fork() för att skapa en ny process. 
exec() byter ut det tillfälliga programmet i den tillfälliga processorn.
wait() är ett systemanrop där föräldern väntar på att barnprocessorn skall avslutas. Om föräldraprocessen inte väntar på barnet så kommer barnprocessorn bli en zombie. Zombieprocesser tar upp onödigt med resurser i datorn.

BEDÖMNING: Oklart varför fork och exec är nödvändiga och samverkan beskrivs inte. Ett ganska kort och oklart svar.

============================


A)när fork() utförs skapas en process som är en identisk kopia av dess förälder, med undantaget av
processid. Identisk betyder att den har samma data, instruktioner samt program-counter. M.h.a.
processidt kan man t.ex. via en if-sats gå in i en alternativ kod som står under fork()-kommandot som
utför andra instruktioner än föräldern som inte kommer in i den if-satsen. ”PARALLELT” kyckling och
ris -2017
B)kommandot exec() byter ut all data och instruktioner i en process, förutom process-idt samt
eventuella barn-förälder relationer, mot en programfil på hårdisken. T.ex. om man delat upp ett
program i mindre filer så kan man tillkalla olika delar vid olika tillfällen när det behövs genom exec-
kommandot eller så kan man tillkalla kommandot ls för att lista någonting.
C)kommandot wait() kan en föräldraprocess använda för att kunna avgöra när en barnprocess är
färdig och dess data kan samlas in och processen avslutas. Om wait inte lyckas blir barnprocessen en
zombie som fortsätter att köra utan att egentligen göra någonting förutom att ta upp resurser. Wait
kan användas i ett program för att få en kronologisk ordning på de olika processer som ska köras.

BEDÖMNING: Varför är fork och exec nödvändiga? Samverkan är inte beskriven. 

======================

a. fork() i. fork() Returnerar 3 olika värden som man behöver ta hänsyn till i koden. -1 = misslyckat, 0 = barnprocess, 1 - stor summa = förälder process

b. exec() i. Byter kod i en körande process
ii.   En funktion av ett operativsystem som körs en körbar fil i samband med en redan befintlig process, som ersätter det tidigare körbar. Detta kan även hänvisas till som en overlay . Det är särskilt viktigt i Unix-liknande system, även om det finns någon annanstans. Som en ny process skapas går inte processidentifieraren (PID) att förändras, men det kan maskinkoden, data, heap, och stack i processen skall ersättas med de av det nya programmet.
          
c. wait() i. Wait måste finnas för att en förälder ska kunna invänta ett eventuellt barn. Detta är nödvändigt för att barnet inte ska bli en zombie som försvinner och sätter sig under init.

BEDÖMNING: Det står inte alls vad fork gör, bara vilka returvärden den ger. Inte alls bra. Beskrivningen av exec har en massa tekniska termer inlagda vars betydelse inte framgår. "overlay"? Oklart om svarande förstår vad som skrivits. En zombie lägger sig aldrig under Init. Och samverkan är inte beskriven.

=============================

a) Skapar en barnprocess från en förälder, en nästan exakt kopia av förälderns processbild (processens data i ramminnet). Detta gör att en tjänst kan arbeta med flera uppgifter samtidigt(flera processer) utan att försämra prestandan, t.ex. en server som kan hantera flera anrop samtidigt.
b) Exec() skriver över alla data från den anropande process-bilden med annan körbar process denna behåller dock process-id och dess relationer med föräldrr och barn. Exec() kan samverka med fork() som annars bara skulle skapa kopior av processen för att möjligtköra körnign ava andra processer i systemet.
c) Wait(). Detta anrop invändar på att barnprocesser ska avslutas som får alla information från barnets vars state har ändrats. Om wait() misslyckats eller inte finns så kommer det avslutande barnprocessen att bli en zombie som tar upp onödigt med administrativa resurser. Zombies bör alltid undikas. 

BEDÖMNING: Inte helt klart varför fork är nödvändig. Bra motivering av execs nödvändighet dock! Men i beskrivningen av samverkan saknas referens till wait.

================================

Fork() är en transaktion var igenom en process skapar en kopia av sig själv. Detta är ett systemanrop som genomförs i kärnan. Fork är den primilinära och den enda metoden för skapande processen. Barnet processen börjar med en kopia av sin överordnade fil deskriptorer. För kommunikation mellan, kommer den överordnade processen ofta skapa ett rör eller flera rör, och sedan efter förgrening processerna kommer att stänga ändarna av rören som de inte behöver. Fork används för  det tillåter flera uppgifter för att köra oberoende av varandra, som om de var och en hade den fullständiga minnet av maskinen till sig själva.
 
Exec () familj av funktioner ersätter den nuvarande processen bilden
        med en ny process bild.
Tillsammans beskriver de en lista med en eller flera pekare till null-
        avslutade strängar som representerar argumentlistan tillgänglig för
        exekveras programmet. Det första argumentet, enligt konvention, ska peka på
        filnamnet i samband med den fil som exekveras.
 
Wait()- Detta anrop är när en förälder väntar in ett barn som har avslutats. Om wait() misslyckas att utföras så kommer det avslutande barnet att bli en Zombie ,alltså levande död. En avslutad processen som finns kvar i systemet och tar upp onödigt med administrativa resurser. Zombier bör alltid undvikas.
Fork exec och wait samverkar på så sätt när man skapar en fork så blir det barnproccesser och om man använder wait så föräldern väntar in barnet innan de går vidare. 

BEDÖMNING: För mycket text som inte är helt sammanhängande. Frågan är om svaranden vet vad som efterfrågas och hur det fungerar. Nödvändigheten hos fork/exec framgår inte. Samverkan är vagt beskriven, det finns ingen referens till hur exec kommer in här. Ett ganska såligt svar trots att det fanns mycket text.


