Chapter 12 Advanced Programming: Systems Calls

1. Chapter 12 Advanced Programming: Systems Calls By C. Shing ITEC Dept Radford University

2. Slide 2 Objectives Understand the capabilities of system calls Understand how to use system calls for file and process management Understand the signals and how to control processes

3. Slide 3 System Calls Programmer’s interface to kernel Capabilities: function returns -1 if failed Error handling: library routine - perror() File management Process management

4. Slide 4 System Calls (Cont.) File management Regular: open(), close(), read(), write(), lseek() – in Chapter 7 link(), unlink(), chmod(), chown(), dup(), dup2(), fcntl(), stat(), fstat(), truncate(), ftruncate(), sync()

5. Slide 5 System Calls (Cont.) File management (Cont.) Directory: getdents() Special (IPC): mknod(), ioctl(), pipe() Sockets: accept(), bind(), connect(), listen(), socke() Internet sockets: gethostbyname(), gethostname(), htonl(), htons(), inet_addr(), inet_ntoa()

6. Slide 6 System Calls (Cont.) Process management: fork(), exec(), wait(), exit(), chdir(), setuid(), setgid(), getuid(), getgid(), getpid(), getppid() Signals: kill()

7. Slide 7 Error Handling - perror Syntax: void perror (char *str) Prints out :, followed by the description of error after the string that you enter A standard C library routine Must use #include <errno.h> Description: Every process initialize a global variable errno when created errno stores error from last system call error Error number defined in /usr/include/sys/errno.h

8. Slide 8 Error Handling – perror (Cont.) Example: showErrno.c

9. Slide 9 Regular File Management - link Syntax: int link (const char *oldfilename, const char *newaliase) Creates a hard link newaliase for oldfilename Both must be on same file system Example: mylink.c

10. Slide 10 Regular File Management - unlink Syntax: int unlink (const char *filename) Removes a hard link for filename. If , as a result, no hard link exists, then the filename is de-allocated. An executable can unlink (or remove) itself during execution. Example: reverse.c

11. Slide 11 Regular File Management – chmod/fchmod Syntax: int chmod (const char *filename, int octal_permission) int fchmod (int fd, int octal_permission) Change filename (fd) with octal_permission Example: mychmod.c

12. Slide 12 Regular File Management – chown/lchown/fchown Syntax: int chown (const char *filename, int ownerid, int groupid) int lchown (const char *filename, int ownerid, int groupid) int fchown (int fd, int ownerid, int groupid) chown/fchown: change ownerid and groupid for filename (fd) lchown: change ownerid and groupid for the link only Example: mychown.c

13. Slide 13 Regular File Management – dup/dup2 Syntax: int dup (int oldfd) int dup2 (int oldfd, int newfd) dup: creates a newfd and both fds point to same file dup2: creates a newfd and close the oldfd Example: mydup.c

14. Slide 14 Regular File Management - fcntl Syntax: int fcntl (int fd, int flag, int mode) Creates an action encoded by the flag on the file (fd) with specified mode

15. Slide 15 Regular File Management - fcntl(Cont.) fcntl flags:

16. Slide 16 Regular File Management - fcntl(Cont.) fcntl flags (Cont.):

17. Slide 17 Regular File Management – fcntl (Cont.) Example: myfcntl.c

18. Slide 18 Regular File Management – stat/lstat/fstat Syntax: int stat (const char *filename, struct stat *buffer) int lstat (const char *filename, struct stat *buffer) int fstat (int fd, struct stat *buffer) stat/fstat fill buffer with information about filename (fd) in stat structure (defined in /usr/include/sys/stat.h) lstat fill buffer with information about the link only

19. Slide 19 Regular File Management – stat/lstat/fstat (Cont.) stat structure:

20. Slide 20 Regular File Management – stat/lstat/fstat (Cont.) stat structure (Cont.):

21. Slide 21 Regular File Management – stat/lstat/fstat (Cont.) Macro returns True using argument: st_mode in stat struct

22. Slide 22 Regular File Management – stat/lstat/fstat (Cont.) Example: monitor.c

23. Slide 23 Regular File Management – truncate/ftruncate Syntax: int truncate (const char *filename, int length) int f truncate (int fd, int length) Set size of filename (fd) to length bytes Example: truncate.c

