Förklara skillnaden mellan ett systemanrop och ett anrop av en vanlig funktion, vad menas med att man måste kontrollera returvärdet från ett systemanrop och varför måste vi det? Ge ett konkret exempel hur du gjort då du arbetar med övningar och laborationer där detta förekommer och motivera just varför du kontrollerat returvärdet av det systemanrop du exemplifierar.

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

Ett systemanrop görs till kärnan medans ett vanlig funktionsanrop görs mot dess processbild. Värdet måste kontrolleras i ett systemanrop för att undvika t.ex systemcrash. 
Exempel på detta är när vi kontrollerar om ett barns PID blir negativt med hjälp av systemanropet fork().

int main(void) {
pid_t pid;
pid = fork();

switch(pid) {
case -1:
//systemfel
break;
case 0:
//barnkod
break; 
default:
//föräldrakod
} 
return 0;
}

BEDÖMNING: Oklart om det behöver resultera i en systemkrasch ... det kan vara mycket enklare än så. Det är snarare att man behöver undvika en krasch av den process man kör. Ganska bra svar i övrigt.

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


Systemanrop är ett anrop till de redan existerande funktioner i operativsystemtskärna, returvärdet av systemanorpen måste kontrolleras för att säkerställa om anropet lyckades eller missslyckades och vilka data det skicka tillbaka. Detta skiljer sig från en vanlig funktion som anropas i processens egan processbild. Ett exempel på systemanrop är fork() som skapar en barnprocess och resultatet av en fork() behöver då avläsas för att säkerställa att anropet lyckades och vilket identitetsnummer processen fick vilket är viktigt för att urskilja barnprocessen från föräldern.


BEDÖMNING: Oklart om systemanrop i allmänhet skickar tillbaka data. Att avläsa ett barns process id är skilt från betänkanden som blir aktuella om fork misslyckas. Men i stort sett ett bra svar.

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


Ett systemanrop är ett anrop av funktioner som erbjuds av operativsystemets kärna och kontrollen över programmet lämnas då över till kärnan medan dessa funktioner körs. Vid ett anrop av en vanlig funktion behåller programmet själv kontrollen.

Returvärdet ger oss information om hur systemanropet utfördes som t.ex. om det lyckades eller avbröts samt information om resultatet vilket vi vill kunna ta hänsyn till i vår kod.

När vi använder fork() kontrollerar vi returvärdet för att kunna bestämma vilken kod som ska utföras av child-processen respektive parent-processen.​

BEDÖMNING: Bra svar, dock kan det vara bra att betona att även fork kan misslyckas och det är här man behöver kontrollera att returvärdet inte är -1.

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

Ett systemanrop är ett direktanrop till operativsystemet, det vill komma åt delade
  resurser, t.e.x I/O-enheter. Ett vanligt funktionsanrop är ett anrop till en funktion i ett
  program som t.ex. gör en vanlig matematisk beräkning.
  Att vi måste kontrollera returen på systemanrop menas att vi måste bestämma ifall något
  har gått fel och i så fall avsluta programmet.
  Ett exempel på en sådan kontroll är då vi har använt fork(), vi måste kontrollera ID:t på
  barnprocessen, är det -1 har systemanropet misslyckats och vi måste avsluta programmet,
  får vi något annat i retur har anropet lyckats och vi kan fortsätta.

BEDÖMNING: Bra svar i stort, men det är lite vagt vad som menas med "direktanrop till operativsystemet".

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

Systemanrop kan man se som en direkt fråga till OS kärnan. Medan vanliga funktionsanrop är anrop som sker i användarprogrammet. Man måste kontrollera returvärdet för systemanrop för att kontrollera att allting gick bra och inget konstigt har hänt. Tex om fork() returnerar -1 då betyder det att systemanropet inte har lyckats och detta kan vara viktigt för programmeraren att veta. Men om fork() returnerar ett tal större eller lika med 0 då betyder det att anropet har lyckats
 
BEDÖMNING: Kan bli klarare vad som menas med att "lyckats". Något vagt svar.

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

Skillnaden mellan ett systemanrop och ett anrop av en vanlig funktion är att systemanrop behandlar processhantering och korresponderar direkt med processorkärnan. Genom systemanrop kan processer skapas, dödas, inväntas med mera. Med en vanlig funktionsanrop menas med funktioner som användarprogram kan anropa i ett systemanrop. Ett systemanrop returnerar ett värde som ger en status för genomförandet av anropet. Genom att kontrollera returvärdet av t.ex. ett fork()-anrop så vet vi om barnprocessen skapats eller ej. Om fork() returnerar ”-1” så har ingen barnprocess skapats, om returvärdet är 0 så befinner vi oss i barnprocessens processbild och vid annat positivt returvärde befinner vi oss i föräldraprocessens processbild.

BEDÖMNING: "processorkärnan"? "Genom systemanrop kan processer skapas, dödas, inväntas med mera." Men VAD skiljer detta från vanliga anrop? "Med en vanlig funktionsanrop menas med funktioner som användarprogram kan anropa i ett systemanrop." Sammanblandning! Ett mycket vagt svar.

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

Skillnaden mellan ett systemanrop och en funktionsanrop är att systemanropet är en
underrutin som är inbyggd i systemet. Funktionsanrop används för att utföra någon
sorts uppgift i själva programmet. Man måste kontrollera returvärdet av ett systemanrop för att kontrollera om processen lyckades bli skapad. Om det returnerar ett negativt värde så lyckades processen inte
skapas, om det returnerar ett annat värde lyckades processen skapas.

