CS353 : Operating Systems Notes

allSyntax.cpp

/*
--- Representational Code Only: Not to compile
--- Aditya Jain ------------------------------
--- IIT INDORE -------------------------------
*/


// libraries

#include <semaphore.h>
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <sys/wait.h>
#include <sys/shm.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <pthread.h>

using namespace std;

/** SEMAPHORES
 * sem_init(sem_t* sem, int pshared, unsigned init_value)
 * sem_open(char* name, oflags, sflags, unsigned init_value)
 * sem_post(sem_t* x)
 * sem_wait(sem_t* x)
 * -pthread
 * find named semaphores in /dev/shm
 */

sem_t x, y;
sem_init(&x, 0, 1); 
sem_wait(&x);
sem_post(&x);

sem_t* mutex = sem_open("my_sem", O_CREAT|O_EXCL, S_IRUSR|S_IWUSR, 1); // will create if not
// will fail ^ if sem already exists
// in some other file
sem_t* mutex = sem_open("my_sem", O_EXCL, S_IRUSR|S_IWUSR, 1);

// Sample Program
do_some_sync(){
	sem_t* signalX = sem_open("sigX", O_CREAT|O_EXCL, S_IRUSR|S_IWUSR, 1);
	sem_t* signalY = sem_open("sigY", O_CREAT|O_EXCL, S_IRUSR|S_IWUSR, 0);
	while(1){
		sem_wait(signalY);
		puts("P2 IN CS");
		sleep(1);
		sem_post(signalX);
	}
}

/** SOCKETS
 * -> Server Creation
 *		1. Define struct for server
 *		2. create socket
 *		3. Bind the socket
 *		4. Listen
 * 		5. Accept Connections
 *		6. Communicate
 * -> Client Side
 *		1. Define struct for server
 *		2. Create socket
 *		3. Connect
 *		4. Communicate after acceptance
 */

// Server: define server struct
struct sockaddr_in server;
server.sin_addr.s_addr = INADDR_ANY;
server.sin_family = AF_INET;
server.sin_port = htons(8888);

// create socket
int socket_desc = socket(AF_INET, SOCK_STREAM, 0);
if(socket_desc == -1) /*socket not created*/

// Server: bind
int flag = bind(socket_desc, (struct sockaddr*)&server, sizeof(server));
if(flag == -1) /*bind failed*/

// Server: listen
// listen(socket_desc, wait_queue_length)
listen(socket_desc, 3); 

// Server: accept
struct sockaddr_in client;
int c = sizeof(server);
int new_socket = accept(socket_desc, (struct sockaddr*)&client, (socklen_t*)&c);

// Server: communicate
char buffer[220];
bzero(buffer,200);
read(new_socket, buffer, 200);
char msg[] = "some thing";
bzero(msg, 200);
write(new_socket, msg, 200);

// Client: define server struct
struct sockaddr_in server;
server.sin_addr.s_addr = inet_addr("127.0.0.1");
server.sin_family = AF_INET;
server.sin_port = htons(8888); 

// Client: connnect
int c = connect(socket_desc, (struct sockaddr*) &server , sizeof(server));
if(c < 0) /*connect failed*/

// Client: communicate
char message[] = "something ... ";
bzero(message,100);
s = send(socket_desc , message , strlen(message) , 0);
if(s<0)puts("can't send");
bzero(server_reply, 2000);
read(socket_desc, server_reply , 2000);

/** MULTITHREADING
 * pthread_t
 * pthread_create(pthread_t*, NULL, func_name, void*)
 * pthread_join(pthread_t, NULL)
 * compile with -pthread
 */

void* solve(void* arg){
	long i = (long) arg;
	// do something
}

long my_arg;
pthread_t tid;
pthread_create(&tid, NULL, solve, (void*)my_arg);
pthread_join(tid, NULL);

/** SHARED MEMORY (SHM)
 * shmget, shmat
 * ipcs -m
 */
#define key 13212
#define BLOCK_SIZE 4

int segment_id = shmget(KEY, BLOCK_SIZE, IPC_CREAT|IPC_EXCL|S_IRUSR|S_IWUSR);
int* a = (int*) shmat(segment_id, NULL, 0);

/** FILE CONCEPTS
 * stdin: 0
 * stdout: 1
 * stderr: 2
 */
// open
int fd = open("/path/to/my/file.txt", O_RDONLY|O_WRONLY|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR);
/**
● O_RDONLY: Opens file for reading.
● O_WRONLY: Opens file for writing.
● O_RDWR: Opens file for reading and writing.
● O_APPEND: Opens file in append mode.
● O_TRUNC: Truncates file to zero length.
● O_CREAT: Create file if it doesn't exist.
● O_SYNC: Synchronizes read-write operations.

S_IRWXU
*/
// closing
close(fd);


#define SIZE_TO_READ 200
#define SIZE_TO_WRITE 200
char buffer[220];
// read
int size_of_read_stuff = read(fd, buffer, SIZE_TO_READ);
if(size_of_read_stuff == -1) /*write failed*/

// write
int number_of_bytes_written = write(fd, buffer, SIZE_TO_WRITE);
if(number_of_bytes_written == -1) /*write failed*/

// lseek -> setoffset in file
/** WHENCE
 * SEEK_CUR : current position
 * SEEK_SET : start position
 * SEEK_END : EOF
 */

int pos_of_pointer_from_beginning_of_file = lseek(int fd, int offset, int whence)
int size = lseek(fd, 0, SEEK_END);

// dup
dup(fd); //<- duplicated fd to lowest possible file descriptor

dup2(fd, new_fd);
// closes new_fd and duplicates fd to new_fd


/** PIPE AND FIFO
 * pipe -> temp file, separate desc for read and write ends, used b/w related processes
 * sync using block
 * fifo -> named pipe, b/w unrelated processes
 */

int pipe_fds[2];
pipe(pipe_fds);
// pipe_fds[0] -> read end
// pipe_fds[1] -> write end

mkfifo("/tmp/fifo", S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
// open normally in processes
int fd = open("/tmp/fifo", O_RDONLY); // READER PROCESS
int fd = open("/tmp/fifo", O_WRONLY); // WRITER PROCESS