24. Slide 24 Regular File Management - sync Syntax: void sync (void) Flush all file system buffers to be written to disks

25. Slide 25 Directory File Management – getdents/getdirectries Syntax: int getdents (int fd, struct dirent *buffer, int size) Read directory entry structure dirent into buffer address. Returns size of the directory entry if successful.

26. Slide 26 Directory File Management – getdents/getdirectries (Cont.) dirent structure: defined in /usr/include/sys/dirent.h

27. Slide 27 Directory File Management – getdents/getdirectries (Cont.) Example: truncate.c count.c

28. Slide 28 Special File Management - mknod Syntax: int mknod (const char *filename, mode_t type, dev_t device) Creates a regular, directory or special filename with type If filename is a character or block file, then low-order byte of device specifies minor number and high-order byte specifies major number

29. Slide 29 Special File Management – mknod (Cont.) File type

30. Slide 30 Special File Management - ioctl Syntax: int ioctl (int fd, int cmd, int arg) Performs operation on device encoded by cmd with arg for cmd

31. Slide 31 Process Management – getpid, getppid Syntax: pid_t getpid (void) Returns process id Syntax: pid_t getppid (void) Returns parent’s process id

32. Slide 32 Process Management – exit Syntax: void exit (int status) Deallocates process’ resources, sends a SIGCHLD signal and waits for return code status to be accepted Status is 0-255 Example: myexit.c