BEDÖMNING: Vad menas med "inbyggd i systemet"? Vad är "själva programmet"? Kontroll av returvärde av systemanrop kan motiveras mycket mer generellt än så och frågan är vilket konkret systemanrop som exemplifierades? Ett mycket vagt svar.

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

Ett systemanrop och ett anrop av en vanlig funktions skillnader är t.ex. att ett systemanrop behöver
operativsystemets hjälp med att få tillgång till resurser t.ex. filer på en hårddisk eller att kunna skapa
en ny process. Ett systemanrop kräver olika rättigheter om man t.ex. ska hämta en fil och skriva i den
kan man behöva root-rättigheter, har man inte dessa kommer OS:et stoppa dig. Det som stoppar en
är att OS:et kontrollerar returvärdet av systemanropet, och om detta returvärdet är korrekt så kan
anropet köras, annars inte.
Ett konkret exempel är t.ex. när man använder systemanropet fork(). När detta anropet körs så
måste först OS:et kontrollera om det finns plats för att skapa en barnprocess. Har föräldern ett wait-
kommando och fork-kommandot ej returnerar korrekt värde så är det uppenbart att forken ej
lyckades, vilket kan vara p.g.a. att det ej finns plats för yterliggare processer

BEDÖMNING: Bra svar i stor, dock kan den tekniska precisionen bli bättre. Ett systemanrop kan alltid köras, däremot är det inte säkert att det lyckas. Vidare är det inte systemanropet som behöver OS hjälp, det är processen som anropar som behöver OS hjälp och processen begär detta genom systemanrop. Oklart vad som kontrollerades vid anrop av fork.

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


d. Skillnad på systemanrop och vanligt anrop
                  i.   systemanrop är anrop som du själv måste kalla i systemet. Dessa
                       anrop kommer med operativsystemet och är aldrig automatiskt av
                       säkerhetsskäl. Vanliga anrop kan vara kallelser på vilka funktioner.
          e. Varför måste man kontrollera returvärdet
                  i.   Outputen av ett anrop säger ofta mycket om antingen resultaten eller
                       huruvida processen lyckades. Det kan då vara användbart att kolla
                       detta för att exekvera annan kod beroende på resultatet av
                       returvärdet.
          f. Exempel på egen användning av detta vid laboration
                  i.   fork() returnerar antingen 0 om den ansvariga processen är ett barn,
                       med hjälp av detta kan man te.x använda sig av system anropen
                       Execl och en if sats för att endast “byta” kod om det är en
                       barnprocess.
          g. Varför kontrollerade du returvärdet
                  i.   för att programmet ska kunna vara “dependarn” på en annan process.

BEDÖMNING: "du själv måste kalla i systemet"? "Vanliga anrop kan vara kallelser på vilka funktioner" Oprecist språkbruk. Det är i allmänhet inte bra att använda citationstecken i ett svar, när ni skriver “byta” eller “dependarn” då hänvisar ni till någonting som ni anser har något slags speciell betydelse ... men själva idén med en fråga på en tentamen är att ni ska ange just den precisa tekniska betydelsen som en viss tillämpning innebär. Det här är ett dåligt svar.

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

Skillnaden mellan ett systemanrop och ett anrop av en vanlig funktion är att systemanropet förändrar strukturen som uppgifter ska utföras på men utför inga uppgifter själv. Genom att kontrollera returvärdena ser man om systemanropet lyckades eller inte och på så sett kan man se eventuella problem. Innan vi gör exec() när vi skapar processer med systemanropet fork() så kontrollerar vi returvärdet för att se vilken av de identiska processerna som är föräldern och vilken som är barnet. ​

BEDÖMNING: "systemanropet förändrar strukturen som uppgifter ska utföras på men utför inga uppgifter själv" fullkomligt obegripligt. Hade varit bra med mer konkreta beskrivningar av returvärdena på det systemanrop som exemplifieras. Ett ganska dåligt svar.


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

Systemanropen är det gränssnitt/de funktioner som operativsystemet gör tillgängligt för användarprogram att anropa för att få tjänster utförda av operativsystemet. När ett användarprogram utför ett systemanrop så anropas normalt en biblioteksfunktion i C som utför själva systemanropet.
Systemanrop utgör en gränsyta mellan användarprogrammen och operativsystemet. Det betyder att i princip all kommunikation med operativsystemet går genom systemanrop och på så sätt kan de tjänster som operativsystemet tillhandahåller utnyttjas som t.ex. fil- och processhantering. De systemanrop ni skall implementera finns i filen userprog/syscall.h.
 
I mansidorna står det ofta "returnerner -1 vid fel". Detta gäller inte systemanropen utan de biblioteksfunktioner som wrappar systemanropen. I själva verket så returnerar systemanropen någon av de felkoder som manualsidan beskriver som värden på errno. Det värde som systemanropet returnerar till biblioteksfunktionen sparas alltså i errno och -1 returneras i dess ställe.
 
Exempel på systemanrop är fork(2), execve(2), pipe(2), socket(2), select(2) och kill(2). Alla systemanrop finns utförligt dokumenterade i Linux och fås fram med kommandot man
 
anrop i programmering: instruktion som sätter igång en del av ett program (en procedur).
 Anropet anger vilken procedur som ska köras och eventuella parametrar.
 
Skillnaden är då att systemanrop görs till systemets kärna medan ett funktionsanrop görs i processens egna processbild. Ett systemanrop kan nekas eller misslyckas och då måste man hantera det istället för att lita blint på att allt alltid fungerar.

BEDÖMNING: Ett mycket mycket bra svar som går mycket djupare än vad vi behöver i kursen. Kunde varit mer konkret i beskrivningen av returvärde från det systemanrop som exemplifieras.

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












