Kursused - Kasutaja kaastöö [et]

ITS8020

2019-11-29T13:50:30Z

Irve:

=ITS8020 Systems Programming=

[https://ois.ttu.ee/portal/page?_pageid=37,674581&_dad=portal&_schema=PORTAL&p_msg=&p_public=1&p_what=1&p_lang=ET&p_open_node2=&p_session_id=70505303&p_id=117259&p_mode=1&p_pageid=OKM_AINE_WEB_OTSING&n_disp_result=1&n_export=0&_init=1&_nextsearch=1&_nextorder=1&_orfn_1=AINER_KOOD&_ordi_1=ASC&_disp_ainer_kood=1&_where_ainer_kood=&_ainer_kood=ITS8020&_disp_ainer_nimetus=1&_where_ainer_nimetus=&_ainer_nimetus=&_disp_ainer_nimetus_en=1&_where_ainer_nimetus_en=&_ainer_nimetus_en=&_disp_ainer_oppejoud=1&_where_ainer_oppejoud=&_ainer_oppejoud=&_disp_ainer_eap=1&_where_ainer_eap=&_ainer_eap=&_where_ainer_eap_vahemik=&_ainer_eap_vahemik=&__ainer_eap_vahemik=&_where_ainer_opj_keel=&_ainer_opj_keel=&_disp_ainer_opetsem=1&_where_ainer_opetsem=&_ainer_opetsem=&_disp_ainer_kodulehe_autor=1&_where_ainer_kodulehe_autor=&_ainer_kodulehe_autor=&_where_ainer_std_id=&_ainer_std_id=&_where_ainer_e_taismaht=&_ainer_e_taismaht=&_where_ainer_e_maht=&_ainer_e_maht=&_where_ainer_e_tase=&_ainer_e_tase=&_where_ainer_e_kinn_kp=&_ainer_e_kinn_kp=&_where_ainer_e_k_maht=&_ainer_e_k_maht=&_where_ainer_e_k_tase=&_ainer_e_k_tase=&_where_ainer_e_k_kinn_kp=&_ainer_e_k_kinn_kp=&_vformaat=VFORMAAT_HTML&n_lov_offset=1&n_row_count=&n_row_pos= Course Card] 
Lecturer: Jaagup Irve <jaagup.irve@ttu.ee> 

Previous year: [https://courses.cs.ttu.ee/w/index.php?title=ITS8020&oldid=7925 2018]. Historical materials can be found at [http://lambda.ee/wiki/Real-Time_Operating_Systems_and_Systems_Programming Real-Time Operating Systems and Systems Programming].

== Elevator pitch ==

The course is an advanced C course which delves into the intricacies of hardware, memory management and operating system design. It looks at basic operating system components (scheduling, mutexes) and also at GNU/Linux standard library. You will be expected to program difficult tasks and it will be englightening. The course has been enjoyed by numerous smart students over the years.

== EXAM TIMES ==

* During the lecture: 20. Dec 2019 room U04-103 10:00
* Secondary exam: 10. Jan 2020 room U04-103 10:00

== PRACTICE CLASS CHANGE ==

* Now in ITC-401. Tell your friends.

== Grading ==

Grading is based on points earned during the course.

90+ points earns a grade of 5, and 50+ lets you pass. Exam can earn you up to 60 points and is difficult. Programming independently (lab) is worth 40 points max. There are 10 bonus points for attending and working on the labs. It is possible to agree on a different course project during the course.

== Lectures ==
'''Note: Anything up to the lecture may change'''
# Introduction (course overview, grades, operator precedence, real time overview) [[Media:Rtos_01.pdf|PDF]]
# Stack Exploration, Long Jump [[Media:Rtos_02.pdf|PDF]]
# Heap [[Media:Rtos_03.pdf|PDF]]
# Hardware, interrupts, basic IO: [https://www.youtube.com/playlist?list=PLMQzXA1f24AdzOb5kRBfN2SkXNrSbdb5L Please watch the videos] [[Media:Rtos_04.pdf|PDF]]
# Signals, System Calls [[Media: Rtos_05.pdf|PDF]]
# Threads [[Media:Rtos_06.pdf|PDF]]
# Scheduling, Processes [[Media:Rtos_07.pdf|PDF]]
# File IO, file and directory management [[Media:Rtos_08.pdf|PDF]]
# Programming an Operating System [[Media:Rtos_09.pdf|PDF]]
# Optimization [[Media:Rtos_10.pdf|PDF]]
# Networking [[Media:Rtos_11.pdf|PDF]] and Bit-Fields [[Media:Rtos_11a.pdf|PDF]]
# Compilation and Utilities [[Media:Rtos_12.pdf|PDF]]
# Security [[Media:Rtos_13.pdf|PDF]]
# Localization [[Media:Rtos_14.pdf|PDF]]
# Real Time Operating Systems [[Media:Rtos_15.pdf|PDF]]
# Summary [[Media:Rtos_16.pdf|PDF]]

== Practice ==
* [http://lambda.ee/wiki/Basic_Linux_command-line_and_utilities_for_accessing_it_(ITI8510) Basic command line and compilation]
* [[Stack Exploration (ITS8020)|Stack Exploration]]
* [[Exploring Debugger (ITS8020)|Exploring Debugger]]
* [[Nonblocking IO (ITS8020)|Nonblocking IO]]
* [[Signals (ITS8020)|Signals]]
* [[Threads (ITS8020)|Threads]]
* [[Processes (ITS8020)|Processes]]
* [[File Attributes (ITS8020)|File Attributes]]
* [[Writing and Reading Binary Data (ITS8020)|Writing and Reading Binary Data]]
* [[Network Sockets (ITS8020)|Network Sockets]]
* [[Optimization (ITS8020)|Optimization]]

== Homework ==

The homework for the course is a file encoder/decoder using a Huffman algorithm. The deadline for the task is set, but if you show your progress weekly, it can be extended without penalty depending on the amount of progress shown. The encoder needs to be shown and defended before the lectures conclude (that is: within 2019).

* [[Huffman Encoder (ITS8020)|Huffman Encoder]]

== Links==

* [http://www.edn.com/design/automotive/4423428/Toyota-s-killer-firmware--Bad-design-and-its-consequences Toyota killer firmware]
* [http://blog.regehr.org/archives/1091 Use of Assertions]
* [https://matt.sh/howto-c How to C in 2016] - or why the lecturer should be deprecated
* [https://avicoder.me/2016/02/01/smashsatck-revived/ Smashing the Stack for Fun and Profit Redone] - a take on a classic
* [https://github.com/s-matyukevich/raspberry-pi-os Raspberry Pi Os] - an opsystem from scratch

Nonblocking IO (ITS8020)

2019-09-27T08:59:52Z

Irve:

{{Its8020}}

Practice with nonblocking IO.

= 1. Nonblocking reads from a FIFO =

Goal: To write a program which prints a '.' character every half-a second unless some input is provided on a fifo file.

'''Hints:'''
* Try to put the terminal into noncanonical mode (you want to turn off line buffering) and remove terminal echo See '[http://linux.die.net/man/3/termios man termios]' or [http://www.google.ee/search?q=noncanonical+mode Google "noncanonical mode"] for that.
* Note that you should restore the terminal mode before quitting since otherwise the terminal might get messed up (no echo).
* Working with bits:
flags &= ~NEWFLAG // Clears the bit NEWFLAG on flags
flags |= NEWFLAG // Set the bit NEWFLAG on flags
flags ^= NEWFLAG // Toggle NEWLAG

= 2. Reading from stidin =

Goal: To write a program which echoes characters on screen while typed until button 'q' is pressed. Then it quits and prints a newline.

'''Hints:'''
* Use [http://linux.die.net/man/2/open open()] with O_NONBLOCK flag.
* If [http://linux.die.net/man/2/read read()] does not have anything to read, it returns with -1 and sets [http://linux.die.net/man/3/errno errno] to constant EAGAIN - you can check that or try messing around with [http://linux.die.net/man/3/select select()] function.
* [http://en.wikipedia.org/wiki/Named_pipe FIFO] can be made with a 'mkfifo fifoname' command and written to using 'cat > fifoname'.
* You have to open fifo ''before'' reading (open two terminal windows).
* Write your output with [http://linux.die.net/man/2/write write()] function to bypass line buffering (or turn it off).
* Function usleep() can be used for half-a second pause here.

[[Kategooria:RTOS]]

Nonblocking IO (ITS8020)

2019-09-27T08:47:09Z

Irve: Uus lehekülg: '{{Its8020}} Practice with nonblocking IO. = 1. Canonical mode = Goal: To write a program which echoes characters on screen while typed until button 'q' is pressed. Then it qui...'

{{Its8020}}

Practice with nonblocking IO.

= 1. Canonical mode =

Goal: To write a program which echoes characters on screen while typed until button 'q' is pressed. Then it quits and prints a newline.

'''Hints:'''
* Try to put the terminal into noncanonical mode and remove terminal echo See '[http://linux.die.net/man/3/termios man termios]' or [http://www.google.ee/search?q=noncanonical+mode Google "noncanonical mode"] for that.
* Note that you should restore the terminal mode before quitting since otherwise the terminal might get messed up (no echo).
* Working with bits:
flags &= ~NEWFLAG // Clears the bit NEWFLAG on flags
flags |= NEWFLAG // Set the bit NEWFLAG on flags
flags ^= NEWFLAG // Toggle NEWLAG

= 2. Nonblocking reads from a FIFO =

Goal: To write a program which prints a '.' character every half-a second unless some input is provided on a fifo file.

'''Hints:'''
* Use [http://linux.die.net/man/2/open open()] with O_NONBLOCK flag.
* If [http://linux.die.net/man/2/read read()] does not have anything to read, it returns with -1 and sets [http://linux.die.net/man/3/errno errno] to constant EAGAIN - you can check that or try messing around with [http://linux.die.net/man/3/select select()] function.
* [http://en.wikipedia.org/wiki/Named_pipe FIFO] can be made with a 'mkfifo fifoname' command and written to using 'cat > fifoname'.
* You have to open fifo ''before'' reading (open two terminal windows).
* Write your output with [http://linux.die.net/man/2/write write()] function to bypass line buffering (or turn it off).
* Function usleep() can be used for half-a second pause here.

[[Kategooria:RTOS]]

ITS8020

2019-09-27T08:45:01Z

Irve: /* Practice */

=ITS8020 Systems Programming=

[https://ois.ttu.ee/portal/page?_pageid=37,674581&_dad=portal&_schema=PORTAL&p_msg=&p_public=1&p_what=1&p_lang=ET&p_open_node2=&p_session_id=70505303&p_id=117259&p_mode=1&p_pageid=OKM_AINE_WEB_OTSING&n_disp_result=1&n_export=0&_init=1&_nextsearch=1&_nextorder=1&_orfn_1=AINER_KOOD&_ordi_1=ASC&_disp_ainer_kood=1&_where_ainer_kood=&_ainer_kood=ITS8020&_disp_ainer_nimetus=1&_where_ainer_nimetus=&_ainer_nimetus=&_disp_ainer_nimetus_en=1&_where_ainer_nimetus_en=&_ainer_nimetus_en=&_disp_ainer_oppejoud=1&_where_ainer_oppejoud=&_ainer_oppejoud=&_disp_ainer_eap=1&_where_ainer_eap=&_ainer_eap=&_where_ainer_eap_vahemik=&_ainer_eap_vahemik=&__ainer_eap_vahemik=&_where_ainer_opj_keel=&_ainer_opj_keel=&_disp_ainer_opetsem=1&_where_ainer_opetsem=&_ainer_opetsem=&_disp_ainer_kodulehe_autor=1&_where_ainer_kodulehe_autor=&_ainer_kodulehe_autor=&_where_ainer_std_id=&_ainer_std_id=&_where_ainer_e_taismaht=&_ainer_e_taismaht=&_where_ainer_e_maht=&_ainer_e_maht=&_where_ainer_e_tase=&_ainer_e_tase=&_where_ainer_e_kinn_kp=&_ainer_e_kinn_kp=&_where_ainer_e_k_maht=&_ainer_e_k_maht=&_where_ainer_e_k_tase=&_ainer_e_k_tase=&_where_ainer_e_k_kinn_kp=&_ainer_e_k_kinn_kp=&_vformaat=VFORMAAT_HTML&n_lov_offset=1&n_row_count=&n_row_pos= Course Card] 
Lecturer: Jaagup Irve <jaagup.irve@ttu.ee> 

Previous year: [https://courses.cs.ttu.ee/w/index.php?title=ITS8020&oldid=7925 2018]. Historical materials can be found at [http://lambda.ee/wiki/Real-Time_Operating_Systems_and_Systems_Programming Real-Time Operating Systems and Systems Programming].

== Elevator pitch ==

The course is an advanced C course which delves into the intricacies of hardware, memory management and operating system design. It looks at basic operating system components (scheduling, mutexes) and also at GNU/Linux standard library. You will be expected to program difficult tasks and it will be englightening. The course has been enjoyed by numerous smart students over the years.

== PRACTICE CLASS CHANGE ==

* Now in ITC-401. Tell your friends.

== Grading ==

Grading is based on points earned during the course.

90+ points earns a grade of 5, and 50+ lets you pass. Exam can earn you up to 60 points and is difficult. Programming independently (lab) is worth 40 points max. There are 10 bonus points for attending and working on the labs. It is possible to agree on a different course project during the course.

== Lectures ==
'''Note: Anything up to the lecture may change'''
# Introduction (course overview, grades, operator precedence, real time overview) [[Media:Rtos_01.pdf|PDF]]
# Stack Exploration, Long Jump [[Media:Rtos_02.pdf|PDF]]
# Heap [[Media:Rtos_03.pdf|PDF]]
# Hardware, interrupts, basic IO: [https://www.youtube.com/playlist?list=PLMQzXA1f24AdzOb5kRBfN2SkXNrSbdb5L Please watch the videos] [[Media:Rtos_04.pdf|PDF]]
# Signals, System Calls [[Media: Rtos_05.pdf|PDF]]
# Threads [[Media:Rtos_06.pdf|PDF]]
# Scheduling, Processes [[Media:Rtos_07.pdf|PDF]]
# File IO, file and directory management [[Media:Rtos_08.pdf|PDF]]
# Programming an Operating System [[Media:Rtos_09.pdf|PDF]]
# Optimization [[Media:Rtos_10.pdf|PDF]]
# Networking [[Media:Rtos_11.pdf|PDF]] and Bit-Fields [[Media:Rtos_11a.pdf|PDF]]
# Compilation and Utilities [[Media:Rtos_12.pdf|PDF]]
# Security [[Media:Rtos_13.pdf|PDF]]
# Localization [[Media:Rtos_14.pdf|PDF]]
# Real Time Operating Systems [[Media:Rtos_15.pdf|PDF]]
# Summary [[Media:Rtos_16.pdf|PDF]]

== Practice ==
* [http://lambda.ee/wiki/Basic_Linux_command-line_and_utilities_for_accessing_it_(ITI8510) Basic command line and compilation]
* [[Stack Exploration (ITS8020)|Stack Exploration]]
* [[Exploring Debugger (ITS8020)|Exploring Debugger]]
* [[Nonblocking IO (ITS8020)|Nonblocking IO]]
* [[Signals (ITS8020)|Signals]]
* [[Threads (ITS8020)|Threads]]
* [[Processes (ITS8020)|Processes]]
* [[File Attributes (ITS8020)|File Attributes]]
* [[Writing and Reading Binary Data (ITS8020)|Writing and Reading Binary Data]]
* [[Network Sockets (ITS8020)|Network Sockets]]
* [[Optimization (ITS8020)|Optimization]]

== Homework ==

The homework for the course is a file encoder/decoder using a Huffman algorithm. The deadline for the task is set, but if you show your progress weekly, it can be extended without penalty depending on the amount of progress shown. The encoder needs to be shown and defended before the lectures conclude (that is: within 2019).

* [[Huffman Encoder (ITS8020)|Huffman Encoder]]

== Links==

* [http://www.edn.com/design/automotive/4423428/Toyota-s-killer-firmware--Bad-design-and-its-consequences Toyota killer firmware]
* [http://blog.regehr.org/archives/1091 Use of Assertions]
* [https://matt.sh/howto-c How to C in 2016] - or why the lecturer should be deprecated
* [https://avicoder.me/2016/02/01/smashsatck-revived/ Smashing the Stack for Fun and Profit Redone] - a take on a classic
* [https://github.com/s-matyukevich/raspberry-pi-os Raspberry Pi Os] - an opsystem from scratch

ITS8020

2019-09-27T08:44:48Z

Irve: /* Practice */

=ITS8020 Systems Programming=

[https://ois.ttu.ee/portal/page?_pageid=37,674581&_dad=portal&_schema=PORTAL&p_msg=&p_public=1&p_what=1&p_lang=ET&p_open_node2=&p_session_id=70505303&p_id=117259&p_mode=1&p_pageid=OKM_AINE_WEB_OTSING&n_disp_result=1&n_export=0&_init=1&_nextsearch=1&_nextorder=1&_orfn_1=AINER_KOOD&_ordi_1=ASC&_disp_ainer_kood=1&_where_ainer_kood=&_ainer_kood=ITS8020&_disp_ainer_nimetus=1&_where_ainer_nimetus=&_ainer_nimetus=&_disp_ainer_nimetus_en=1&_where_ainer_nimetus_en=&_ainer_nimetus_en=&_disp_ainer_oppejoud=1&_where_ainer_oppejoud=&_ainer_oppejoud=&_disp_ainer_eap=1&_where_ainer_eap=&_ainer_eap=&_where_ainer_eap_vahemik=&_ainer_eap_vahemik=&__ainer_eap_vahemik=&_where_ainer_opj_keel=&_ainer_opj_keel=&_disp_ainer_opetsem=1&_where_ainer_opetsem=&_ainer_opetsem=&_disp_ainer_kodulehe_autor=1&_where_ainer_kodulehe_autor=&_ainer_kodulehe_autor=&_where_ainer_std_id=&_ainer_std_id=&_where_ainer_e_taismaht=&_ainer_e_taismaht=&_where_ainer_e_maht=&_ainer_e_maht=&_where_ainer_e_tase=&_ainer_e_tase=&_where_ainer_e_kinn_kp=&_ainer_e_kinn_kp=&_where_ainer_e_k_maht=&_ainer_e_k_maht=&_where_ainer_e_k_tase=&_ainer_e_k_tase=&_where_ainer_e_k_kinn_kp=&_ainer_e_k_kinn_kp=&_vformaat=VFORMAAT_HTML&n_lov_offset=1&n_row_count=&n_row_pos= Course Card] 
Lecturer: Jaagup Irve <jaagup.irve@ttu.ee> 

Previous year: [https://courses.cs.ttu.ee/w/index.php?title=ITS8020&oldid=7925 2018]. Historical materials can be found at [http://lambda.ee/wiki/Real-Time_Operating_Systems_and_Systems_Programming Real-Time Operating Systems and Systems Programming].

== Elevator pitch ==

The course is an advanced C course which delves into the intricacies of hardware, memory management and operating system design. It looks at basic operating system components (scheduling, mutexes) and also at GNU/Linux standard library. You will be expected to program difficult tasks and it will be englightening. The course has been enjoyed by numerous smart students over the years.

== PRACTICE CLASS CHANGE ==

* Now in ITC-401. Tell your friends.

== Grading ==

Grading is based on points earned during the course.

90+ points earns a grade of 5, and 50+ lets you pass. Exam can earn you up to 60 points and is difficult. Programming independently (lab) is worth 40 points max. There are 10 bonus points for attending and working on the labs. It is possible to agree on a different course project during the course.

== Lectures ==
'''Note: Anything up to the lecture may change'''
# Introduction (course overview, grades, operator precedence, real time overview) [[Media:Rtos_01.pdf|PDF]]
# Stack Exploration, Long Jump [[Media:Rtos_02.pdf|PDF]]
# Heap [[Media:Rtos_03.pdf|PDF]]
# Hardware, interrupts, basic IO: [https://www.youtube.com/playlist?list=PLMQzXA1f24AdzOb5kRBfN2SkXNrSbdb5L Please watch the videos] [[Media:Rtos_04.pdf|PDF]]
# Signals, System Calls [[Media: Rtos_05.pdf|PDF]]
# Threads [[Media:Rtos_06.pdf|PDF]]
# Scheduling, Processes [[Media:Rtos_07.pdf|PDF]]
# File IO, file and directory management [[Media:Rtos_08.pdf|PDF]]
# Programming an Operating System [[Media:Rtos_09.pdf|PDF]]
# Optimization [[Media:Rtos_10.pdf|PDF]]
# Networking [[Media:Rtos_11.pdf|PDF]] and Bit-Fields [[Media:Rtos_11a.pdf|PDF]]
# Compilation and Utilities [[Media:Rtos_12.pdf|PDF]]
# Security [[Media:Rtos_13.pdf|PDF]]
# Localization [[Media:Rtos_14.pdf|PDF]]
# Real Time Operating Systems [[Media:Rtos_15.pdf|PDF]]
# Summary [[Media:Rtos_16.pdf|PDF]]

== Practice ==
* [http://lambda.ee/wiki/Basic_Linux_command-line_and_utilities_for_accessing_it_(ITI8510) Basic command line and compilation]
* [[Stack Exploration (ITS8020)|Stack Exploration]]
* [[Exploring Debugger (ITS8020)|Exploring Debugger]]
* [[Nonblocking IO (ITS8020|Nonblocking IO)]]
* [[Signals (ITS8020)|Signals]]
* [[Threads (ITS8020)|Threads]]
* [[Processes (ITS8020)|Processes]]
* [[File Attributes (ITS8020)|File Attributes]]
* [[Writing and Reading Binary Data (ITS8020)|Writing and Reading Binary Data]]
* [[Network Sockets (ITS8020)|Network Sockets]]
* [[Optimization (ITS8020)|Optimization]]

== Homework ==

The homework for the course is a file encoder/decoder using a Huffman algorithm. The deadline for the task is set, but if you show your progress weekly, it can be extended without penalty depending on the amount of progress shown. The encoder needs to be shown and defended before the lectures conclude (that is: within 2019).

* [[Huffman Encoder (ITS8020)|Huffman Encoder]]

== Links==

* [http://www.edn.com/design/automotive/4423428/Toyota-s-killer-firmware--Bad-design-and-its-consequences Toyota killer firmware]
* [http://blog.regehr.org/archives/1091 Use of Assertions]
* [https://matt.sh/howto-c How to C in 2016] - or why the lecturer should be deprecated
* [https://avicoder.me/2016/02/01/smashsatck-revived/ Smashing the Stack for Fun and Profit Redone] - a take on a classic
* [https://github.com/s-matyukevich/raspberry-pi-os Raspberry Pi Os] - an opsystem from scratch

ITS8020

2019-09-13T06:00:35Z

Irve:

=ITS8020 Systems Programming=

[https://ois.ttu.ee/portal/page?_pageid=37,674581&_dad=portal&_schema=PORTAL&p_msg=&p_public=1&p_what=1&p_lang=ET&p_open_node2=&p_session_id=70505303&p_id=117259&p_mode=1&p_pageid=OKM_AINE_WEB_OTSING&n_disp_result=1&n_export=0&_init=1&_nextsearch=1&_nextorder=1&_orfn_1=AINER_KOOD&_ordi_1=ASC&_disp_ainer_kood=1&_where_ainer_kood=&_ainer_kood=ITS8020&_disp_ainer_nimetus=1&_where_ainer_nimetus=&_ainer_nimetus=&_disp_ainer_nimetus_en=1&_where_ainer_nimetus_en=&_ainer_nimetus_en=&_disp_ainer_oppejoud=1&_where_ainer_oppejoud=&_ainer_oppejoud=&_disp_ainer_eap=1&_where_ainer_eap=&_ainer_eap=&_where_ainer_eap_vahemik=&_ainer_eap_vahemik=&__ainer_eap_vahemik=&_where_ainer_opj_keel=&_ainer_opj_keel=&_disp_ainer_opetsem=1&_where_ainer_opetsem=&_ainer_opetsem=&_disp_ainer_kodulehe_autor=1&_where_ainer_kodulehe_autor=&_ainer_kodulehe_autor=&_where_ainer_std_id=&_ainer_std_id=&_where_ainer_e_taismaht=&_ainer_e_taismaht=&_where_ainer_e_maht=&_ainer_e_maht=&_where_ainer_e_tase=&_ainer_e_tase=&_where_ainer_e_kinn_kp=&_ainer_e_kinn_kp=&_where_ainer_e_k_maht=&_ainer_e_k_maht=&_where_ainer_e_k_tase=&_ainer_e_k_tase=&_where_ainer_e_k_kinn_kp=&_ainer_e_k_kinn_kp=&_vformaat=VFORMAAT_HTML&n_lov_offset=1&n_row_count=&n_row_pos= Course Card] 
Lecturer: Jaagup Irve <jaagup.irve@ttu.ee> 

Previous year: [https://courses.cs.ttu.ee/w/index.php?title=ITS8020&oldid=7925 2018]. Historical materials can be found at [http://lambda.ee/wiki/Real-Time_Operating_Systems_and_Systems_Programming Real-Time Operating Systems and Systems Programming].

== Elevator pitch ==

The course is an advanced C course which delves into the intricacies of hardware, memory management and operating system design. It looks at basic operating system components (scheduling, mutexes) and also at GNU/Linux standard library. You will be expected to program difficult tasks and it will be englightening. The course has been enjoyed by numerous smart students over the years.

== PRACTICE CLASS CHANGE ==

* Now in ITC-401. Tell your friends.

== Grading ==

Grading is based on points earned during the course.

90+ points earns a grade of 5, and 50+ lets you pass. Exam can earn you up to 60 points and is difficult. Programming independently (lab) is worth 40 points max. There are 10 bonus points for attending and working on the labs. It is possible to agree on a different course project during the course.

== Lectures ==
'''Note: Anything up to the lecture may change'''
# Introduction (course overview, grades, operator precedence, real time overview) [[Media:Rtos_01.pdf|PDF]]
# Stack Exploration, Long Jump [[Media:Rtos_02.pdf|PDF]]
# Heap [[Media:Rtos_03.pdf|PDF]]
# Hardware, interrupts, basic IO: [https://www.youtube.com/playlist?list=PLMQzXA1f24AdzOb5kRBfN2SkXNrSbdb5L Please watch the videos] [[Media:Rtos_04.pdf|PDF]]
# Signals, System Calls [[Media: Rtos_05.pdf|PDF]]
# Threads [[Media:Rtos_06.pdf|PDF]]
# Scheduling, Processes [[Media:Rtos_07.pdf|PDF]]
# File IO, file and directory management [[Media:Rtos_08.pdf|PDF]]
# Programming an Operating System [[Media:Rtos_09.pdf|PDF]]
# Optimization [[Media:Rtos_10.pdf|PDF]]
# Networking [[Media:Rtos_11.pdf|PDF]] and Bit-Fields [[Media:Rtos_11a.pdf|PDF]]
# Compilation and Utilities [[Media:Rtos_12.pdf|PDF]]
# Security [[Media:Rtos_13.pdf|PDF]]
# Localization [[Media:Rtos_14.pdf|PDF]]
# Real Time Operating Systems [[Media:Rtos_15.pdf|PDF]]
# Summary [[Media:Rtos_16.pdf|PDF]]

== Practice ==
* [http://lambda.ee/wiki/Basic_Linux_command-line_and_utilities_for_accessing_it_(ITI8510) Basic command line and compilation]
* [[Stack Exploration (ITS8020)|Stack Exploration]]
* [[Exploring Debugger (ITS8020)|Exploring Debugger]]
* [[Signals (ITS8020)|Signals]]
* [[Threads (ITS8020)|Threads]]
* [[Processes (ITS8020)|Processes]]
* [[File Attributes (ITS8020)|File Attributes]]
* [[Writing and Reading Binary Data (ITS8020)|Writing and Reading Binary Data]]
* [[Network Sockets (ITS8020)|Network Sockets]]
* [[Optimization (ITS8020)|Optimization]]

== Homework ==

The homework for the course is a file encoder/decoder using a Huffman algorithm. The deadline for the task is set, but if you show your progress weekly, it can be extended without penalty depending on the amount of progress shown. The encoder needs to be shown and defended before the lectures conclude (that is: within 2019).

* [[Huffman Encoder (ITS8020)|Huffman Encoder]]

== Links==

* [http://www.edn.com/design/automotive/4423428/Toyota-s-killer-firmware--Bad-design-and-its-consequences Toyota killer firmware]
* [http://blog.regehr.org/archives/1091 Use of Assertions]
* [https://matt.sh/howto-c How to C in 2016] - or why the lecturer should be deprecated
* [https://avicoder.me/2016/02/01/smashsatck-revived/ Smashing the Stack for Fun and Profit Redone] - a take on a classic
* [https://github.com/s-matyukevich/raspberry-pi-os Raspberry Pi Os] - an opsystem from scratch

Fail:Rtos 02.pdf

2019-09-13T05:56:15Z

Irve: Irve laadis üles faili "Pilt:Rtos 02.pdf" uue versiooni: removing the arvutiteaduse instituut

Fail:Rtos 01.pdf

2019-09-05T19:13:20Z

Irve: Irve laadis üles faili "Pilt:Rtos 01.pdf" uue versiooni: taltec>taltech

Fail:Rtos 01.pdf

2019-09-05T19:11:46Z

Irve: Irve laadis üles faili "Pilt:Rtos 01.pdf" uue versiooni

ITS8020

2019-09-05T18:55:53Z

Irve:

=ITS8020 Systems Programming=

[https://ois.ttu.ee/portal/page?_pageid=37,674581&_dad=portal&_schema=PORTAL&p_msg=&p_public=1&p_what=1&p_lang=ET&p_open_node2=&p_session_id=70505303&p_id=117259&p_mode=1&p_pageid=OKM_AINE_WEB_OTSING&n_disp_result=1&n_export=0&_init=1&_nextsearch=1&_nextorder=1&_orfn_1=AINER_KOOD&_ordi_1=ASC&_disp_ainer_kood=1&_where_ainer_kood=&_ainer_kood=ITS8020&_disp_ainer_nimetus=1&_where_ainer_nimetus=&_ainer_nimetus=&_disp_ainer_nimetus_en=1&_where_ainer_nimetus_en=&_ainer_nimetus_en=&_disp_ainer_oppejoud=1&_where_ainer_oppejoud=&_ainer_oppejoud=&_disp_ainer_eap=1&_where_ainer_eap=&_ainer_eap=&_where_ainer_eap_vahemik=&_ainer_eap_vahemik=&__ainer_eap_vahemik=&_where_ainer_opj_keel=&_ainer_opj_keel=&_disp_ainer_opetsem=1&_where_ainer_opetsem=&_ainer_opetsem=&_disp_ainer_kodulehe_autor=1&_where_ainer_kodulehe_autor=&_ainer_kodulehe_autor=&_where_ainer_std_id=&_ainer_std_id=&_where_ainer_e_taismaht=&_ainer_e_taismaht=&_where_ainer_e_maht=&_ainer_e_maht=&_where_ainer_e_tase=&_ainer_e_tase=&_where_ainer_e_kinn_kp=&_ainer_e_kinn_kp=&_where_ainer_e_k_maht=&_ainer_e_k_maht=&_where_ainer_e_k_tase=&_ainer_e_k_tase=&_where_ainer_e_k_kinn_kp=&_ainer_e_k_kinn_kp=&_vformaat=VFORMAAT_HTML&n_lov_offset=1&n_row_count=&n_row_pos= Course Card] 
Lecturer: Jaagup Irve <jaagup.irve@ttu.ee> 

Previous year: [https://courses.cs.ttu.ee/w/index.php?title=ITS8020&oldid=7925 2018]. Historical materials can be found at [http://lambda.ee/wiki/Real-Time_Operating_Systems_and_Systems_Programming Real-Time Operating Systems and Systems Programming].

== Elevator pitch ==

The course is an advanced C course which delves into the intricacies of hardware, memory management and operating system design. It looks at basic operating system components (scheduling, mutexes) and also at GNU/Linux standard library. You will be expected to program difficult tasks and it will be englightening. The course has been enjoyed by numerous smart students over the years.

== Grading ==

Grading is based on points earned during the course.

90+ points earns a grade of 5, and 50+ lets you pass. Exam can earn you up to 60 points and is difficult. Programming independently (lab) is worth 40 points max. There are 10 bonus points for attending and working on the labs. It is possible to agree on a different course project during the course.

== Lectures ==
'''Note: Anything up to the lecture may change'''
# Introduction (course overview, grades, operator precedence, real time overview) [[Media:Rtos_01.pdf|PDF]]
# Stack Exploration, Long Jump [[Media:Rtos_02.pdf|PDF]]
# Heap [[Media:Rtos_03.pdf|PDF]]
# Hardware, interrupts, basic IO: [https://www.youtube.com/playlist?list=PLMQzXA1f24AdzOb5kRBfN2SkXNrSbdb5L Please watch the videos] [[Media:Rtos_04.pdf|PDF]]
# Signals, System Calls [[Media: Rtos_05.pdf|PDF]]
# Threads [[Media:Rtos_06.pdf|PDF]]
# Scheduling, Processes [[Media:Rtos_07.pdf|PDF]]
# File IO, file and directory management [[Media:Rtos_08.pdf|PDF]]
# Programming an Operating System [[Media:Rtos_09.pdf|PDF]]
# Optimization [[Media:Rtos_10.pdf|PDF]]
# Networking [[Media:Rtos_11.pdf|PDF]] and Bit-Fields [[Media:Rtos_11a.pdf|PDF]]
# Compilation and Utilities [[Media:Rtos_12.pdf|PDF]]
# Security [[Media:Rtos_13.pdf|PDF]]
# Localization [[Media:Rtos_14.pdf|PDF]]
# Real Time Operating Systems [[Media:Rtos_15.pdf|PDF]]
# Summary [[Media:Rtos_16.pdf|PDF]]

== Practice ==
* [http://lambda.ee/wiki/Basic_Linux_command-line_and_utilities_for_accessing_it_(ITI8510) Basic command line and compilation]
* [[Stack Exploration (ITS8020)|Stack Exploration]]
* [[Exploring Debugger (ITS8020)|Exploring Debugger]]
* [[Signals (ITS8020)|Signals]]
* [[Threads (ITS8020)|Threads]]
* [[Processes (ITS8020)|Processes]]
* [[File Attributes (ITS8020)|File Attributes]]
* [[Writing and Reading Binary Data (ITS8020)|Writing and Reading Binary Data]]
* [[Network Sockets (ITS8020)|Network Sockets]]
* [[Optimization (ITS8020)|Optimization]]

== Homework ==

The homework for the course is a file encoder/decoder using a Huffman algorithm. The deadline for the task is set, but if you show your progress weekly, it can be extended without penalty depending on the amount of progress shown. The encoder needs to be shown and defended before the lectures conclude (that is: within 2019).

* [[Huffman Encoder (ITS8020)|Huffman Encoder]]

== Links==

* [http://www.edn.com/design/automotive/4423428/Toyota-s-killer-firmware--Bad-design-and-its-consequences Toyota killer firmware]
* [http://blog.regehr.org/archives/1091 Use of Assertions]
* [https://matt.sh/howto-c How to C in 2016] - or why the lecturer should be deprecated
* [https://avicoder.me/2016/02/01/smashsatck-revived/ Smashing the Stack for Fun and Profit Redone] - a take on a classic
* [https://github.com/s-matyukevich/raspberry-pi-os Raspberry Pi Os] - an opsystem from scratch

Fail:ITS8020 2018.zip

2018-12-20T16:33:33Z

Irve:

Fail:Rtos 16.pdf

2018-12-20T16:31:25Z

Irve:

Fail:Rtos 15.pdf

2018-12-20T16:31:11Z

Irve:

Fail:Rtos 14.pdf

2018-12-20T16:31:00Z

Irve:

ITS8020

2018-12-20T16:30:48Z

Irve: /* Lectures */

=ITS8020 Systems Programming=

[https://ois.ttu.ee/portal/page?_pageid=37,674581&_dad=portal&_schema=PORTAL&p_msg=&p_public=1&p_what=1&p_lang=ET&p_open_node2=&p_session_id=70505303&p_id=117259&p_mode=1&p_pageid=OKM_AINE_WEB_OTSING&n_disp_result=1&n_export=0&_init=1&_nextsearch=1&_nextorder=1&_orfn_1=AINER_KOOD&_ordi_1=ASC&_disp_ainer_kood=1&_where_ainer_kood=&_ainer_kood=ITS8020&_disp_ainer_nimetus=1&_where_ainer_nimetus=&_ainer_nimetus=&_disp_ainer_nimetus_en=1&_where_ainer_nimetus_en=&_ainer_nimetus_en=&_disp_ainer_oppejoud=1&_where_ainer_oppejoud=&_ainer_oppejoud=&_disp_ainer_eap=1&_where_ainer_eap=&_ainer_eap=&_where_ainer_eap_vahemik=&_ainer_eap_vahemik=&__ainer_eap_vahemik=&_where_ainer_opj_keel=&_ainer_opj_keel=&_disp_ainer_opetsem=1&_where_ainer_opetsem=&_ainer_opetsem=&_disp_ainer_kodulehe_autor=1&_where_ainer_kodulehe_autor=&_ainer_kodulehe_autor=&_where_ainer_std_id=&_ainer_std_id=&_where_ainer_e_taismaht=&_ainer_e_taismaht=&_where_ainer_e_maht=&_ainer_e_maht=&_where_ainer_e_tase=&_ainer_e_tase=&_where_ainer_e_kinn_kp=&_ainer_e_kinn_kp=&_where_ainer_e_k_maht=&_ainer_e_k_maht=&_where_ainer_e_k_tase=&_ainer_e_k_tase=&_where_ainer_e_k_kinn_kp=&_ainer_e_k_kinn_kp=&_vformaat=VFORMAAT_HTML&n_lov_offset=1&n_row_count=&n_row_pos= Course Card] 
Lecturer: Jaagup Irve <jaagup.irve@ttu.ee> 

For reference: last year materials can be found at [http://lambda.ee/wiki/Real-Time_Operating_Systems_and_Systems_Programming Real-Time Operating Systems and Systems Programming]. Most of it is still relevant.

== Elevator pitch ==

The course is basically an advanced C course which delves into the intricacies of hardware, memory management and operating system design. It looks at basic operating system components (scheduling, mutexes) and also at Linux standard library. You will be expected to program difficult tasks and it will be englightening. The course has been enjoyed by numerous smart students over the years.

== Grading ==

Grading is based on points earned during the course.

90+ points earns a grade of 5, and 50+ lets you pass. Exam can earn you up to 60 points and is difficult. Programming independently (lab) is worth 40 points max. There are 10 bonus points for attending and working on the labs. It is possible to agree on a different course project during the course.

== Exam ==

The first exam will be held in last lecture, the second one in the second week of January.
* '''First Exam''' - 21.12.2018 10:00 in room '''SOC-212''', no registration needed
* '''Second Exam''' - 09.01.2019 10:00 in room '''SOC-212''', registration in OIS needed

The last day for any show of huffman is 21.12 after the exam.

== Lectures ==
# Introduction (course overview, grades, operator precedence, real time overview) [[Media:Rtos_01.pdf|PDF]]
# Stack Exploration, Long Jump [[Media:Rtos_02.pdf|PDF]]
# Heap [[Media:Rtos_03.pdf|PDF]]
# Hardware, interrupts, basic IO: [https://www.youtube.com/playlist?list=PLMQzXA1f24AdzOb5kRBfN2SkXNrSbdb5L Please watch the videos] [[Media:Rtos_04.pdf|PDF]]
# Signals, System Calls [[Media: Rtos_05.pdf|PDF]]
# Threads [[Media:Rtos_06.pdf|PDF]]
# Scheduling, Processes [[Media:Rtos_07.pdf|PDF]]
# File IO, file and directory management [[Media:Rtos_08.pdf|PDF]]
# Programming an Operating System [[Media:Rtos_09.pdf|PDF]]
# Optimization [[Media:Rtos_10.pdf|PDF]]
# Networking [[Media:Rtos_11.pdf|PDF]] and Bit-Fields [[Media:Rtos_11a.pdf|PDF]]
# Compilation and Utilities [[Media:Rtos_12.pdf|PDF]]
# Security [[Media:Rtos_13.pdf|PDF]]
# Localization [[Media:Rtos_14.pdf|PDF]]
# Real Time Operating Systems [[Media:Rtos_15.pdf|PDF]]
# Summary [[Media:Rtos_16.pdf|PDF]]

[[Media:ITS8020_2018.zip|ITS8020_2018.zip]]

== Practice ==
* [http://lambda.ee/wiki/Basic_Linux_command-line_and_utilities_for_accessing_it_(ITI8510) Basic command line and compilation]
* [[Stack Exploration (ITS8020)|Stack Exploration]]
* [[Exploring Debugger (ITS8020)|Exploring Debugger]]
* [[Signals (ITS8020)|Signals]]
* [[Threads (ITS8020)|Threads]]
* [[Processes (ITS8020)|Processes]]
* [[File Attributes (ITS8020)|File Attributes]]
* [[Writing and Reading Binary Data (ITS8020)|Writing and Reading Binary Data]]
* [[Network Sockets (ITS8020)|Network Sockets]]
* [[Optimization (ITS8020)|Optimization]]

== Homework ==

The homework for the course is a file encoder/decoder using a Huffman algorithm. The deadline for the task is November 9, but if you show your progress weekly, it can be extended without penalty depending on the amount of progress shown. The encoder needs to be shown and defended before the lectures conclude.

* [[Huffman Encoder (ITS8020)|Huffman Encoder]]

== Links==

* [http://www.edn.com/design/automotive/4423428/Toyota-s-killer-firmware--Bad-design-and-its-consequences Toyota killer firmware]
* [http://blog.regehr.org/archives/1091 Use of Assertions]
* [https://matt.sh/howto-c How to C in 2016] - or why the lecturer should be deprecated
* [https://avicoder.me/2016/02/01/smashsatck-revived/ Smashing the Stack for Fun and Profit Redone] - a take on a classic
* [https://github.com/s-matyukevich/raspberry-pi-os Raspberry Pi Os] - an opsystem from scratch

ITS8020

2018-12-20T16:30:12Z

Irve: /* Lectures */

=ITS8020 Systems Programming=

[https://ois.ttu.ee/portal/page?_pageid=37,674581&_dad=portal&_schema=PORTAL&p_msg=&p_public=1&p_what=1&p_lang=ET&p_open_node2=&p_session_id=70505303&p_id=117259&p_mode=1&p_pageid=OKM_AINE_WEB_OTSING&n_disp_result=1&n_export=0&_init=1&_nextsearch=1&_nextorder=1&_orfn_1=AINER_KOOD&_ordi_1=ASC&_disp_ainer_kood=1&_where_ainer_kood=&_ainer_kood=ITS8020&_disp_ainer_nimetus=1&_where_ainer_nimetus=&_ainer_nimetus=&_disp_ainer_nimetus_en=1&_where_ainer_nimetus_en=&_ainer_nimetus_en=&_disp_ainer_oppejoud=1&_where_ainer_oppejoud=&_ainer_oppejoud=&_disp_ainer_eap=1&_where_ainer_eap=&_ainer_eap=&_where_ainer_eap_vahemik=&_ainer_eap_vahemik=&__ainer_eap_vahemik=&_where_ainer_opj_keel=&_ainer_opj_keel=&_disp_ainer_opetsem=1&_where_ainer_opetsem=&_ainer_opetsem=&_disp_ainer_kodulehe_autor=1&_where_ainer_kodulehe_autor=&_ainer_kodulehe_autor=&_where_ainer_std_id=&_ainer_std_id=&_where_ainer_e_taismaht=&_ainer_e_taismaht=&_where_ainer_e_maht=&_ainer_e_maht=&_where_ainer_e_tase=&_ainer_e_tase=&_where_ainer_e_kinn_kp=&_ainer_e_kinn_kp=&_where_ainer_e_k_maht=&_ainer_e_k_maht=&_where_ainer_e_k_tase=&_ainer_e_k_tase=&_where_ainer_e_k_kinn_kp=&_ainer_e_k_kinn_kp=&_vformaat=VFORMAAT_HTML&n_lov_offset=1&n_row_count=&n_row_pos= Course Card] 
Lecturer: Jaagup Irve <jaagup.irve@ttu.ee> 

For reference: last year materials can be found at [http://lambda.ee/wiki/Real-Time_Operating_Systems_and_Systems_Programming Real-Time Operating Systems and Systems Programming]. Most of it is still relevant.

== Elevator pitch ==

The course is basically an advanced C course which delves into the intricacies of hardware, memory management and operating system design. It looks at basic operating system components (scheduling, mutexes) and also at Linux standard library. You will be expected to program difficult tasks and it will be englightening. The course has been enjoyed by numerous smart students over the years.

== Grading ==

Grading is based on points earned during the course.

90+ points earns a grade of 5, and 50+ lets you pass. Exam can earn you up to 60 points and is difficult. Programming independently (lab) is worth 40 points max. There are 10 bonus points for attending and working on the labs. It is possible to agree on a different course project during the course.

== Exam ==

The first exam will be held in last lecture, the second one in the second week of January.
* '''First Exam''' - 21.12.2018 10:00 in room '''SOC-212''', no registration needed
* '''Second Exam''' - 09.01.2019 10:00 in room '''SOC-212''', registration in OIS needed

The last day for any show of huffman is 21.12 after the exam.

== Lectures ==
# Introduction (course overview, grades, operator precedence, real time overview) [[Media:Rtos_01.pdf|PDF]]
# Stack Exploration, Long Jump [[Media:Rtos_02.pdf|PDF]]
# Heap [[Media:Rtos_03.pdf|PDF]]
# Hardware, interrupts, basic IO: [https://www.youtube.com/playlist?list=PLMQzXA1f24AdzOb5kRBfN2SkXNrSbdb5L Please watch the videos] [[Media:Rtos_04.pdf|PDF]]
# Signals, System Calls [[Media: Rtos_05.pdf|PDF]]
# Threads [[Media:Rtos_06.pdf|PDF]]
# Scheduling, Processes [[Media:Rtos_07.pdf|PDF]]
# File IO, file and directory management [[Media:Rtos_08.pdf|PDF]]
# Programming an Operating System [[Media:Rtos_09.pdf|PDF]]
# Optimization [[Media:Rtos_10.pdf|PDF]]
# Networking [[Media:Rtos_11.pdf|PDF]] and Bit-Fields [[Media:Rtos_11a.pdf|PDF]]
# Compilation and Utilities [[Media:Rtos_12.pdf|PDF]]
# Security [[Media:Rtos_13.pdf|PDF]]
# Localization [[Media:Rtos_14.pdf|PDF]]
# Real Time Operating Systems [[Media:Rtos_15.pdf|PDF]]
# Summary [[Media:Rtos_16.pdf|PDF]]
# [[Media:ITS8020_2018.zip|ITS8020_2018.zip]]

== Practice ==
* [http://lambda.ee/wiki/Basic_Linux_command-line_and_utilities_for_accessing_it_(ITI8510) Basic command line and compilation]
* [[Stack Exploration (ITS8020)|Stack Exploration]]
* [[Exploring Debugger (ITS8020)|Exploring Debugger]]
* [[Signals (ITS8020)|Signals]]
* [[Threads (ITS8020)|Threads]]
* [[Processes (ITS8020)|Processes]]
* [[File Attributes (ITS8020)|File Attributes]]
* [[Writing and Reading Binary Data (ITS8020)|Writing and Reading Binary Data]]
* [[Network Sockets (ITS8020)|Network Sockets]]
* [[Optimization (ITS8020)|Optimization]]

== Homework ==

The homework for the course is a file encoder/decoder using a Huffman algorithm. The deadline for the task is November 9, but if you show your progress weekly, it can be extended without penalty depending on the amount of progress shown. The encoder needs to be shown and defended before the lectures conclude.

* [[Huffman Encoder (ITS8020)|Huffman Encoder]]

== Links==

* [http://www.edn.com/design/automotive/4423428/Toyota-s-killer-firmware--Bad-design-and-its-consequences Toyota killer firmware]
* [http://blog.regehr.org/archives/1091 Use of Assertions]
* [https://matt.sh/howto-c How to C in 2016] - or why the lecturer should be deprecated
* [https://avicoder.me/2016/02/01/smashsatck-revived/ Smashing the Stack for Fun and Profit Redone] - a take on a classic
* [https://github.com/s-matyukevich/raspberry-pi-os Raspberry Pi Os] - an opsystem from scratch

ITS8020

2018-12-20T15:01:13Z

Irve:

=ITS8020 Systems Programming=

[https://ois.ttu.ee/portal/page?_pageid=37,674581&_dad=portal&_schema=PORTAL&p_msg=&p_public=1&p_what=1&p_lang=ET&p_open_node2=&p_session_id=70505303&p_id=117259&p_mode=1&p_pageid=OKM_AINE_WEB_OTSING&n_disp_result=1&n_export=0&_init=1&_nextsearch=1&_nextorder=1&_orfn_1=AINER_KOOD&_ordi_1=ASC&_disp_ainer_kood=1&_where_ainer_kood=&_ainer_kood=ITS8020&_disp_ainer_nimetus=1&_where_ainer_nimetus=&_ainer_nimetus=&_disp_ainer_nimetus_en=1&_where_ainer_nimetus_en=&_ainer_nimetus_en=&_disp_ainer_oppejoud=1&_where_ainer_oppejoud=&_ainer_oppejoud=&_disp_ainer_eap=1&_where_ainer_eap=&_ainer_eap=&_where_ainer_eap_vahemik=&_ainer_eap_vahemik=&__ainer_eap_vahemik=&_where_ainer_opj_keel=&_ainer_opj_keel=&_disp_ainer_opetsem=1&_where_ainer_opetsem=&_ainer_opetsem=&_disp_ainer_kodulehe_autor=1&_where_ainer_kodulehe_autor=&_ainer_kodulehe_autor=&_where_ainer_std_id=&_ainer_std_id=&_where_ainer_e_taismaht=&_ainer_e_taismaht=&_where_ainer_e_maht=&_ainer_e_maht=&_where_ainer_e_tase=&_ainer_e_tase=&_where_ainer_e_kinn_kp=&_ainer_e_kinn_kp=&_where_ainer_e_k_maht=&_ainer_e_k_maht=&_where_ainer_e_k_tase=&_ainer_e_k_tase=&_where_ainer_e_k_kinn_kp=&_ainer_e_k_kinn_kp=&_vformaat=VFORMAAT_HTML&n_lov_offset=1&n_row_count=&n_row_pos= Course Card] 
Lecturer: Jaagup Irve <jaagup.irve@ttu.ee> 

For reference: last year materials can be found at [http://lambda.ee/wiki/Real-Time_Operating_Systems_and_Systems_Programming Real-Time Operating Systems and Systems Programming]. Most of it is still relevant.

== Elevator pitch ==

The course is basically an advanced C course which delves into the intricacies of hardware, memory management and operating system design. It looks at basic operating system components (scheduling, mutexes) and also at Linux standard library. You will be expected to program difficult tasks and it will be englightening. The course has been enjoyed by numerous smart students over the years.

== Grading ==

Grading is based on points earned during the course.

90+ points earns a grade of 5, and 50+ lets you pass. Exam can earn you up to 60 points and is difficult. Programming independently (lab) is worth 40 points max. There are 10 bonus points for attending and working on the labs. It is possible to agree on a different course project during the course.

== Exam ==

The first exam will be held in last lecture, the second one in the second week of January.
* '''First Exam''' - 21.12.2018 10:00 in room '''SOC-212''', no registration needed
* '''Second Exam''' - 09.01.2019 10:00 in room '''SOC-212''', registration in OIS needed

The last day for any show of huffman is 21.12 after the exam.

== Lectures ==
# Introduction (course overview, grades, operator precedence, real time overview) [[Media:Rtos_01.pdf|PDF]]
# Stack Exploration, Long Jump [[Media:Rtos_02.pdf|PDF]]
# Heap [[Media:Rtos_03.pdf|PDF]]
# Hardware, interrupts, basic IO: [https://www.youtube.com/playlist?list=PLMQzXA1f24AdzOb5kRBfN2SkXNrSbdb5L Please watch the videos] [[Media:Rtos_04.pdf|PDF]]
# Signals, System Calls [[Media: Rtos_05.pdf|PDF]]
# Threads [[Media:Rtos_06.pdf|PDF]]
# Scheduling, Processes [[Media:Rtos_07.pdf|PDF]]
# File IO, file and directory management [[Media:Rtos_08.pdf|PDF]]
# Programming an Operating System [[Media:Rtos_09.pdf|PDF]]
# Optimization [[Media:Rtos_10.pdf|PDF]]
# Networking [[Media:Rtos_11.pdf|PDF]] and Bit-Fields [[Media:Rtos_11a.pdf|PDF]]
# Compilation and Utilities [[Media:Rtos_12.pdf|PDF]]
# Security [[Media:Rtos_13.pdf|PDF]]

== Practice ==
* [http://lambda.ee/wiki/Basic_Linux_command-line_and_utilities_for_accessing_it_(ITI8510) Basic command line and compilation]
* [[Stack Exploration (ITS8020)|Stack Exploration]]
* [[Exploring Debugger (ITS8020)|Exploring Debugger]]
* [[Signals (ITS8020)|Signals]]
* [[Threads (ITS8020)|Threads]]
* [[Processes (ITS8020)|Processes]]
* [[File Attributes (ITS8020)|File Attributes]]
* [[Writing and Reading Binary Data (ITS8020)|Writing and Reading Binary Data]]
* [[Network Sockets (ITS8020)|Network Sockets]]
* [[Optimization (ITS8020)|Optimization]]

== Homework ==

The homework for the course is a file encoder/decoder using a Huffman algorithm. The deadline for the task is November 9, but if you show your progress weekly, it can be extended without penalty depending on the amount of progress shown. The encoder needs to be shown and defended before the lectures conclude.

* [[Huffman Encoder (ITS8020)|Huffman Encoder]]

== Links==

* [http://www.edn.com/design/automotive/4423428/Toyota-s-killer-firmware--Bad-design-and-its-consequences Toyota killer firmware]
* [http://blog.regehr.org/archives/1091 Use of Assertions]
* [https://matt.sh/howto-c How to C in 2016] - or why the lecturer should be deprecated
* [https://avicoder.me/2016/02/01/smashsatck-revived/ Smashing the Stack for Fun and Profit Redone] - a take on a classic
* [https://github.com/s-matyukevich/raspberry-pi-os Raspberry Pi Os] - an opsystem from scratch

Fail:Rtos 13.pdf

2018-11-30T09:45:05Z

Irve:

Fail:Rtos 12.pdf

2018-11-30T09:44:53Z

Irve:

Fail:Rtos 11a.pdf

2018-11-30T09:44:39Z

Irve:

Fail:Rtos 11.pdf

2018-11-30T09:44:25Z

Irve:

Fail:Rtos 10.pdf

2018-11-30T09:44:12Z

Irve:

ITS8020

2018-11-30T09:44:02Z

Irve: /* Lectures */

=ITS8020 Systems Programming=

[https://ois.ttu.ee/portal/page?_pageid=37,674581&_dad=portal&_schema=PORTAL&p_msg=&p_public=1&p_what=1&p_lang=ET&p_open_node2=&p_session_id=70505303&p_id=117259&p_mode=1&p_pageid=OKM_AINE_WEB_OTSING&n_disp_result=1&n_export=0&_init=1&_nextsearch=1&_nextorder=1&_orfn_1=AINER_KOOD&_ordi_1=ASC&_disp_ainer_kood=1&_where_ainer_kood=&_ainer_kood=ITS8020&_disp_ainer_nimetus=1&_where_ainer_nimetus=&_ainer_nimetus=&_disp_ainer_nimetus_en=1&_where_ainer_nimetus_en=&_ainer_nimetus_en=&_disp_ainer_oppejoud=1&_where_ainer_oppejoud=&_ainer_oppejoud=&_disp_ainer_eap=1&_where_ainer_eap=&_ainer_eap=&_where_ainer_eap_vahemik=&_ainer_eap_vahemik=&__ainer_eap_vahemik=&_where_ainer_opj_keel=&_ainer_opj_keel=&_disp_ainer_opetsem=1&_where_ainer_opetsem=&_ainer_opetsem=&_disp_ainer_kodulehe_autor=1&_where_ainer_kodulehe_autor=&_ainer_kodulehe_autor=&_where_ainer_std_id=&_ainer_std_id=&_where_ainer_e_taismaht=&_ainer_e_taismaht=&_where_ainer_e_maht=&_ainer_e_maht=&_where_ainer_e_tase=&_ainer_e_tase=&_where_ainer_e_kinn_kp=&_ainer_e_kinn_kp=&_where_ainer_e_k_maht=&_ainer_e_k_maht=&_where_ainer_e_k_tase=&_ainer_e_k_tase=&_where_ainer_e_k_kinn_kp=&_ainer_e_k_kinn_kp=&_vformaat=VFORMAAT_HTML&n_lov_offset=1&n_row_count=&n_row_pos= Course Card] 
Lecturer: Jaagup Irve <jaagup.irve@ttu.ee> 

For reference: last year materials can be found at [http://lambda.ee/wiki/Real-Time_Operating_Systems_and_Systems_Programming Real-Time Operating Systems and Systems Programming]. Most of it is still relevant.

== Elevator pitch ==

The course is basically an advanced C course which delves into the intricacies of hardware, memory management and operating system design. It looks at basic operating system components (scheduling, mutexes) and also at Linux standard library. You will be expected to program difficult tasks and it will be englightening. The course has been enjoyed by numerous smart students over the years.

== Grading ==

Grading is based on points earned during the course.

90+ points earns a grade of 5, and 50+ lets you pass. Exam can earn you up to 60 points and is difficult. Programming independently (lab) is worth 40 points max. There are 10 bonus points for attending and working on the labs. It is possible to agree on a different course project during the course.

== Exam ==

The first exam will be held in last lecture, the second one in the second week of January.

== Lectures ==
# Introduction (course overview, grades, operator precedence, real time overview) [[Media:Rtos_01.pdf|PDF]]
# Stack Exploration, Long Jump [[Media:Rtos_02.pdf|PDF]]
# Heap [[Media:Rtos_03.pdf|PDF]]
# Hardware, interrupts, basic IO: [https://www.youtube.com/playlist?list=PLMQzXA1f24AdzOb5kRBfN2SkXNrSbdb5L Please watch the videos] [[Media:Rtos_04.pdf|PDF]]
# Signals, System Calls [[Media: Rtos_05.pdf|PDF]]
# Threads [[Media:Rtos_06.pdf|PDF]]
# Scheduling, Processes [[Media:Rtos_07.pdf|PDF]]
# File IO, file and directory management [[Media:Rtos_08.pdf|PDF]]
# Programming an Operating System [[Media:Rtos_09.pdf|PDF]]
# Optimization [[Media:Rtos_10.pdf|PDF]]
# Networking [[Media:Rtos_11.pdf|PDF]] and Bit-Fields [[Media:Rtos_11a.pdf|PDF]]
# Compilation and Utilities [[Media:Rtos_12.pdf|PDF]]
# Security [[Media:Rtos_13.pdf|PDF]]

== Practice ==
* [http://lambda.ee/wiki/Basic_Linux_command-line_and_utilities_for_accessing_it_(ITI8510) Basic command line and compilation]
* [[Stack Exploration (ITS8020)|Stack Exploration]]
* [[Exploring Debugger (ITS8020)|Exploring Debugger]]
* [[Signals (ITS8020)|Signals]]
* [[Threads (ITS8020)|Threads]]
* [[Processes (ITS8020)|Processes]]
* [[File Attributes (ITS8020)|File Attributes]]
* [[Writing and Reading Binary Data (ITS8020)|Writing and Reading Binary Data]]
* [[Network Sockets (ITS8020)|Network Sockets]]
* [[Optimization (ITS8020)|Optimization]]

== Homework ==

The homework for the course is a file encoder/decoder using a Huffman algorithm. The deadline for the task is November 9, but if you show your progress weekly, it can be extended without penalty depending on the amount of progress shown. The encoder needs to be shown and defended before the lectures conclude.

* [[Huffman Encoder (ITS8020)|Huffman Encoder]]

== Links==

* [http://www.edn.com/design/automotive/4423428/Toyota-s-killer-firmware--Bad-design-and-its-consequences Toyota killer firmware]
* [http://blog.regehr.org/archives/1091 Use of Assertions]
* [https://matt.sh/howto-c How to C in 2016] - or why the lecturer should be deprecated
* [https://avicoder.me/2016/02/01/smashsatck-revived/ Smashing the Stack for Fun and Profit Redone] - a take on a classic
* [https://github.com/s-matyukevich/raspberry-pi-os Raspberry Pi Os] - an opsystem from scratch

Optimization (ITS8020)

2018-11-30T09:37:17Z

Irve: /* Hints */

''Optimization of a program''
== Programm ==

Write a program which will read a file and outputs its statistics.

* For a "standard" input file with random content, please run:
dd if=/dev/urandom of=random_file count=1048576 bs=1

* The output of the program should be 256 human-readable lines of ASCII numbers, which represent the content of the file. The first line should contain the number of occurences of byte with a value of 0x0 (or binary zero) in the file and the last line the number of occurences of byte with value 0xff (or 255 in decimal).
* Measure the running time of the program with:
time programname

== Hints ==

* Does the loop unrolling trick work?
* Perhaps it is possible to use parallel programming or threads?
* Does compilation optimization with -O work?
* Can you replace printf with something faster that you write yourself?
* Perhaps the keyword inline can be used.
* (Sadly mmap for file reading fails in dijkstra) Can you speed up the reading of the file with mmap()?

== Example code for base program ==

#include <stdlib.h>
#include <stdio.h>

long int stats[256];

int main() {
int i, c;
FILE * f;

f = fopen("random_file", "r");
if(f == NULL) {
perror("slowstat");
exit(EXIT_FAILURE);
}

while((c = fgetc(f)) != EOF) {
stats[c]++;
}

for(i = 0; i < 255; i++) {
printf("%ld\n", stats[i]);
}
exit(EXIT_SUCCESS);
}

Optimization (ITS8020)

2018-11-30T09:36:54Z

Irve: /* Programm */

''Optimization of a program''
== Programm ==

Write a program which will read a file and outputs its statistics.

* For a "standard" input file with random content, please run:
dd if=/dev/urandom of=random_file count=1048576 bs=1

* The output of the program should be 256 human-readable lines of ASCII numbers, which represent the content of the file. The first line should contain the number of occurences of byte with a value of 0x0 (or binary zero) in the file and the last line the number of occurences of byte with value 0xff (or 255 in decimal).
* Measure the running time of the program with:
time programname

== Hints ==

* Does the loop unrolling trick work?
* Perhaps it is possible to use parallel programming or threads?
* Does compilation optimization with -O work?
* Can you replace printf with something faster that you write yourself?
* Perhaps the keyword inline can be used.
* (Sadly mmap for file reading fails in dijkstra) Can you speed up the reading of the file with mmap()? (Note -- mmap not yet explained in the lecture)

== Example code for base program ==

#include <stdlib.h>
#include <stdio.h>

long int stats[256];

int main() {
int i, c;
FILE * f;

f = fopen("random_file", "r");
if(f == NULL) {
perror("slowstat");
exit(EXIT_FAILURE);
}

while((c = fgetc(f)) != EOF) {
stats[c]++;
}

for(i = 0; i < 255; i++) {
printf("%ld\n", stats[i]);
}
exit(EXIT_SUCCESS);
}

Optimization (ITS8020)

2018-11-30T09:36:22Z

Irve:

''Optimization of a program''
== Programm ==

Write a program which will read a file and outputs its statistics.

* For a "standard" input file with random content, please run:
dd if=/dev/urandom of=random_file count=1048576 bs=1

* The output of the program should be 256 human-readable lines of ASCII numbers, which represent the content of the file. The first line should contain the number of occurences of byte with a value of 0x0 (or binary zero) in the file and the last line the number of occurences of byte with value 0xff (or 256 in decimal).
* Measure the running time of the program with:
time programname

== Hints ==

* Does the loop unrolling trick work?
* Perhaps it is possible to use parallel programming or threads?
* Does compilation optimization with -O work?
* Can you replace printf with something faster that you write yourself?
* Perhaps the keyword inline can be used.
* (Sadly mmap for file reading fails in dijkstra) Can you speed up the reading of the file with mmap()? (Note -- mmap not yet explained in the lecture)

== Example code for base program ==

#include <stdlib.h>
#include <stdio.h>

long int stats[256];

int main() {
int i, c;
FILE * f;

f = fopen("random_file", "r");
if(f == NULL) {
perror("slowstat");
exit(EXIT_FAILURE);
}

while((c = fgetc(f)) != EOF) {
stats[c]++;
}

for(i = 0; i < 255; i++) {
printf("%ld\n", stats[i]);
}
exit(EXIT_SUCCESS);
}

Optimization (ITS8020)

2018-11-30T09:36:12Z

Irve: Uus lehekülg: '''Optimization of a program'' (Also available in [http://lambda.ee/w/index.php?title=Optimization_(ITI8510)&oldid=12060 Estonian]) == Programm == Write a program which will rea...'

''Optimization of a program'' (Also available in [http://lambda.ee/w/index.php?title=Optimization_(ITI8510)&oldid=12060 Estonian])

== Programm ==

Write a program which will read a file and outputs its statistics.

* For a "standard" input file with random content, please run:
dd if=/dev/urandom of=random_file count=1048576 bs=1

* The output of the program should be 256 human-readable lines of ASCII numbers, which represent the content of the file. The first line should contain the number of occurences of byte with a value of 0x0 (or binary zero) in the file and the last line the number of occurences of byte with value 0xff (or 256 in decimal).
* Measure the running time of the program with:
time programname

== Hints ==

* Does the loop unrolling trick work?
* Perhaps it is possible to use parallel programming or threads?
* Does compilation optimization with -O work?
* Can you replace printf with something faster that you write yourself?
* Perhaps the keyword inline can be used.
* (Sadly mmap for file reading fails in dijkstra) Can you speed up the reading of the file with mmap()? (Note -- mmap not yet explained in the lecture)

== Example code for base program ==

#include <stdlib.h>
#include <stdio.h>

long int stats[256];

int main() {
int i, c;
FILE * f;

f = fopen("random_file", "r");
if(f == NULL) {
perror("slowstat");
exit(EXIT_FAILURE);
}

while((c = fgetc(f)) != EOF) {
stats[c]++;
}

for(i = 0; i < 255; i++) {
printf("%ld\n", stats[i]);
}
exit(EXIT_SUCCESS);
}

ITS8020

2018-11-30T09:35:42Z

Irve: /* Practice */

=ITS8020 Systems Programming=

[https://ois.ttu.ee/portal/page?_pageid=37,674581&_dad=portal&_schema=PORTAL&p_msg=&p_public=1&p_what=1&p_lang=ET&p_open_node2=&p_session_id=70505303&p_id=117259&p_mode=1&p_pageid=OKM_AINE_WEB_OTSING&n_disp_result=1&n_export=0&_init=1&_nextsearch=1&_nextorder=1&_orfn_1=AINER_KOOD&_ordi_1=ASC&_disp_ainer_kood=1&_where_ainer_kood=&_ainer_kood=ITS8020&_disp_ainer_nimetus=1&_where_ainer_nimetus=&_ainer_nimetus=&_disp_ainer_nimetus_en=1&_where_ainer_nimetus_en=&_ainer_nimetus_en=&_disp_ainer_oppejoud=1&_where_ainer_oppejoud=&_ainer_oppejoud=&_disp_ainer_eap=1&_where_ainer_eap=&_ainer_eap=&_where_ainer_eap_vahemik=&_ainer_eap_vahemik=&__ainer_eap_vahemik=&_where_ainer_opj_keel=&_ainer_opj_keel=&_disp_ainer_opetsem=1&_where_ainer_opetsem=&_ainer_opetsem=&_disp_ainer_kodulehe_autor=1&_where_ainer_kodulehe_autor=&_ainer_kodulehe_autor=&_where_ainer_std_id=&_ainer_std_id=&_where_ainer_e_taismaht=&_ainer_e_taismaht=&_where_ainer_e_maht=&_ainer_e_maht=&_where_ainer_e_tase=&_ainer_e_tase=&_where_ainer_e_kinn_kp=&_ainer_e_kinn_kp=&_where_ainer_e_k_maht=&_ainer_e_k_maht=&_where_ainer_e_k_tase=&_ainer_e_k_tase=&_where_ainer_e_k_kinn_kp=&_ainer_e_k_kinn_kp=&_vformaat=VFORMAAT_HTML&n_lov_offset=1&n_row_count=&n_row_pos= Course Card] 
Lecturer: Jaagup Irve <jaagup.irve@ttu.ee> 

For reference: last year materials can be found at [http://lambda.ee/wiki/Real-Time_Operating_Systems_and_Systems_Programming Real-Time Operating Systems and Systems Programming]. Most of it is still relevant.

== Elevator pitch ==

The course is basically an advanced C course which delves into the intricacies of hardware, memory management and operating system design. It looks at basic operating system components (scheduling, mutexes) and also at Linux standard library. You will be expected to program difficult tasks and it will be englightening. The course has been enjoyed by numerous smart students over the years.

== Grading ==

Grading is based on points earned during the course.

90+ points earns a grade of 5, and 50+ lets you pass. Exam can earn you up to 60 points and is difficult. Programming independently (lab) is worth 40 points max. There are 10 bonus points for attending and working on the labs. It is possible to agree on a different course project during the course.

== Exam ==

The first exam will be held in last lecture, the second one in the second week of January.

== Lectures ==
# Introduction (course overview, grades, operator precedence, real time overview) [[Media:Rtos_01.pdf|PDF]]
# Stack Exploration, Long Jump [[Media:Rtos_02.pdf|PDF]]
# Heap [[Media:Rtos_03.pdf|PDF]]
# Hardware, interrupts, basic IO: [https://www.youtube.com/playlist?list=PLMQzXA1f24AdzOb5kRBfN2SkXNrSbdb5L Please watch the videos] [[Media:Rtos_04.pdf|PDF]]
# Signals, System Calls [[Media: Rtos_05.pdf|PDF]]
# Threads [[Media:Rtos_06.pdf|PDF]]
# Scheduling, Processes [[Media:Rtos_07.pdf|PDF]]
# File IO, file and directory management [[Media:Rtos_08.pdf|PDF]]
# Programming an Operating System [[Media:Rtos_09.pdf|PDF]]

== Practice ==
* [http://lambda.ee/wiki/Basic_Linux_command-line_and_utilities_for_accessing_it_(ITI8510) Basic command line and compilation]
* [[Stack Exploration (ITS8020)|Stack Exploration]]
* [[Exploring Debugger (ITS8020)|Exploring Debugger]]
* [[Signals (ITS8020)|Signals]]
* [[Threads (ITS8020)|Threads]]
* [[Processes (ITS8020)|Processes]]
* [[File Attributes (ITS8020)|File Attributes]]
* [[Writing and Reading Binary Data (ITS8020)|Writing and Reading Binary Data]]
* [[Network Sockets (ITS8020)|Network Sockets]]
* [[Optimization (ITS8020)|Optimization]]

== Homework ==

The homework for the course is a file encoder/decoder using a Huffman algorithm. The deadline for the task is November 9, but if you show your progress weekly, it can be extended without penalty depending on the amount of progress shown. The encoder needs to be shown and defended before the lectures conclude.

* [[Huffman Encoder (ITS8020)|Huffman Encoder]]

== Links==

* [http://www.edn.com/design/automotive/4423428/Toyota-s-killer-firmware--Bad-design-and-its-consequences Toyota killer firmware]
* [http://blog.regehr.org/archives/1091 Use of Assertions]
* [https://matt.sh/howto-c How to C in 2016] - or why the lecturer should be deprecated
* [https://avicoder.me/2016/02/01/smashsatck-revived/ Smashing the Stack for Fun and Profit Redone] - a take on a classic
* [https://github.com/s-matyukevich/raspberry-pi-os Raspberry Pi Os] - an opsystem from scratch

Network Sockets (ITS8020)

2018-11-16T09:42:46Z

Irve: /* Connection */

''The goal is to try sending and receiving data over the socket interface''

You will use socket(), connect(), bind(), listen(), accept() and socket addresses for the task.

==Task==

There are two separate tasks.

=== Connection ===

Write a program which tries connecting to a specified machine on specified port so the following command:
connect www.lambda.ee 80
would connect to www.lambda.ee on port 80. Write
<nowiki>GET / HTTP/1.0\r\n\r\n</nowiki>
to the socket and display any resulting data on screen. Terminate when connection is closed.

=== Listening ===

Write a server program which shows on screen whatever data is received from the network. The command line:
listen 3333
would listen on port 3333 and display any received connections.

When connection is made, display the address of the other connection, then display the data until connection is closed.

== Bonus ==

If the former part of the exercises does not provide you with sufficient brain-stimulation. Please try the following: Create a program which outputs the output of "ls -l" to the network on the given socket when connected; using dup() or dup2() functions. For running a progam you could use fork() and execv(). It could work as follows:
lsner 3333

And then you could try it out using netcat for example.

== Tips ==

Use netcat for connecting and listening to your program:
nc www.lambda.ee 80
nc -l 8080

Note that you can only listen to ports starting from 1024. In addition to that, the Dijkstra server has an external firewall which prevents connections from '''outside''' unless you listen on ports 7400-8000 .

Network Sockets (ITS8020)

2018-11-16T09:39:32Z

Irve: Uus lehekülg: '''The goal is to try sending and receiving data over the socket interface'' You will use socket(), connect(), bind(), listen(), accept() and socket addresses for the task. ==Ta...'

''The goal is to try sending and receiving data over the socket interface''

You will use socket(), connect(), bind(), listen(), accept() and socket addresses for the task.

==Task==

There are two separate tasks.

=== Connection ===

Write a program which tries connecting to a specified machine on specified port so the following command:
connect www.lambda.ee 80
would connect to www.lambda.ee on port 80. Write
<nowiki>GET http://courses.cs.ttu.ee/pages/Esileht/ HTTP/1.0\r\n\r\n</nowiki>
to the socket and display any resulting data on screen. Terminate when connection is closed.

=== Listening ===

Write a server program which shows on screen whatever data is received from the network. The command line:
listen 3333
would listen on port 3333 and display any received connections.

When connection is made, display the address of the other connection, then display the data until connection is closed.

== Bonus ==

If the former part of the exercises does not provide you with sufficient brain-stimulation. Please try the following: Create a program which outputs the output of "ls -l" to the network on the given socket when connected; using dup() or dup2() functions. For running a progam you could use fork() and execv(). It could work as follows:
lsner 3333

And then you could try it out using netcat for example.

== Tips ==

Use netcat for connecting and listening to your program:
nc www.lambda.ee 80
nc -l 8080

Note that you can only listen to ports starting from 1024. In addition to that, the Dijkstra server has an external firewall which prevents connections from '''outside''' unless you listen on ports 7400-8000 .

ITS8020

2018-11-16T09:38:13Z

Irve: /* Practice */

=ITS8020 Systems Programming=

[https://ois.ttu.ee/portal/page?_pageid=37,674581&_dad=portal&_schema=PORTAL&p_msg=&p_public=1&p_what=1&p_lang=ET&p_open_node2=&p_session_id=70505303&p_id=117259&p_mode=1&p_pageid=OKM_AINE_WEB_OTSING&n_disp_result=1&n_export=0&_init=1&_nextsearch=1&_nextorder=1&_orfn_1=AINER_KOOD&_ordi_1=ASC&_disp_ainer_kood=1&_where_ainer_kood=&_ainer_kood=ITS8020&_disp_ainer_nimetus=1&_where_ainer_nimetus=&_ainer_nimetus=&_disp_ainer_nimetus_en=1&_where_ainer_nimetus_en=&_ainer_nimetus_en=&_disp_ainer_oppejoud=1&_where_ainer_oppejoud=&_ainer_oppejoud=&_disp_ainer_eap=1&_where_ainer_eap=&_ainer_eap=&_where_ainer_eap_vahemik=&_ainer_eap_vahemik=&__ainer_eap_vahemik=&_where_ainer_opj_keel=&_ainer_opj_keel=&_disp_ainer_opetsem=1&_where_ainer_opetsem=&_ainer_opetsem=&_disp_ainer_kodulehe_autor=1&_where_ainer_kodulehe_autor=&_ainer_kodulehe_autor=&_where_ainer_std_id=&_ainer_std_id=&_where_ainer_e_taismaht=&_ainer_e_taismaht=&_where_ainer_e_maht=&_ainer_e_maht=&_where_ainer_e_tase=&_ainer_e_tase=&_where_ainer_e_kinn_kp=&_ainer_e_kinn_kp=&_where_ainer_e_k_maht=&_ainer_e_k_maht=&_where_ainer_e_k_tase=&_ainer_e_k_tase=&_where_ainer_e_k_kinn_kp=&_ainer_e_k_kinn_kp=&_vformaat=VFORMAAT_HTML&n_lov_offset=1&n_row_count=&n_row_pos= Course Card] 
Lecturer: Jaagup Irve <jaagup.irve@ttu.ee> 

For reference: last year materials can be found at [http://lambda.ee/wiki/Real-Time_Operating_Systems_and_Systems_Programming Real-Time Operating Systems and Systems Programming]. Most of it is still relevant.

== Elevator pitch ==

The course is basically an advanced C course which delves into the intricacies of hardware, memory management and operating system design. It looks at basic operating system components (scheduling, mutexes) and also at Linux standard library. You will be expected to program difficult tasks and it will be englightening. The course has been enjoyed by numerous smart students over the years.

== Grading ==

Grading is based on points earned during the course.

90+ points earns a grade of 5, and 50+ lets you pass. Exam can earn you up to 60 points and is difficult. Programming independently (lab) is worth 40 points max. There are 10 bonus points for attending and working on the labs. It is possible to agree on a different course project during the course.

== Exam ==

The first exam will be held in last lecture, the second one in the second week of January.

== Lectures ==
# Introduction (course overview, grades, operator precedence, real time overview) [[Media:Rtos_01.pdf|PDF]]
# Stack Exploration, Long Jump [[Media:Rtos_02.pdf|PDF]]
# Heap [[Media:Rtos_03.pdf|PDF]]
# Hardware, interrupts, basic IO: [https://www.youtube.com/playlist?list=PLMQzXA1f24AdzOb5kRBfN2SkXNrSbdb5L Please watch the videos] [[Media:Rtos_04.pdf|PDF]]
# Signals, System Calls [[Media: Rtos_05.pdf|PDF]]
# Threads [[Media:Rtos_06.pdf|PDF]]
# Scheduling, Processes [[Media:Rtos_07.pdf|PDF]]
# File IO, file and directory management [[Media:Rtos_08.pdf|PDF]]
# Programming an Operating System [[Media:Rtos_09.pdf|PDF]]

== Practice ==
* [http://lambda.ee/wiki/Basic_Linux_command-line_and_utilities_for_accessing_it_(ITI8510) Basic command line and compilation]
* [[Stack Exploration (ITS8020)|Stack Exploration]]
* [[Exploring Debugger (ITS8020)|Exploring Debugger]]
* [[Signals (ITS8020)|Signals]]
* [[Threads (ITS8020)|Threads]]
* [[Processes (ITS8020)|Processes]]
* [[File Attributes (ITS8020)|File Attributes]]
* [[Writing and Reading Binary Data (ITS8020)|Writing and Reading Binary Data]]
* [[Network Sockets (ITS8020)|Network Sockets]]

== Homework ==

The homework for the course is a file encoder/decoder using a Huffman algorithm. The deadline for the task is November 9, but if you show your progress weekly, it can be extended without penalty depending on the amount of progress shown. The encoder needs to be shown and defended before the lectures conclude.

* [[Huffman Encoder (ITS8020)|Huffman Encoder]]

== Links==

* [http://www.edn.com/design/automotive/4423428/Toyota-s-killer-firmware--Bad-design-and-its-consequences Toyota killer firmware]
* [http://blog.regehr.org/archives/1091 Use of Assertions]
* [https://matt.sh/howto-c How to C in 2016] - or why the lecturer should be deprecated
* [https://avicoder.me/2016/02/01/smashsatck-revived/ Smashing the Stack for Fun and Profit Redone] - a take on a classic
* [https://github.com/s-matyukevich/raspberry-pi-os Raspberry Pi Os] - an opsystem from scratch

Fail:Rtos 09.pdf

2018-11-02T15:43:26Z

Irve:

ITS8020

2018-11-02T15:43:18Z

Irve: /* Lectures */

=ITS8020 Systems Programming=

[https://ois.ttu.ee/portal/page?_pageid=37,674581&_dad=portal&_schema=PORTAL&p_msg=&p_public=1&p_what=1&p_lang=ET&p_open_node2=&p_session_id=70505303&p_id=117259&p_mode=1&p_pageid=OKM_AINE_WEB_OTSING&n_disp_result=1&n_export=0&_init=1&_nextsearch=1&_nextorder=1&_orfn_1=AINER_KOOD&_ordi_1=ASC&_disp_ainer_kood=1&_where_ainer_kood=&_ainer_kood=ITS8020&_disp_ainer_nimetus=1&_where_ainer_nimetus=&_ainer_nimetus=&_disp_ainer_nimetus_en=1&_where_ainer_nimetus_en=&_ainer_nimetus_en=&_disp_ainer_oppejoud=1&_where_ainer_oppejoud=&_ainer_oppejoud=&_disp_ainer_eap=1&_where_ainer_eap=&_ainer_eap=&_where_ainer_eap_vahemik=&_ainer_eap_vahemik=&__ainer_eap_vahemik=&_where_ainer_opj_keel=&_ainer_opj_keel=&_disp_ainer_opetsem=1&_where_ainer_opetsem=&_ainer_opetsem=&_disp_ainer_kodulehe_autor=1&_where_ainer_kodulehe_autor=&_ainer_kodulehe_autor=&_where_ainer_std_id=&_ainer_std_id=&_where_ainer_e_taismaht=&_ainer_e_taismaht=&_where_ainer_e_maht=&_ainer_e_maht=&_where_ainer_e_tase=&_ainer_e_tase=&_where_ainer_e_kinn_kp=&_ainer_e_kinn_kp=&_where_ainer_e_k_maht=&_ainer_e_k_maht=&_where_ainer_e_k_tase=&_ainer_e_k_tase=&_where_ainer_e_k_kinn_kp=&_ainer_e_k_kinn_kp=&_vformaat=VFORMAAT_HTML&n_lov_offset=1&n_row_count=&n_row_pos= Course Card] 
Lecturer: Jaagup Irve <jaagup.irve@ttu.ee> 

For reference: last year materials can be found at [http://lambda.ee/wiki/Real-Time_Operating_Systems_and_Systems_Programming Real-Time Operating Systems and Systems Programming]. Most of it is still relevant.

== Elevator pitch ==

The course is basically an advanced C course which delves into the intricacies of hardware, memory management and operating system design. It looks at basic operating system components (scheduling, mutexes) and also at Linux standard library. You will be expected to program difficult tasks and it will be englightening. The course has been enjoyed by numerous smart students over the years.

== Grading ==

Grading is based on points earned during the course.

90+ points earns a grade of 5, and 50+ lets you pass. Exam can earn you up to 60 points and is difficult. Programming independently (lab) is worth 40 points max. There are 10 bonus points for attending and working on the labs. It is possible to agree on a different course project during the course.

== Exam ==

The first exam will be held in last lecture, the second one in the second week of January.

== Lectures ==
# Introduction (course overview, grades, operator precedence, real time overview) [[Media:Rtos_01.pdf|PDF]]
# Stack Exploration, Long Jump [[Media:Rtos_02.pdf|PDF]]
# Heap [[Media:Rtos_03.pdf|PDF]]
# Hardware, interrupts, basic IO: [https://www.youtube.com/playlist?list=PLMQzXA1f24AdzOb5kRBfN2SkXNrSbdb5L Please watch the videos] [[Media:Rtos_04.pdf|PDF]]
# Signals, System Calls [[Media: Rtos_05.pdf|PDF]]
# Threads [[Media:Rtos_06.pdf|PDF]]
# Scheduling, Processes [[Media:Rtos_07.pdf|PDF]]
# File IO, file and directory management [[Media:Rtos_08.pdf|PDF]]
# Programming an Operating System [[Media:Rtos_09.pdf|PDF]]

== Practice ==
* [http://lambda.ee/wiki/Basic_Linux_command-line_and_utilities_for_accessing_it_(ITI8510) Basic command line and compilation]
* [[Stack Exploration (ITS8020)|Stack Exploration]]
* [[Exploring Debugger (ITS8020)|Exploring Debugger]]
* [[Signals (ITS8020)|Signals]]
* [[Threads (ITS8020)|Threads]]
* [[Processes (ITS8020)|Processes]]
* [[File Attributes (ITS8020)|File Attributes]]
* [[Writing and Reading Binary Data (ITS8020)|Writing and Reading Binary Data]]

== Homework ==

The homework for the course is a file encoder/decoder using a Huffman algorithm. The deadline for the task is November 9, but if you show your progress weekly, it can be extended without penalty depending on the amount of progress shown. The encoder needs to be shown and defended before the lectures conclude.

* [[Huffman Encoder (ITS8020)|Huffman Encoder]]

== Links==

* [http://www.edn.com/design/automotive/4423428/Toyota-s-killer-firmware--Bad-design-and-its-consequences Toyota killer firmware]
* [http://blog.regehr.org/archives/1091 Use of Assertions]
* [https://matt.sh/howto-c How to C in 2016] - or why the lecturer should be deprecated
* [https://avicoder.me/2016/02/01/smashsatck-revived/ Smashing the Stack for Fun and Profit Redone] - a take on a classic
* [https://github.com/s-matyukevich/raspberry-pi-os Raspberry Pi Os] - an opsystem from scratch

Writing and Reading Binary Data (ITS8020)

2018-11-02T09:29:17Z

Irve: Uus lehekülg: 'This practice is about writing data in binary format. == Task == There are two tasks; the first one is simple fread() fwrite() to get the general idea accross, the second need...'

This practice is about writing data in binary format.

== Task ==

There are two tasks; the first one is simple fread() fwrite() to get the general idea accross, the second needs some thinking.

=== Runtimes ===

* Write a program which counts and prints how many times it has been run.
** Save the amount of runs into a file named runtimes.dat
** If the file is missing, write a binary 1 into the file, save and exit.
** If the file exists, read the count from the file, increment it, print it and write the new count into the file before exiting.

=== Array to file and from file ===

Here we could also learn using [http://linux.die.net/man/3/getopt getopt()] function, if task seems too simple.

* If the program starts without command line options, show help
* If program is run with
table -c filename.dat -n 10
: Create 10x10 element 2d array (okay to create just a multiplication table here) and write it into file named filename.dat (save size, then elements)
* If program is run with
table -r filename.dat
: Open the file, read the array dimensions if stored, show the array on the screen.
äidake tabel ekraanile.

== Hints ==

* It is advisable to store the table so that the first 4 bytes of the file hold the table dimensions, then the array elements would follow.
* If the numbers in file are human-readable you are doing the binary wrong.

ITS8020

2018-11-02T09:28:36Z

Irve:

=ITS8020 Systems Programming=

[https://ois.ttu.ee/portal/page?_pageid=37,674581&_dad=portal&_schema=PORTAL&p_msg=&p_public=1&p_what=1&p_lang=ET&p_open_node2=&p_session_id=70505303&p_id=117259&p_mode=1&p_pageid=OKM_AINE_WEB_OTSING&n_disp_result=1&n_export=0&_init=1&_nextsearch=1&_nextorder=1&_orfn_1=AINER_KOOD&_ordi_1=ASC&_disp_ainer_kood=1&_where_ainer_kood=&_ainer_kood=ITS8020&_disp_ainer_nimetus=1&_where_ainer_nimetus=&_ainer_nimetus=&_disp_ainer_nimetus_en=1&_where_ainer_nimetus_en=&_ainer_nimetus_en=&_disp_ainer_oppejoud=1&_where_ainer_oppejoud=&_ainer_oppejoud=&_disp_ainer_eap=1&_where_ainer_eap=&_ainer_eap=&_where_ainer_eap_vahemik=&_ainer_eap_vahemik=&__ainer_eap_vahemik=&_where_ainer_opj_keel=&_ainer_opj_keel=&_disp_ainer_opetsem=1&_where_ainer_opetsem=&_ainer_opetsem=&_disp_ainer_kodulehe_autor=1&_where_ainer_kodulehe_autor=&_ainer_kodulehe_autor=&_where_ainer_std_id=&_ainer_std_id=&_where_ainer_e_taismaht=&_ainer_e_taismaht=&_where_ainer_e_maht=&_ainer_e_maht=&_where_ainer_e_tase=&_ainer_e_tase=&_where_ainer_e_kinn_kp=&_ainer_e_kinn_kp=&_where_ainer_e_k_maht=&_ainer_e_k_maht=&_where_ainer_e_k_tase=&_ainer_e_k_tase=&_where_ainer_e_k_kinn_kp=&_ainer_e_k_kinn_kp=&_vformaat=VFORMAAT_HTML&n_lov_offset=1&n_row_count=&n_row_pos= Course Card] 
Lecturer: Jaagup Irve <jaagup.irve@ttu.ee> 

For reference: last year materials can be found at [http://lambda.ee/wiki/Real-Time_Operating_Systems_and_Systems_Programming Real-Time Operating Systems and Systems Programming]. Most of it is still relevant.

== Elevator pitch ==

The course is basically an advanced C course which delves into the intricacies of hardware, memory management and operating system design. It looks at basic operating system components (scheduling, mutexes) and also at Linux standard library. You will be expected to program difficult tasks and it will be englightening. The course has been enjoyed by numerous smart students over the years.

== Grading ==

Grading is based on points earned during the course.

90+ points earns a grade of 5, and 50+ lets you pass. Exam can earn you up to 60 points and is difficult. Programming independently (lab) is worth 40 points max. There are 10 bonus points for attending and working on the labs. It is possible to agree on a different course project during the course.

== Exam ==

The first exam will be held in last lecture, the second one in the second week of January.

== Lectures ==
# Introduction (course overview, grades, operator precedence, real time overview) [[Media:Rtos_01.pdf|PDF]]
# Stack Exploration, Long Jump [[Media:Rtos_02.pdf|PDF]]
# Heap [[Media:Rtos_03.pdf|PDF]]
# Hardware, interrupts, basic IO: [https://www.youtube.com/playlist?list=PLMQzXA1f24AdzOb5kRBfN2SkXNrSbdb5L Please watch the videos] [[Media:Rtos_04.pdf|PDF]]
# Signals, System Calls [[Media: Rtos_05.pdf|PDF]]
# Threads [[Media:Rtos_06.pdf|PDF]]
# Scheduling, Processes [[Media:Rtos_07.pdf|PDF]]
# File IO, file and directory management [[Media:Rtos_08.pdf|PDF]]

== Practice ==
* [http://lambda.ee/wiki/Basic_Linux_command-line_and_utilities_for_accessing_it_(ITI8510) Basic command line and compilation]
* [[Stack Exploration (ITS8020)|Stack Exploration]]
* [[Exploring Debugger (ITS8020)|Exploring Debugger]]
* [[Signals (ITS8020)|Signals]]
* [[Threads (ITS8020)|Threads]]
* [[Processes (ITS8020)|Processes]]
* [[File Attributes (ITS8020)|File Attributes]]
* [[Writing and Reading Binary Data (ITS8020)|Writing and Reading Binary Data]]

== Homework ==

The homework for the course is a file encoder/decoder using a Huffman algorithm. The deadline for the task is November 9, but if you show your progress weekly, it can be extended without penalty depending on the amount of progress shown. The encoder needs to be shown and defended before the lectures conclude.

* [[Huffman Encoder (ITS8020)|Huffman Encoder]]

== Links==

* [http://www.edn.com/design/automotive/4423428/Toyota-s-killer-firmware--Bad-design-and-its-consequences Toyota killer firmware]
* [http://blog.regehr.org/archives/1091 Use of Assertions]
* [https://matt.sh/howto-c How to C in 2016] - or why the lecturer should be deprecated
* [https://avicoder.me/2016/02/01/smashsatck-revived/ Smashing the Stack for Fun and Profit Redone] - a take on a classic
* [https://github.com/s-matyukevich/raspberry-pi-os Raspberry Pi Os] - an opsystem from scratch

Huffman Encoder (ITS8020)

2018-10-26T09:07:24Z

Irve: Uus lehekülg: '''The Huffman encoder assignment helps to discover the wonderful world of pointers, debugging and segmentation faults.'' Your task is to implement an Hufmann encoder for statist...'

''The Huffman encoder assignment helps to discover the wonderful world of pointers, debugging and segmentation faults.''

Your task is to implement an Hufmann encoder for statistical compression in C. The task is described on [http://deepthought.ttu.ee/it/vorgutarkvara/wav3050/lab1.html this old page]; ignore its presentation guidelines with Tanel Tammet: send them to me.

[http://deepthought.ttu.ee/it/vorgutarkvara/wav3050/lab1_hufmann.html The description of the algorithm].

== Grades ==

If you want to predict your grade you might find following helpful:
* 10p: Compresses and decompresses some regular text files (this is mandatory) the .c file of your program for example
* 10p Compresses and decompresses most input you can have occasional errors with binary files
* 5p: Compresses and decompresses almost everything program can work with all non-tricky inputs
* 5p: Compresses and decompresses even the wierd files program can work with tricky inputs
* 5p: Accepts stdin/stdout when no options or -d are present
myhuf < asd > asd.out
myhuf -d < asd.out > asd2
* OR accepts file name arguments for both input and output files
myhuf asd asd.out
myhuf -d asd.out asd2
* 1p: Has a working makefile (or "make programname" works)
* 1p: Returns 0 on successful exit; nonzero on any errors
* 1p: Sends error messages to stderr
* 1p: Program is not slow
* 1p: program does not crash
+1p per week up to 3, when presented earlier than the deadline

ITS8020

2018-10-26T09:07:10Z

Irve: /* Homework */

=ITS8020 Systems Programming=

[https://ois.ttu.ee/portal/page?_pageid=37,674581&_dad=portal&_schema=PORTAL&p_msg=&p_public=1&p_what=1&p_lang=ET&p_open_node2=&p_session_id=70505303&p_id=117259&p_mode=1&p_pageid=OKM_AINE_WEB_OTSING&n_disp_result=1&n_export=0&_init=1&_nextsearch=1&_nextorder=1&_orfn_1=AINER_KOOD&_ordi_1=ASC&_disp_ainer_kood=1&_where_ainer_kood=&_ainer_kood=ITS8020&_disp_ainer_nimetus=1&_where_ainer_nimetus=&_ainer_nimetus=&_disp_ainer_nimetus_en=1&_where_ainer_nimetus_en=&_ainer_nimetus_en=&_disp_ainer_oppejoud=1&_where_ainer_oppejoud=&_ainer_oppejoud=&_disp_ainer_eap=1&_where_ainer_eap=&_ainer_eap=&_where_ainer_eap_vahemik=&_ainer_eap_vahemik=&__ainer_eap_vahemik=&_where_ainer_opj_keel=&_ainer_opj_keel=&_disp_ainer_opetsem=1&_where_ainer_opetsem=&_ainer_opetsem=&_disp_ainer_kodulehe_autor=1&_where_ainer_kodulehe_autor=&_ainer_kodulehe_autor=&_where_ainer_std_id=&_ainer_std_id=&_where_ainer_e_taismaht=&_ainer_e_taismaht=&_where_ainer_e_maht=&_ainer_e_maht=&_where_ainer_e_tase=&_ainer_e_tase=&_where_ainer_e_kinn_kp=&_ainer_e_kinn_kp=&_where_ainer_e_k_maht=&_ainer_e_k_maht=&_where_ainer_e_k_tase=&_ainer_e_k_tase=&_where_ainer_e_k_kinn_kp=&_ainer_e_k_kinn_kp=&_vformaat=VFORMAAT_HTML&n_lov_offset=1&n_row_count=&n_row_pos= Course Card] 
Lecturer: Jaagup Irve <jaagup.irve@ttu.ee> 

For reference: last year materials can be found at [http://lambda.ee/wiki/Real-Time_Operating_Systems_and_Systems_Programming Real-Time Operating Systems and Systems Programming]. Most of it is still relevant.

== Elevator pitch ==

The course is basically an advanced C course which delves into the intricacies of hardware, memory management and operating system design. It looks at basic operating system components (scheduling, mutexes) and also at Linux standard library. You will be expected to program difficult tasks and it will be englightening. The course has been enjoyed by numerous smart students over the years.

== Grading ==

Grading is based on points earned during the course.

90+ points earns a grade of 5, and 50+ lets you pass. Exam can earn you up to 60 points and is difficult. Programming independently (lab) is worth 40 points max. There are 10 bonus points for attending and working on the labs. It is possible to agree on a different course project during the course.

== Exam ==

The first exam will be held in last lecture, the second one in the second week of January.

== Lectures ==
# Introduction (course overview, grades, operator precedence, real time overview) [[Media:Rtos_01.pdf|PDF]]
# Stack Exploration, Long Jump [[Media:Rtos_02.pdf|PDF]]
# Heap [[Media:Rtos_03.pdf|PDF]]
# Hardware, interrupts, basic IO: [https://www.youtube.com/playlist?list=PLMQzXA1f24AdzOb5kRBfN2SkXNrSbdb5L Please watch the videos] [[Media:Rtos_04.pdf|PDF]]
# Signals, System Calls [[Media: Rtos_05.pdf|PDF]]
# Threads [[Media:Rtos_06.pdf|PDF]]
# Scheduling, Processes [[Media:Rtos_07.pdf|PDF]]
# File IO, file and directory management [[Media:Rtos_08.pdf|PDF]]

== Practice ==
* [http://lambda.ee/wiki/Basic_Linux_command-line_and_utilities_for_accessing_it_(ITI8510) Basic command line and compilation]
* [[Stack Exploration (ITS8020)|Stack Exploration]]
* [[Exploring Debugger (ITS8020)|Exploring Debugger]]
* [[Signals (ITS8020)|Signals]]
* [[Threads (ITS8020)|Threads]]
* [[Processes (ITS8020)|Processes]]
* [[File Attributes (ITS8020)|File Attributes]]

== Homework ==

The homework for the course is a file encoder/decoder using a Huffman algorithm. The deadline for the task is November 9, but if you show your progress weekly, it can be extended without penalty depending on the amount of progress shown. The encoder needs to be shown and defended before the lectures conclude.

* [[Huffman Encoder (ITS8020)|Huffman Encoder]]

== Links==

* [http://www.edn.com/design/automotive/4423428/Toyota-s-killer-firmware--Bad-design-and-its-consequences Toyota killer firmware]
* [http://blog.regehr.org/archives/1091 Use of Assertions]
* [https://matt.sh/howto-c How to C in 2016] - or why the lecturer should be deprecated
* [https://avicoder.me/2016/02/01/smashsatck-revived/ Smashing the Stack for Fun and Profit Redone] - a take on a classic
* [https://github.com/s-matyukevich/raspberry-pi-os Raspberry Pi Os] - an opsystem from scratch

ITS8020

2018-10-26T08:42:43Z

Irve:

=ITS8020 Systems Programming=

[https://ois.ttu.ee/portal/page?_pageid=37,674581&_dad=portal&_schema=PORTAL&p_msg=&p_public=1&p_what=1&p_lang=ET&p_open_node2=&p_session_id=70505303&p_id=117259&p_mode=1&p_pageid=OKM_AINE_WEB_OTSING&n_disp_result=1&n_export=0&_init=1&_nextsearch=1&_nextorder=1&_orfn_1=AINER_KOOD&_ordi_1=ASC&_disp_ainer_kood=1&_where_ainer_kood=&_ainer_kood=ITS8020&_disp_ainer_nimetus=1&_where_ainer_nimetus=&_ainer_nimetus=&_disp_ainer_nimetus_en=1&_where_ainer_nimetus_en=&_ainer_nimetus_en=&_disp_ainer_oppejoud=1&_where_ainer_oppejoud=&_ainer_oppejoud=&_disp_ainer_eap=1&_where_ainer_eap=&_ainer_eap=&_where_ainer_eap_vahemik=&_ainer_eap_vahemik=&__ainer_eap_vahemik=&_where_ainer_opj_keel=&_ainer_opj_keel=&_disp_ainer_opetsem=1&_where_ainer_opetsem=&_ainer_opetsem=&_disp_ainer_kodulehe_autor=1&_where_ainer_kodulehe_autor=&_ainer_kodulehe_autor=&_where_ainer_std_id=&_ainer_std_id=&_where_ainer_e_taismaht=&_ainer_e_taismaht=&_where_ainer_e_maht=&_ainer_e_maht=&_where_ainer_e_tase=&_ainer_e_tase=&_where_ainer_e_kinn_kp=&_ainer_e_kinn_kp=&_where_ainer_e_k_maht=&_ainer_e_k_maht=&_where_ainer_e_k_tase=&_ainer_e_k_tase=&_where_ainer_e_k_kinn_kp=&_ainer_e_k_kinn_kp=&_vformaat=VFORMAAT_HTML&n_lov_offset=1&n_row_count=&n_row_pos= Course Card] 
Lecturer: Jaagup Irve <jaagup.irve@ttu.ee> 

For reference: last year materials can be found at [http://lambda.ee/wiki/Real-Time_Operating_Systems_and_Systems_Programming Real-Time Operating Systems and Systems Programming]. Most of it is still relevant.

== Elevator pitch ==

The course is basically an advanced C course which delves into the intricacies of hardware, memory management and operating system design. It looks at basic operating system components (scheduling, mutexes) and also at Linux standard library. You will be expected to program difficult tasks and it will be englightening. The course has been enjoyed by numerous smart students over the years.

== Grading ==

Grading is based on points earned during the course.

90+ points earns a grade of 5, and 50+ lets you pass. Exam can earn you up to 60 points and is difficult. Programming independently (lab) is worth 40 points max. There are 10 bonus points for attending and working on the labs. It is possible to agree on a different course project during the course.

== Exam ==

The first exam will be held in last lecture, the second one in the second week of January.

== Lectures ==
# Introduction (course overview, grades, operator precedence, real time overview) [[Media:Rtos_01.pdf|PDF]]
# Stack Exploration, Long Jump [[Media:Rtos_02.pdf|PDF]]
# Heap [[Media:Rtos_03.pdf|PDF]]
# Hardware, interrupts, basic IO: [https://www.youtube.com/playlist?list=PLMQzXA1f24AdzOb5kRBfN2SkXNrSbdb5L Please watch the videos] [[Media:Rtos_04.pdf|PDF]]
# Signals, System Calls [[Media: Rtos_05.pdf|PDF]]
# Threads [[Media:Rtos_06.pdf|PDF]]
# Scheduling, Processes [[Media:Rtos_07.pdf|PDF]]
# File IO, file and directory management [[Media:Rtos_08.pdf|PDF]]

== Practice ==
* [http://lambda.ee/wiki/Basic_Linux_command-line_and_utilities_for_accessing_it_(ITI8510) Basic command line and compilation]
* [[Stack Exploration (ITS8020)|Stack Exploration]]
* [[Exploring Debugger (ITS8020)|Exploring Debugger]]
* [[Signals (ITS8020)|Signals]]
* [[Threads (ITS8020)|Threads]]
* [[Processes (ITS8020)|Processes]]
* [[File Attributes (ITS8020)|File Attributes]]

== Homework ==

The homework for the course is a file encoder/decoder using a Huffman algorithm. The deadline for the task is November 9, but if you show your progress weekly, it can be extended without penalty depending on the amount of progress shown. The encoder needs to be shown and defended before the lectures conclude.

== Links==

* [http://www.edn.com/design/automotive/4423428/Toyota-s-killer-firmware--Bad-design-and-its-consequences Toyota killer firmware]
* [http://blog.regehr.org/archives/1091 Use of Assertions]
* [https://matt.sh/howto-c How to C in 2016] - or why the lecturer should be deprecated
* [https://avicoder.me/2016/02/01/smashsatck-revived/ Smashing the Stack for Fun and Profit Redone] - a take on a classic
* [https://github.com/s-matyukevich/raspberry-pi-os Raspberry Pi Os] - an opsystem from scratch

Fail:Rtos 04.pdf

2018-10-26T08:39:31Z

Irve:

Fail:Rtos 08.pdf

2018-10-26T08:39:12Z

Irve:

Fail:Rtos 07.pdf

2018-10-26T08:38:24Z

Irve:

Fail:Rtos 06.pdf

2018-10-26T08:38:13Z

Irve:

ITS8020

2018-10-26T08:38:05Z

Irve: /* Lectures */

=ITS8020 Systems Programming=

[https://ois.ttu.ee/portal/page?_pageid=37,674581&_dad=portal&_schema=PORTAL&p_msg=&p_public=1&p_what=1&p_lang=ET&p_open_node2=&p_session_id=70505303&p_id=117259&p_mode=1&p_pageid=OKM_AINE_WEB_OTSING&n_disp_result=1&n_export=0&_init=1&_nextsearch=1&_nextorder=1&_orfn_1=AINER_KOOD&_ordi_1=ASC&_disp_ainer_kood=1&_where_ainer_kood=&_ainer_kood=ITS8020&_disp_ainer_nimetus=1&_where_ainer_nimetus=&_ainer_nimetus=&_disp_ainer_nimetus_en=1&_where_ainer_nimetus_en=&_ainer_nimetus_en=&_disp_ainer_oppejoud=1&_where_ainer_oppejoud=&_ainer_oppejoud=&_disp_ainer_eap=1&_where_ainer_eap=&_ainer_eap=&_where_ainer_eap_vahemik=&_ainer_eap_vahemik=&__ainer_eap_vahemik=&_where_ainer_opj_keel=&_ainer_opj_keel=&_disp_ainer_opetsem=1&_where_ainer_opetsem=&_ainer_opetsem=&_disp_ainer_kodulehe_autor=1&_where_ainer_kodulehe_autor=&_ainer_kodulehe_autor=&_where_ainer_std_id=&_ainer_std_id=&_where_ainer_e_taismaht=&_ainer_e_taismaht=&_where_ainer_e_maht=&_ainer_e_maht=&_where_ainer_e_tase=&_ainer_e_tase=&_where_ainer_e_kinn_kp=&_ainer_e_kinn_kp=&_where_ainer_e_k_maht=&_ainer_e_k_maht=&_where_ainer_e_k_tase=&_ainer_e_k_tase=&_where_ainer_e_k_kinn_kp=&_ainer_e_k_kinn_kp=&_vformaat=VFORMAAT_HTML&n_lov_offset=1&n_row_count=&n_row_pos= Course Card] 
Lecturer: Jaagup Irve <jaagup.irve@ttu.ee> 

For reference: last year materials can be found at [http://lambda.ee/wiki/Real-Time_Operating_Systems_and_Systems_Programming Real-Time Operating Systems and Systems Programming]. Most of it is still relevant.

== Elevator pitch ==

The course is basically an advanced C course which delves into the intricacies of hardware, memory management and operating system design. It looks at basic operating system components (scheduling, mutexes) and also at Linux standard library. You will be expected to program difficult tasks and it will be englightening. The course has been enjoyed by numerous smart students over the years.

== Grading ==

Grading is based on points earned during the course.

90+ points earns a grade of 5, and 50+ lets you pass. Exam can earn you up to 60 points and is difficult. Programming independently (lab) is worth 40 points max. There are 10 bonus points for attending and working on the labs. It is possible to agree on a different course project during the course.

== Lectures ==
# Introduction (course overview, grades, operator precedence, real time overview) [[Media:Rtos_01.pdf|PDF]]
# Stack Exploration, Long Jump [[Media:Rtos_02.pdf|PDF]]
# Heap [[Media:Rtos_03.pdf|PDF]]
# Hardware, interrupts, basic IO: [https://www.youtube.com/playlist?list=PLMQzXA1f24AdzOb5kRBfN2SkXNrSbdb5L Please watch the videos] [[Media:Rtos_04.pdf|PDF]]
# Signals, System Calls [[Media: Rtos_05.pdf|PDF]]
# Threads [[Media:Rtos_06.pdf|PDF]]
# Scheduling, Processes [[Media:Rtos_07.pdf|PDF]]
# File IO, file and directory management [[Media:Rtos_08.pdf|PDF]]

== Practice ==
* [http://lambda.ee/wiki/Basic_Linux_command-line_and_utilities_for_accessing_it_(ITI8510) Basic command line and compilation]
* [[Stack Exploration (ITS8020)|Stack Exploration]]
* [[Exploring Debugger (ITS8020)|Exploring Debugger]]
* [[Signals (ITS8020)|Signals]]
* [[Threads (ITS8020)|Threads]]
* [[Processes (ITS8020)|Processes]]
* [[File Attributes (ITS8020)|File Attributes]]

== Links==

* [http://www.edn.com/design/automotive/4423428/Toyota-s-killer-firmware--Bad-design-and-its-consequences Toyota killer firmware]
* [http://blog.regehr.org/archives/1091 Use of Assertions]
* [https://matt.sh/howto-c How to C in 2016] - or why the lecturer should be deprecated
* [https://avicoder.me/2016/02/01/smashsatck-revived/ Smashing the Stack for Fun and Profit Redone] - a take on a classic
* [https://github.com/s-matyukevich/raspberry-pi-os Raspberry Pi Os] - an opsystem from scratch

File Attributes (ITS8020)

2018-10-26T08:36:01Z

Irve: Uus lehekülg: '''We practice using structures in standard library and read file information'' == Task == Write a program, which takes a filename as an argument and then tries to show the att...'

''We practice using structures in standard library and read file information''

== Task ==

Write a program, which takes a filename as an argument and then tries to show the attributes of the file: basically calls the stat() function.

When the file is a directory, the program shows the files in that directory (don't show hidden files). When the user runs the program without extra arguments, just show the contents of the working directory. For symbolic links, show the data about the target, not the link itself.

Only show these attributes:
* File size
* Can the owner read?
* Can the owner write?
* Can the owner execute?

== Hints ==

* File existence can be checked with function [http://linux.die.net/man/2/access access()].
* You can get the file attributes using [http://linux.die.net/man/2/stat man stat()] function.
* The owner permissions are easier to understand using [http://linux.die.net/man/2/chmod man chmod()] (or man stat in the terminal), which provides you with the list of constants which can be compared using if and & to check for the particurlar permission.
* File is hidden if it starts with a dot.
* For the directory you can use [http://linux.die.net/man/3/opendir opendir()] and [http://linux.die.net/man/3/readdir readdir()] functions.

=== A Philosophical Detour ===

You may note that the file size attribute has off_t as a type. How to print its contents? Which character should one use with % sign for printf()?

Since off_t can depend on the system, the most rational choice would be to print an unsigned long int and to convert off_t into the corresponding long int using a (''cast'').

ITS8020

2018-10-26T08:35:03Z

Irve: /* Practice */

=ITS8020 Systems Programming=

[https://ois.ttu.ee/portal/page?_pageid=37,674581&_dad=portal&_schema=PORTAL&p_msg=&p_public=1&p_what=1&p_lang=ET&p_open_node2=&p_session_id=70505303&p_id=117259&p_mode=1&p_pageid=OKM_AINE_WEB_OTSING&n_disp_result=1&n_export=0&_init=1&_nextsearch=1&_nextorder=1&_orfn_1=AINER_KOOD&_ordi_1=ASC&_disp_ainer_kood=1&_where_ainer_kood=&_ainer_kood=ITS8020&_disp_ainer_nimetus=1&_where_ainer_nimetus=&_ainer_nimetus=&_disp_ainer_nimetus_en=1&_where_ainer_nimetus_en=&_ainer_nimetus_en=&_disp_ainer_oppejoud=1&_where_ainer_oppejoud=&_ainer_oppejoud=&_disp_ainer_eap=1&_where_ainer_eap=&_ainer_eap=&_where_ainer_eap_vahemik=&_ainer_eap_vahemik=&__ainer_eap_vahemik=&_where_ainer_opj_keel=&_ainer_opj_keel=&_disp_ainer_opetsem=1&_where_ainer_opetsem=&_ainer_opetsem=&_disp_ainer_kodulehe_autor=1&_where_ainer_kodulehe_autor=&_ainer_kodulehe_autor=&_where_ainer_std_id=&_ainer_std_id=&_where_ainer_e_taismaht=&_ainer_e_taismaht=&_where_ainer_e_maht=&_ainer_e_maht=&_where_ainer_e_tase=&_ainer_e_tase=&_where_ainer_e_kinn_kp=&_ainer_e_kinn_kp=&_where_ainer_e_k_maht=&_ainer_e_k_maht=&_where_ainer_e_k_tase=&_ainer_e_k_tase=&_where_ainer_e_k_kinn_kp=&_ainer_e_k_kinn_kp=&_vformaat=VFORMAAT_HTML&n_lov_offset=1&n_row_count=&n_row_pos= Course Card] 
Lecturer: Jaagup Irve <jaagup.irve@ttu.ee> 

For reference: last year materials can be found at [http://lambda.ee/wiki/Real-Time_Operating_Systems_and_Systems_Programming Real-Time Operating Systems and Systems Programming]. Most of it is still relevant.

== Elevator pitch ==

The course is basically an advanced C course which delves into the intricacies of hardware, memory management and operating system design. It looks at basic operating system components (scheduling, mutexes) and also at Linux standard library. You will be expected to program difficult tasks and it will be englightening. The course has been enjoyed by numerous smart students over the years.

== Grading ==

Grading is based on points earned during the course.

90+ points earns a grade of 5, and 50+ lets you pass. Exam can earn you up to 60 points and is difficult. Programming independently (lab) is worth 40 points max. There are 10 bonus points for attending and working on the labs. It is possible to agree on a different course project during the course.

== Lectures ==
# Introduction (course overview, grades, operator precedence, real time overview) [[Media:Rtos_01.pdf|PDF]]
# Stack Exploration, Long Jump [[Media:Rtos_02.pdf|PDF]]
# Heap [[Media:Rtos_03.pdf|PDF]]
# Hardware, interrupts, basic IO: [https://www.youtube.com/playlist?list=PLMQzXA1f24AdzOb5kRBfN2SkXNrSbdb5L Please watch the videos] [[Media:Rtos_04.pdf|PDF]]
# Signals, System Calls [[Media: Rtos_05.pdf|PDF]]

== Practice ==
* [http://lambda.ee/wiki/Basic_Linux_command-line_and_utilities_for_accessing_it_(ITI8510) Basic command line and compilation]
* [[Stack Exploration (ITS8020)|Stack Exploration]]
* [[Exploring Debugger (ITS8020)|Exploring Debugger]]
* [[Signals (ITS8020)|Signals]]
* [[Threads (ITS8020)|Threads]]
* [[Processes (ITS8020)|Processes]]
* [[File Attributes (ITS8020)|File Attributes]]

== Links==

* [http://www.edn.com/design/automotive/4423428/Toyota-s-killer-firmware--Bad-design-and-its-consequences Toyota killer firmware]
* [http://blog.regehr.org/archives/1091 Use of Assertions]
* [https://matt.sh/howto-c How to C in 2016] - or why the lecturer should be deprecated
* [https://avicoder.me/2016/02/01/smashsatck-revived/ Smashing the Stack for Fun and Profit Redone] - a take on a classic
* [https://github.com/s-matyukevich/raspberry-pi-os Raspberry Pi Os] - an opsystem from scratch

Processes (ITS8020)

2018-10-19T08:40:26Z

Irve: Uus lehekülg: '{{its8020}} ''We look at ways to execute a program'' The goal of the lab is to use three different programs to see how to execute programs. It's really simple this time. == Tas...'

{{its8020}}
''We look at ways to execute a program''

The goal of the lab is to use three different programs to see how to execute programs. It's really simple this time.

== Task ==

Write three programs.

First one -- execute -- runs the program "stopper" (you can find it in the prototype below) with argument "-s" from the same directory where it is located (use only exec()).

The second -- runner -- runs program "stopper" with argument "-s" from the same directory where it is located and waits for it to finish. After the program has concluded, it prints "runner: Stopped". (fork() + exec() + wait())

Third program -- backgrounder -- runs the program "stopper" with an argument of "-s", but does not wait for it to conclude; it exits. This would be analogous to the Daemon pattern explained in the lecture.

Backgrounder should print the PID of itself and the child when it runs.

NB! If you want to compile only the first program, write "make stopper" or "make runner".

== Prototype ==

The prototype can be found at /export/kursused/iti8510/ (or [http://dijkstra.cs.ttu.ee/iti8510/processes.tar.gz] )
To copy the file to the current directory:
cp /export/kursused/iti8510/processes.tar.gz .

Untar it:
tar -xzvf processes.tar.gz

ITS8020

2018-10-19T08:39:59Z

Irve: /* Practice */

=ITS8020 Systems Programming=

[https://ois.ttu.ee/portal/page?_pageid=37,674581&_dad=portal&_schema=PORTAL&p_msg=&p_public=1&p_what=1&p_lang=ET&p_open_node2=&p_session_id=70505303&p_id=117259&p_mode=1&p_pageid=OKM_AINE_WEB_OTSING&n_disp_result=1&n_export=0&_init=1&_nextsearch=1&_nextorder=1&_orfn_1=AINER_KOOD&_ordi_1=ASC&_disp_ainer_kood=1&_where_ainer_kood=&_ainer_kood=ITS8020&_disp_ainer_nimetus=1&_where_ainer_nimetus=&_ainer_nimetus=&_disp_ainer_nimetus_en=1&_where_ainer_nimetus_en=&_ainer_nimetus_en=&_disp_ainer_oppejoud=1&_where_ainer_oppejoud=&_ainer_oppejoud=&_disp_ainer_eap=1&_where_ainer_eap=&_ainer_eap=&_where_ainer_eap_vahemik=&_ainer_eap_vahemik=&__ainer_eap_vahemik=&_where_ainer_opj_keel=&_ainer_opj_keel=&_disp_ainer_opetsem=1&_where_ainer_opetsem=&_ainer_opetsem=&_disp_ainer_kodulehe_autor=1&_where_ainer_kodulehe_autor=&_ainer_kodulehe_autor=&_where_ainer_std_id=&_ainer_std_id=&_where_ainer_e_taismaht=&_ainer_e_taismaht=&_where_ainer_e_maht=&_ainer_e_maht=&_where_ainer_e_tase=&_ainer_e_tase=&_where_ainer_e_kinn_kp=&_ainer_e_kinn_kp=&_where_ainer_e_k_maht=&_ainer_e_k_maht=&_where_ainer_e_k_tase=&_ainer_e_k_tase=&_where_ainer_e_k_kinn_kp=&_ainer_e_k_kinn_kp=&_vformaat=VFORMAAT_HTML&n_lov_offset=1&n_row_count=&n_row_pos= Course Card] 
Lecturer: Jaagup Irve <jaagup.irve@ttu.ee> 

For reference: last year materials can be found at [http://lambda.ee/wiki/Real-Time_Operating_Systems_and_Systems_Programming Real-Time Operating Systems and Systems Programming]. Most of it is still relevant.

== Elevator pitch ==

The course is basically an advanced C course which delves into the intricacies of hardware, memory management and operating system design. It looks at basic operating system components (scheduling, mutexes) and also at Linux standard library. You will be expected to program difficult tasks and it will be englightening. The course has been enjoyed by numerous smart students over the years.

== Grading ==

Grading is based on points earned during the course.

90+ points earns a grade of 5, and 50+ lets you pass. Exam can earn you up to 60 points and is difficult. Programming independently (lab) is worth 40 points max. There are 10 bonus points for attending and working on the labs. It is possible to agree on a different course project during the course.

== Lectures ==
# Introduction (course overview, grades, operator precedence, real time overview) [[Media:Rtos_01.pdf|PDF]]
# Stack Exploration, Long Jump [[Media:Rtos_02.pdf|PDF]]
# Heap [[Media:Rtos_03.pdf|PDF]]
# Hardware, interrupts, basic IO: [https://www.youtube.com/playlist?list=PLMQzXA1f24AdzOb5kRBfN2SkXNrSbdb5L Please watch the videos] [[Media:Rtos_04.pdf|PDF]]
# Signals, System Calls [[Media: Rtos_05.pdf|PDF]]

== Practice ==
* [http://lambda.ee/wiki/Basic_Linux_command-line_and_utilities_for_accessing_it_(ITI8510) Basic command line and compilation]
* [[Stack Exploration (ITS8020)|Stack Exploration]]
* [[Exploring Debugger (ITS8020)|Exploring Debugger]]
* [[Signals (ITS8020)|Signals]]
* [[Threads (ITS8020)|Threads]]
* [[Processes (ITS8020)|Processes]]

== Links==

* [http://www.edn.com/design/automotive/4423428/Toyota-s-killer-firmware--Bad-design-and-its-consequences Toyota killer firmware]
* [http://blog.regehr.org/archives/1091 Use of Assertions]
* [https://matt.sh/howto-c How to C in 2016] - or why the lecturer should be deprecated
* [https://avicoder.me/2016/02/01/smashsatck-revived/ Smashing the Stack for Fun and Profit Redone] - a take on a classic
* [https://github.com/s-matyukevich/raspberry-pi-os Raspberry Pi Os] - an opsystem from scratch

ITS8020

2018-10-19T08:39:51Z

Irve: /* Practice */

=ITS8020 Systems Programming=

[https://ois.ttu.ee/portal/page?_pageid=37,674581&_dad=portal&_schema=PORTAL&p_msg=&p_public=1&p_what=1&p_lang=ET&p_open_node2=&p_session_id=70505303&p_id=117259&p_mode=1&p_pageid=OKM_AINE_WEB_OTSING&n_disp_result=1&n_export=0&_init=1&_nextsearch=1&_nextorder=1&_orfn_1=AINER_KOOD&_ordi_1=ASC&_disp_ainer_kood=1&_where_ainer_kood=&_ainer_kood=ITS8020&_disp_ainer_nimetus=1&_where_ainer_nimetus=&_ainer_nimetus=&_disp_ainer_nimetus_en=1&_where_ainer_nimetus_en=&_ainer_nimetus_en=&_disp_ainer_oppejoud=1&_where_ainer_oppejoud=&_ainer_oppejoud=&_disp_ainer_eap=1&_where_ainer_eap=&_ainer_eap=&_where_ainer_eap_vahemik=&_ainer_eap_vahemik=&__ainer_eap_vahemik=&_where_ainer_opj_keel=&_ainer_opj_keel=&_disp_ainer_opetsem=1&_where_ainer_opetsem=&_ainer_opetsem=&_disp_ainer_kodulehe_autor=1&_where_ainer_kodulehe_autor=&_ainer_kodulehe_autor=&_where_ainer_std_id=&_ainer_std_id=&_where_ainer_e_taismaht=&_ainer_e_taismaht=&_where_ainer_e_maht=&_ainer_e_maht=&_where_ainer_e_tase=&_ainer_e_tase=&_where_ainer_e_kinn_kp=&_ainer_e_kinn_kp=&_where_ainer_e_k_maht=&_ainer_e_k_maht=&_where_ainer_e_k_tase=&_ainer_e_k_tase=&_where_ainer_e_k_kinn_kp=&_ainer_e_k_kinn_kp=&_vformaat=VFORMAAT_HTML&n_lov_offset=1&n_row_count=&n_row_pos= Course Card] 
Lecturer: Jaagup Irve <jaagup.irve@ttu.ee> 

For reference: last year materials can be found at [http://lambda.ee/wiki/Real-Time_Operating_Systems_and_Systems_Programming Real-Time Operating Systems and Systems Programming]. Most of it is still relevant.

== Elevator pitch ==

The course is basically an advanced C course which delves into the intricacies of hardware, memory management and operating system design. It looks at basic operating system components (scheduling, mutexes) and also at Linux standard library. You will be expected to program difficult tasks and it will be englightening. The course has been enjoyed by numerous smart students over the years.

== Grading ==

Grading is based on points earned during the course.

90+ points earns a grade of 5, and 50+ lets you pass. Exam can earn you up to 60 points and is difficult. Programming independently (lab) is worth 40 points max. There are 10 bonus points for attending and working on the labs. It is possible to agree on a different course project during the course.

== Lectures ==
# Introduction (course overview, grades, operator precedence, real time overview) [[Media:Rtos_01.pdf|PDF]]
# Stack Exploration, Long Jump [[Media:Rtos_02.pdf|PDF]]
# Heap [[Media:Rtos_03.pdf|PDF]]
# Hardware, interrupts, basic IO: [https://www.youtube.com/playlist?list=PLMQzXA1f24AdzOb5kRBfN2SkXNrSbdb5L Please watch the videos] [[Media:Rtos_04.pdf|PDF]]
# Signals, System Calls [[Media: Rtos_05.pdf|PDF]]

== Practice ==
* [http://lambda.ee/wiki/Basic_Linux_command-line_and_utilities_for_accessing_it_(ITI8510) Basic command line and compilation]
* [[Stack Exploration (ITS8020)|Stack Exploration]]
* [[Exploring Debugger (ITS8020)|Exploring Debugger]]
* [[Signals (ITS8020)|Signals]]
* [[Threads (ITS8020)|Threads]]
* [[Processes (ITS8020|Processes)]]

== Links==

* [http://www.edn.com/design/automotive/4423428/Toyota-s-killer-firmware--Bad-design-and-its-consequences Toyota killer firmware]
* [http://blog.regehr.org/archives/1091 Use of Assertions]
* [https://matt.sh/howto-c How to C in 2016] - or why the lecturer should be deprecated
* [https://avicoder.me/2016/02/01/smashsatck-revived/ Smashing the Stack for Fun and Profit Redone] - a take on a classic
* [https://github.com/s-matyukevich/raspberry-pi-os Raspberry Pi Os] - an opsystem from scratch

ITS8020

2018-10-12T08:42:21Z

Irve: /* Practice */

Threads (ITS8020)

2018-10-12T08:42:07Z

Irve: Uus lehekülg: '{{Its8020}} This lab will deal with threads, their creation and common data protection. For (more than thorough) explanation on threads, you can read [https://computing.llnl.gov/...'

{{Its8020}}
This lab will deal with threads, their creation and common data protection. For (more than thorough) explanation on threads, you can read [https://computing.llnl.gov/tutorials/pthreads/ POSIX Threads Programming]. Threads and mutexes can be used for experimenting with concurrency with sharing of the memory space: something which could happen while programming a chip.

== Compilation ==

You will note that using
#include <pthread.h>
in your program is not enough. It will still not compile. This is due to the fact that gcc needs additional library information and should be executed with -pthread option.

It would be helpful to use a makefile for further compilation. Create a file named Makefile in the directory of the program with contents similar to following (assuming that you named your program "threaded_hello.c"):
all: threaded_hello

threaded_hello: threaded_hello.c
gcc -pthread threaded_hello.c -o threaded_hello.o

Use [tab] button for indentation. For compilation, write "make" or "make threaded_hello". For further information, refer to [http://www.opussoftware.com/tutorial/TutMakefile.htm Makefile tutorial].

== Task ==

As before you should make some test programs to run with threads. Keep the main() function as simple as possible, doing most of the "work" in threads.

1. Write and run a threaded "Hello, World" program. You need thread creation pthread_create() and pthread_join() commands.

2. Write a program which uses two threads which both run 100000 times while adding 1 to a single shared variable (global variable). It will (hopefully) not count correctly due to race conditions.

3. Modity the program to use ''detached'' threads. Note that you might want to call pthread_exit() from the main function to let the threads finish.

4. We need to protect the shared variable using a mutex. Use [http://sourceware.org/pthreads-win32/manual/pthread_mutex_init.html pthread_mutex_*] functions. The logic to mutex is that you have to acquire mutex before doing work with shared data and have to release it after finishing with it. While the mutex is in the hands of a thread, the other threads who want to lock it block (wait) until the lock is released. ''Show it''

5. For the last task, we explore how you could pass several arguments to a thread. Improve your program by adding two arguments for a thread that will run: the arguments should be the arguments to the program (to main()); pass them to the thread using an argument to the pthread_create() function. Running your program as follows:
threadexperiment test1 test2
The output should be as follows:
Hello, test1 test2
If there are less than 2 arguments, exit. ''Show it''