33. Slide 33 Process Management - fork Syntax: pid_t fork (void) Returns non-zero to parent process and zero to child process Identify child process by checking the return value 0 Identify parent process by checking the return value non-zero Example: if (fork() == 0) { // child process tasks } else { // parent process tasks }

34. Slide 34 Process Management – fork (Cont.) Example: myfork.c

35. Slide 35 Process Management – fork (Cont.) Comparison of parent and child processes Common: child process has duplication of parent Code Data (e.g. file descriptor, process group) Stack Difference Process id

36. Slide 36 Process Management – fork (Cont.) Child process becomes Orphan process: parent dies before child, automatically adopted by init process Example: orphan.c Zombie process: parent suspend and child is waiting for parent to accept its return code Example: zombie.c

37. Slide 37 Process Management – wait Syntax: pid_t wait (int *status) Suspend the parent process until one child terminates Returns child process id and stores return code in status Example: mywait.c

38. Slide 38 Process Management– execl/execv/execlp/execvp Syntax: int execl (const char *filepath, const char *argv[], NULL) int execlp (const char *argv[], NULL) int execv (const char *filepath, const char **argv[]) int execvp (const char **argv[])

39. Slide 39 Process Management– execl/execv/execlp/execvp (Cont.) Description argv[0] is the executable file that when executed, it replaces the parent (i.e. calling) process All functions are library routines which invoke system call exece execlp and execvp don’t specify file path since they use environment variable $PATH to find executable

40. Slide 40 Process Management– execl/execv/execlp/execvp (Cont.) Comparison example: exec family execl (“/bin/ls”, “ls”, “-l”, NULL); execlp (“ls”, “ls”, “-l”, NULL); char *cmd = {“ls”, “-l”}; execv (“/bin/ls”, cmd}; char *cmd = {“ls”, “-l”}; execvp (“ls”, cmd};

41. Slide 41 Process Management– execl/execv/execlp/execvp(Cont.) execl Example: myexec.c

42. Slide 42 Process Management– execl/execv/execlp/execvp(Cont.) execvp Example 1: create a background process (process group changed) steps: Create a child process to exec the background process See background.c (background gcc mywait.c)

43. Slide 43 Process Management– execl/execv/execlp/execvp(Cont.) Execvp (Cont.) Example 2: redirect output (ls -l > ls.out) Steps: Open the right hand side of > Duplicate fd from step 1 to stdout and close the fd. In this way stdout will associate with this fd exec the left hand side of > See redirect.c (redirect ls.out ls –l)

44. Slide 44 Process Management – chdir Syntax: int chdir (const char *dirpath) Set process’ working directory to address of dirpath Example: mychdir.c

45. Slide 45 Process Management – nice Syntax: int nice (int decPriority) Add priority level by decPriority It is library routine Priority level between -20 and +19 (high priority to low) System and super-user processes priority levels are negative If priority level over 19, then set to 19 Only super-user can make resulting priority level negative Example: mynice.c

46. Slide 46 Process Management – getuid, getgid, getpgid Syntax: uid_t getuid (void) uid_t geteuid (void) gid_t getgid (void) gid_t getegid (void) Return calling process’ real (or effective) user (or group) id Syntax: pid_t getpgid (pid_t pid) Return process’ group id of the process with the pid value

47. Slide 47 Process Management – setuid, setgid Syntax: uid_t setuid (uid_t id) uid_t seteuid (uid_t id) gid_t setgid (gid_t id) gid_t setegid (gid_t id) Change to id for calling process’ real (or effective) user (or group) id Syntax: pid_t setpgid (pid_t pid, pid_t pgid) set process’ group id of the process to pgid with the pid value

48. Slide 48 What is a Signal When interrupt occurs, kernel sends a signal to the process One process can also send it to another process if permitted Different kinds of signals are defined in /usr/include/sys/signal.h

49. Slide 49 Signal Handler When process receives the signal, it suspends current control flow and switch to signal hander. When finisked, it resumes original control flow.

50. Slide 50 Signal Handler (Cont.) Two kinds of signal handler: Kernel-supplied handler: core dump Quit process Ignore signal suspend process resume process User-supplied handler

51. Slide 51 Process Management (Signal) – alarm Syntax: unsigned alarm (unsigned count) Request kernel to send SIGALRM signal to calling process after count seconds A standard C library routine Example: alarm.c

52. Slide 52 Process Management (Signal) – pause Syntax: int alarm (void) Suspend calling process until it receives the signal A standard C library routine Example: alarm.c

53. Slide 53 Process Management (Signal) – signal Syntax: void *signal (int signalCode, void *func(void)) Specify func when receives signalCode SIG_IGN to ignore signal SIG_DFL for default kernel-supplied handler signalHandler name for user-supplied handler except for signal SIGKILL and SIGSTP A standard C library routine signalCode is defined in /usr/include/signal.h Example: handler.c

54. Slide 54 Process Management (Signal) – signal (Cont.) Example: User-supplied handler: handler.c Kernel-supplied signal & Ignore signal: critical.c

55. Slide 55 Process Management (Signal) – kill Syntax: int kill (pid_t pid, int signalCode) Send the signalCode to the process with the pid value If pid=0, then signal sent to all process in the same group If pid=-1 and sender is super-user, then signal sent to all processes including the sender If pid=-1 and sender is not super-user, then signal sent to all processes owned by sender except the sender If pid=negative except -1, then signal sent to all processes in the process group

56. Slide 56 Process Management (Signal) – kill (Cont.) Example of using signal code: Suspend process kill (pid, SIGSTOP); Resume process kill (pid, SIGCONT);

57. Slide 57 Process Management (Signal) – kill (Cont.) Example: limit.c process groups of parent and child: pgrp1.c pgrp2.c pgrp3.c

58. Slide 58 Pipe IPC on the same machine Establish between a write process and a read process. Pipe has a read end and a write end

59. Slide 59 Pipe (Cont.) Two kinds of pipes: Unnamed pipe: 5K size, 1 write process and 1 read process Named pipe (System V only): 40 K size, many write processes and 1 read process, not work across network

60. Slide 60 Unnamed Pipe Creation: fd[0] is read end, fd[1] is write end int fd[2]; pipe(fd);

61. Slide 61 Unnamed Pipe (Cont.) Use Close read end of the write process before write // for write process close (fd[0]); write (fd[1], buffer, length); Close write end of the read process before read // for read process close (fd[1]); read (fd[0], buffer, length);

62. Slide 62 Unnamed Pipe (Cont.) // for write process if write size no more than pipe size, no pre-empt if pipe read end close, write fails and send SIGPIPE signal to terminate // for read process if read more bytes than pipe has, return actual bytes read if write end open and read an empty pipe, suspend read if pipe write end close, read returns 0

63. Slide 63 Process Management – pipe Syntax: int pipe (int fd[2]) Create 2 file descriptors and stored in fd[0] and fd[1] lseek is not available for pipe Example: talk.c

64. Slide 64 Process Management – pipe (Cont.) Unix shell: unnamed pipe // for write process Close read end of the write process before write Duplicate write end to stdout Close write end so stdout will be used for write process Exec write process // for read process Close write end of the read process before read Duplicate read end to stdin Close read end so stdin will be used for read process Exec read process Example: connect.c (connect who wc)

65. Slide 65 Named Pipe (FIFO) Creation: use mknod to create a special file and set right permission mknod (“mypipe”, S_IFIFO, 0); chmod (“mypipe”, 0660);

66. Slide 66 Named Pipe (FIFO) (Cont.) Use // for read process Delete the pipe unlink (“mypipe”); Create the pipe mknod (“mypipe”, S_IFIFO, 0); chmod (“mypipe”, 0660); Open the pipe for read fd = open (“mypipe”, O_RDONLY); start read process read (fd, buffer, size);

67. Slide 67 Named Pipe (FIFO) (Cont.) Use (Cont.) // for write process Open the pipe for write fd = open (“mypipe”, O_WRONLY); start write process write (fd, buffer, size);

68. Slide 68 Named Pipe (FIFO) (Cont.) // for write process if open a named pipe for write, but no process open for that file to write, write process suspend until a process open for the file to read, unless O_NONBLOCK/O_NDELAY is set (in which open fails) // for read process if open a named pipe for read, but no process open for that file to write, read process suspend until a process open for the file to write, unless O_NONBLOCK/O_NDELAY is set (in which open success)

69. Slide 69 Named Pipe (FIFO) (Cont.) Example: (reader & writer & writer &) reader.c writer.c

70. Slide 70 Socket IPC (two-way communication) across network Use client-server model: server always runs as a background process (passive) Client runs as foreground process (active) Defined in /usr/include/sys/socket.h

71. Slide 71 Socket (Cont.) Characteristics Type: defined in /usr/include/sys/types.h SOCK_STREAM: connection, sequenced, reliable, variable-length stream of bytes SOCK_DGRAM: connectionless, unreliable, fixed length messages

72. Slide 72 Socket (Cont.) Characteristics (Cont.) Domain: server and client location AF/PF (Address Family/Protocol Family) AF_UNIX/PF_UNIX: Server and client are in same machine defined in /usr/include/sys/un.h AF_INET/PF_INET Server and client are in internet defined in /usr/include/netinet/in.h, /usr/include/arpa/inet.h, /usr/include/netdb.h

73. Slide 73 Socket (Cont.) Characteristics (Cont.) Protocols: how socket type is implemented Use default value 0

74. Slide 74 Server Process (Socket) Steps: Create a socket Name the socket Create a socket queue Accept a client Serving a client

75. Slide 75 Server Process (Socket) - socket Create a socket Syntax: int socket (int domain, int type, int protocol)) Return file descriptor representing newly created socket in domain with type and protocol Example: serverFd = socket (AF_UNIX, SOCK_STREAM, DEFAULT_PROTOCOL);

76. Slide 76 Server Process (Socket) - bind Name the socket Syntax: int bind (int fd, const struct sockaddr* addr, size_t addrlength) Return 0 to associate unnamed socket (fd) with socket address stored in addr with address structure length addrlength addr: a pointer to

77. Slide 77 Server Process (Socket) – bind (Cont) Name the socket (Cont.) addr: if socket in domain AF_UNIX cast to (sockaddr*) the pointer to structure sockaddr_un field: sun_family = AF_UNIX field: sun_path = relative or absolute pathname of socket name AF_INET cast to (sockaddr*) the pointer to structure sockaddr_in field: sun_family = AF_INET field: sun_port = socket port number field: sun_addr = in_addr structure that holds IP address

78. Slide 78 Server Process (Socket) – bind (Cont.) Name the socket (Cont.) Example: struct sockaddr_un serverUNIXAddress; struct sockaddr* serverSockAddrPtr; serverSockAddrPtr = (struct sockaddr*) &serverUNIXAddress; serverLen = sizeof (serverUNIXAddress); serverUNIXAddress.sun_family = AF_UNIX; strcpy (serverUNIXAddress.sun_path, "recipe"); unlink ("recipe"); /* Remove file if it already exists */ bind (serverFd, serverSockAddrPtr, serverLen);

79. Slide 79 Server Process (Socket) - listen Create a socket queue Syntax: int listen (int fd, int queuelength) Specify max queuelength for socket (fd). Reject client request if queue is full Example: listen (serverFd, 5);

80. Slide 80 Server Process (Socket) - accept Accept a client Syntax: int accept (int fd, struct sockaddr* addr, int *addrlength returns a file descriptor to communicate with client creates a newly unnamed client socket with the same attributes as the named server socket fd addr stores client’s IP address similar to the one used in bind

81. Slide 81 Server Process (Socket) – accept (Cont.) Accept a client (Cont.) Example: struct sockaddr_un clientUNIXAddress; struct sockaddr* serverSockAddrPtr; struct sockaddr* clientSockAddrPtr; clientSockAddrPtr = (struct sockaddr*) &clientUNIXAddress; clientLen = sizeof (clientUNIXAddress); clientFd = accept (serverFd, clientSockAddrPtr, &clientLen);

82. Slide 82 Server Process (Socket) (Cont.) Serving a client fork a child process to communicate with server using read() and write() Close communication between server socket and client socket to free up server to accept new client’s request

83. Slide 83 Server Process (Socket) (Cont.) Serving a client (Cont.) Example: while (1) { clientFd = accept (serverFd, clientSockAddrPtr, &clientLen); if (fork () == 0) { writeRecipe (clientFd); /* Send the recipe */ close (clientFd); /* Close the socket */ exit (0); /* Terminate */} else close (clientFd); /* Close the client descriptor */ }

84. Slide 84 Client Process (Socket) Steps: Create a unnamed socket Connect to named server socket

85. Slide 85 Client Process (Socket) - socket Create a socket (similar to the one for server) Syntax: int socket (int domain, int type, int protocol)) Return file descriptor representing newly created socket in domain with type and protocol Example: clientFd = socket (AF_UNIX, SOCK_STREAM, DEFAULT_PROTOCOL);

86. Slide 86 Client Process (Socket) - connect Connect to named server socket Syntax: int connect (int clientFd, const struct sockaddr* serveraddr, size_t addrlength) Return 0 to associate unnamed client socket (clientFd) with named socket address stored in addr with address structure length addrlength serveraddr: similar to addr used in bind

87. Slide 87 Client Process (Socket) – connect (Cont.) Connect to named server socket (Cont.) Example: struct sockaddr_un serverUNIXAddress; struct sockaddr* serverSockAddrPtr; serverSockAddrPtr = (struct sockaddr*) &serverUNIXAddress; serverLen = sizeof (serverUNIXAddress); clientFd = socket (AF_UNIX, SOCK_STREAM, DEFAULT_PROTOCOL); serverUNIXAddress.sun_family = AF_UNIX; strcpy (serverUNIXAddress.sun_path, "recipe"); do { result = connect (clientFd, serverSockAddrPtr, serverLen); if (result == -1) sleep (1); /* Wait and then try again */ } while (result == -1);

88. Slide 88 AF_UNIX Socket Example: IPC in same machine Compile: gcc –o chef –lsocket chef.c chef.c (server) Compile: gcc –o cook –lsocket cook.c cook.c (client) Execute: chef & cook

89. Slide 89 Internet Socket Socket with domain AF_INET 32 bit IP address 16 bit port number Library functions inet_addr, gethostbyname, inet_ntoa, bzero(BSD)/memset(System V), htonl/htons/ntohl/ntohs System calls hethostname

90. Slide 90 Socket Library – inet_addr Syntax: in_addr_t inet_addr (const char *ipstring) Return 32 bit IP address in network-byte order) given an ipstring in a.b.c.d format Example: if (isdigit (name[0])) return (inet_addr (name));

91. Slide 91 Socket Library – gethostbyname Syntax: struct hostent *gethostbyname (const char *name) Return a pointer to hostent structure by searching through /etc/hosts file entry with the entry name IP address stored in the field h_addr->s_addr of the hostent structure

92. Slide 92 Socket Library – inet_ntoa Syntax: char * inet_ntoa (struct in_addr address) Return a pointer to a string in a.b.c.d format by converting an in_addr structure

93. Slide 93 Socket Library – gethostbyname, inet_ntoa (Cont.) Example: struct hostent* hostStruct; struct in_addr* hostNode; char hostName [100]; hostStruct = gethostbyname (hostName); if (hostStruct == NULL) return (0); /* Not Found */ hostNode = (struct in_addr*) hostStruct->h_addr; printf ("Internet Address = %s\n", inet_ntoa (*hostNode)); return (hostNode->s_addr); /* Return IP address */

94. Slide 94 Socket Library – bzero Syntax: void bzero (void *buffer, size_t length) Fills buffer with length NULL BSD version

95. Slide 95 Socket Library – bzero (Cont.) Example: /* Start by zeroing out the entire address structure */ bzero ((char*)&serverINETAddress, sizeof(serverINETAddress));

96. Slide 96 Socket Library –memset Syntax: void memset (void *buffer, int value, size_t length) Fills buffer with length value System V version

97. Slide 97 Socket Library – htonl/htons/ntohl/ntohs Syntax: in_addr_t htonl (in_addr_t host_format_long) in_addr_t ntonl (in_addr_t net_format_long) in_port_t htons (in_port_t host_format_short) in_port_t ntons (in_port_t net_format_short) Coversion between host-format and network-format

98. Slide 98 Socket Library – htonl/htons/ntohl/ntohs (Cont.) Example: serverINETAddress.sin_family = AF_INET; serverINETAddress.sin_addr.s_addr = inetAddress; serverINETAddress.sin_port = htons (DAYTIME_PORT);

99. Slide 99 Internet Socket – gethostname Syntax: int gethostname (char *name, int length) Stores hostname in name of length Example: gethostname (hostName,100);

100. Slide 100 Internet Socket (Cont.) Internet server Similar to AF_UNIX server except the field sin_addr.s_addr needs to store INADDR_ANY to accept any incoming client requests

101. Slide 101 Internet Socket - internet server Example: struct sockaddr_un serverUNIXAddress; struct sockaddr_un clientUNIXAddress; struct sockaddr_in serverINETAddress; struct sockaddr_in clientINETAddress; struct sockaddr* serverSockAddrPtr; struct sockaddr* clientSockAddrPtr;

102. Slide 102 Internet Socket - internet server (Cont.) Example: (Cont.) if (internet) { sscanf (name, "%d", &port); /* Get port number */ serverLen = sizeof (serverINETAddress); bzero ((char*) &serverINETAddress, serverLen); serverINETAddress.sin_family = AF_INET; /* Domain */ serverINETAddress.sin_addr.s_addr = htonl (INADDR_ANY); serverINETAddress.sin_port = htons (port); /* Port */ serverSockAddrPtr = (struct sockaddr*) &serverINETAddress; }

103. Slide 103 Internet Socket (Cont.) Internet client Similar to AF_UNIX client Example: clientFd = socket (AF_INET, SOCK_STREAM, DEFAULT_PROTOCOL); do /* Loop until a connection is made with the server */ { result = connect (clientFd,serverSockAddrPtr,serverLen); if (result == -1) sleep (1); /* Try again in 1 second */ }

104. Slide 104 Internet Socket (Cont.) Example 1: Internet time Compile: gcc –o inettime –lsocket –lnsl inettime.c inettime.c (client) Execute: inettime (Enter s, IP address or FQDN: rucs.radford.edu)

105. Slide 105 Internet Socket (Cont.) Example 2: Internet shell Compile: gcc –o ish –lsocket –lnsl ish.c ish.c (server & client) Execute: ish

106. Slide 106 Other System Calls Thread Semaphore STREAMS I/O Shared memory

107. Slide 107 Other Library Calls – Thread Thread: Multiple threads of control in a single process space light-weight process Shared code, data, stack Defined in /usr/include/pthread.h

108. Slide 108 Other Library Calls – Thread (Cont.) Thread library functions: pthread_create/pthread_exit pthread_attr_init/pthread_attr_destroy pthread_attr_setscope/pthread_attr_getscope pthread_join pthread_detach pthread_cancel

109. Slide 109 Other Library Calls – Thread (Cont.) pthread_create/pthread_exit Syntax: int pthread_create (pthread_t *thread, const pthread_attr_t *attr, void * (*startpgm, void*), void *arg) Create a thread with attribute attr and executing startpgm using arg

110. Slide 110 Other Library Calls – Thread (Cont.) pthread_create/pthread_exit (Cont.) Syntax: void pthread_exit (void *status) Terminate a thread with status Example: pthread_exit(0);

111. Slide 111 Other Library Calls – Thread (Cont.) pthread_create/pthread_exit (Cont.) Example: #include <pthread.h> void *Simulator(void *arg); pthread_t slave_threads[numThreads]; pthread_attr_t pthread_attr; /* Create slave threads */ for (i = 1; i<=numThreads;i++) { if( pthread_create(&slave_threads[i-1], &pthread_attr, Simulator, (void *) ( i ))) { perror("Error while creating a thread."); exit(3); } }

112. Slide 112 Other Library Calls – Thread (Cont.) pthread_attr_init/pthread_attr_destroy Syntax: int pthread_attr_init (pthread_attr_t *attr) Initalize a thread attribute attr with default values Syntax: int pthread_attr_destroy (pthread_attr_t *attr) destroy a thread attribute attr

113. Slide 113 Other Library Calls – Thread (Cont.) pthread_attr_init/pthread_attr_destroy (Cont.) Example: pthread_attr_init(&pthread_attr);

114. Slide 114 Other Library Calls – Thread (Cont.) pthread_attr_setscope/pthread_attr_getscope Syntax: int pthread_attr_setscope (pthread_attr_t *attr, int contentionscope) Syntax: int pthread_attr_getscope (pthread_attr_t *attr, int contentionscope) Set or get contentionscope attribute

115. Slide 115 Other Library Calls – Thread (Cont.) pthread_attr_setscope/pthread_attr_getscope (Cont.) Example: pthread_attr_setscope(&pthread_attr, PTHREAD_SCOPE_SYSTEM);

116. Slide 116 Other Library Calls – Thread (Cont.) pthread_join Syntax: int pthread_join (pthread_t *thread, void **status) Wait for another thread to complete with status

117. Slide 117 Other Library Calls – Thread (Cont.) pthread_detach Syntax: int pthread_detach (pthread_t *thread) Reclaim thread space after it terminates

118. Slide 118 Other Library Calls – Thread (Cont.) pthread_cancel Syntax: int pthread_cancel (pthread_t *thread) cancel thread execution

119. Slide 119 Other Library Calls – Semaphore Semaphore : Counter to specify how many concurrent uses of a resource. If <= 0, then no resource available Binary semaphore: semaphore is binary Defined in /usr/include/ semaphore.h

120. Slide 120 Other Library Calls – Semaphore (Cont.) Semaphore library functions: sem_wait sem_post sem_getvalue

121. Slide 121 Other Library Calls – Semaphore (Cont.) sem_wait Syntax: int sem_wait (sem_t *sem) Lock semophore sem

122. Slide 122 Other Library Calls – Semaphore (Cont.) sem_post Syntax: int sem_post (sem_t *sem) Unlock semophore sem and increment its value

123. Slide 123 Other Library Calls – Semaphore (Cont.) sem_wait / sem_post (Cont.) Example: #include <semaphore.h> sem_t useRand; /* generate 20 random number and calculate g(u1,u2,...,u20) */ sem_wait(&useRand); /* Waiting to use random generator */ for( j=0; j < 20; j++) { seeds[j] = (5*seeds[j]+234) % 49764311; x = seeds[j]/49764311.0; power = power + x; } sem_post(&useRand); /* Letting others to use generator */

124. Slide 124 Other Library Calls – Semaphore (Cont.) sem_getvalue Syntax: int sem_getvalue (sem_t *sem, int *svalue) Store value of semophore sem to location svalue

125. Slide 125 Other System Calls – Semaphore System V only semget(): create an array of semaphore semop(): operate on an array of semaphore semctl(): modify attributes of an array of semaphore

126. Slide 126 Other System Calls – STREAMS System V only: has TLI (transport Layer Interface) networking to STREAMS driver System call getmsg (): get a message from stream putmsg (): put a message on a stream poll (): poll streams for activity isastream (): test a file desciptor is a stream

127. Slide 127 Other System Calls – Shared Memory System V only: If creation of shared memory segment success, it returns a segment ID System call shmget (): allocate a shared memory segment and return an ID shmat (): attach a shared memory segment to address space of calling process shmdt (): detach the segment from address space shmctl (): modify attributes of a shared memory segment

128. Slide 128 Reference: Chapter 13 of Glass: Unix