[카테고리:] 생활코딩

linux system programming, 283p

리눅스에 파일, 디렉토리를 감시하는 watch가 있다. 특정 경로를 설정하여 감시하여 적절한 이벤트를 작성할 수 있다.

#include <sys/inotify.h>
#include <stdlib.h>
#include <errno.h>
#include <stdio.h>
#include <unistd.h>
#define BUF_LEN 128 

//int inotify_init1 (int flags);
void main(){
	int fd; //file descritor
	int wd; //watch descriptor
	const char path[50]="/home/now0930/test/ttt";
	fd = inotify_init1 (0);
	if (fd == -1) {
		perror("inotify_init1");
		exit(EXIT_FAILURE);
		}

	//printf("%d", IN_MODIFY);
	wd = inotify_add_watch(fd, path, IN_OPEN);
	if (wd == -1){
		perror("add notify");
		exit(EXIT_FAILURE);
	}
	printf("file descriptor is %d\n",fd);
	printf("path is %s\n",path);
	
	//__attribute__ compiler가 제공하는 메모리 번지 정렬. 4바이트 단위로 정렬.
	//https://blog.naver.com/PostView.nhn?blogId=msyang59&logNo=220885276415
	char buf[BUF_LEN] __attribute__((aligned(4)));
	//printf("buf[0] is  0x%ld\n",&buf[0]);
	//printf("buf[1] is  0x%ld\n",&buf[1]);
	//printf("buf[2] is  0x%ld\n",&buf[2]);
	//printf("buf[3] is  0x%ld\n",&buf[3]);
	//printf("buf[4] is  0x%ld\n",&buf[4]);
	//printf("buf[5] is  0x%ld\n",&buf[5]);
	//
	//
	ssize_t len, i = 0;

	for (int j=0;j<5;j++){
		i = 0;
		/* read BUF_LEN bytes' worth of events */
		len = read (fd, buf, BUF_LEN);
		printf("char is %ld\n",buf);
		printf("len is %ld\n",len);
		//보통 이런 방식으로 사용.
		/* loop over every read event until none remain */
		while (i < len) {
			struct inotify_event *event =
			(struct inotify_event *) &buf[i];
			printf ("wd=%d mask=%d cookie=%d len=%d dir=%s\n", event->wd, event->mask, event->cookie, event->len, (event->mask & IN_ISDIR) ? "yes" : "no");
			/* if there is a name, print it */
			if (event->len)
				printf ("name=%s\n", event->name);
				/* update the index to the start of the next event */
			//printf("i is %d\n",i);
			//printf("buf address is 0x%lx\n",&buf[i]);
			if (event->mask && IN_ACCESS)
				printf("the file was read\n");
			i += sizeof (struct inotify_event) + event->len;
			}
	}


	int ret;
	ret = inotify_rm_watch(fd, wd);
	if(ret)
		perror("remove watch\n");
	
}

[21:45:06]>rm ./a.out ;gcc notify.c;./a.out 
notify.c: In function ‘main’:
notify.c:45:21: warning: format ‘%ld’ expects argument of type ‘long int’, but argument 2 has type ‘char *’ [-Wformat=]
   printf("char is %ld\n",buf);
                   ~~^    ~~~
                   %s
file descriptor is 3
path is /home/now0930/test/ttt
char is 140729024548928
len is 16
wd=1 mask=32 cookie=0 len=0 dir=no
the file was read
char is 140729024548928
len is 16
wd=1 mask=32 cookie=0 len=0 dir=no
the file was read

linux system programming, 238p. 두 시간 삽질했다. thread arg 를 포인터로 주는데 여러 개를 쓰려면 struct로 정의해서 써야 한댄다. 맞는지 틀린지..

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>


//arg를 여러 파라미터로 사용하기 위해,
//구조체로 정의
//https://stackoverflow.com/questions/52812004/parameter-passing-multiple-values-using-void-pointer
//여기 참조
//공유 자원.
int sharedInt=0;
//mutex 설정.
static pthread_mutex_t the_mutex = PTHREAD_MUTEX_INITIALIZER;

struct myStruct {
	//struct는 initilizer를 지원하지 않음.
	char *message;
	int index;
	//index를 보고 입력된 파라미터로 hello, one, two, three를 선택.
	//이렇게 구현하려 했으나, 힘들어 문자열로 변경.
	//index로 sharedInt를 업데이트 하려 했으나,
	//잘 안됨..
	//스레드가 시작할 때마다 sharedInt를 업데이트 하면 기존 값을
	//버리고 다시 씀!!
	//thread 안에서만 공유 자원을 조작..


};



void* start_routine(void* arg ){
	int pid;
	int threadID;
	//struct로 arg를 받기 위해, 
	//struct로 변경.
	struct myStruct *temp;

	temp = arg;
	//pointer 로 global 변수 변경

	//pthread_mutex_lock(&the_mutex);
	//sharedInt = temp->index;

	//printf("my thread sentence is \"%s\"\n", temp->message);
	//printf("temp->index is %d\n", temp->index);

	pthread_mutex_lock(&the_mutex);

	printf("SharedInt는 %d\n",sharedInt);
	if(sharedInt == 0){
		//strsep(temp->message, " ");
		//printf("my thread word is %s\n",outputword);
		printf("zero\n");
		//temp->index++;

	}

	else if(sharedInt == 1){
		//printf("my thread word is %s\n",outputword);
		printf("one\n");
		//temp->index++;

	}
	else if(sharedInt == 2){
		printf("two\n");
		//temp->index++;

	}

	else{
		printf("three or more\n");
	}
	sharedInt++;

	pthread_mutex_unlock(&the_mutex);

	}

int main(){

	pthread_t thread[2];
	int ret, errorno;
	struct myStruct message = {"hello one two three", 0 };
	printf("myStruct message index는 %d\n", message.index);
	//아래 부분은 불필요 부분. thread 밖에서 조작하여 무의미함.
	//message.index=2;

	ret = pthread_create(&thread[0],NULL,start_routine,(void*)&message);

	if(ret<0){
		errorno = ret;
		//printf("%d\n",errorno);
		perror("pthread_create");
		return -1;
	}
	//아래 부분은 불필요 부분. thread 밖에서 조작하여 무의미함.
	//message.index=1;

	//printf("myStruct message index는 %d\n", message.index);

	//printf("struct 출력: %d",message.index);
	//printf("message 확인 %d",message.index);

	ret = pthread_create(&thread[1],NULL,start_routine,(void*)&message);

	if(ret<0){
		errorno = ret;
		//printf("%d\n",errorno);
		perror("pthread_create");
		return -1;
	}

	//각 스레드 끝나길 대기

	pthread_join(thread[0],NULL);
	pthread_join(thread[1],NULL);
	//mutex 삭제
	pthread_mutex_destroy(&the_mutex);
	printf("completed\n");
	return 0;

}

100번 돌리면 mutex lock을 설정한 경우와 설정하지 않은 경우 값이 다름. 나름 이해했다고 믿고 싶다.

linux system programming, 234p

https://bitsoul.tistory.com/m/157 여기 참조.

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>


void* start_routine(void* arg ){
	int pid;
	int threadID;
	pid= getpid();
	printf("pid is %d\n", pid);
	threadID = pthread_self();
	printf("tid is %lu\n",threadID);
	printf("data is %s\n",arg);
	}

int main(){
	pthread_t thread[2];
	const char *message1="hello one";
	const char *message2="hello two";
	const char *message3="hello main";

	int ret, errorno;
	ret = pthread_create(&thread[0],NULL,start_routine,(void*)message1);
	if(ret<0){
		errorno = ret;
		//printf("%d\n",errorno);
		perror("pthread_create");
		return -1;
	}
	ret = pthread_create(&thread[1],NULL,start_routine,(void*)message2);
	if(ret<0){
		errorno = ret;
		//printf("%d\n",errorno);
		perror("pthread_create");
		return -1;
	}



	/*
	for(int i=0;i<2;i++){
		ret = pthread_create(&thread[i],NULL,start_routine,NULL);
		if(!ret){
			errorno = ret;
			printf("%d\n",errorno);
			perror("pthread_create");
			return -1;
		}
	}
	*/
	int thread_compare=0;
	//스레드가 다르면 0, 같으면 0이 아는 수 리턴.
	//다른 스레드로 0을 리턴.
	thread_compare = pthread_equal(thread[0], thread[1]);
	printf("thread is same? %d\n",thread_compare);
	sleep(1);
	//메인에서  start_routine.
	start_routine((void*)message3);


	//각 스레드 끝나길 대기

	pthread_join(thread[0],NULL);
	pthread_join(thread[1],NULL);
	return 0;

}

위 코드를 실행하면 아래와 같다. race condition으로 매 실행 다른 결과를 보았다.

pi@raspberrypi:~/Project/cCode/systemProgram $ gcc -lpthread mythread.c ;./a.out 
thread is same? -1235590048
pid is 14996
tid is 3059377248
data is hello two
pid is 14996
tid is 3067769952
data is hello one
pid is 14996
tid is 3069673600
data is hello main
pi@raspberrypi:~/Project/cCode/systemProgram $ gcc -lpthread mythread.c ;./a.out 
pid is 15068
tid is 3067769952
data is hello one
pid is 15068
tid is 3059377248
data is hello two
thread is same? 0
pid is 15068
tid is 3069673600
data is hello main
pi@raspberrypi:~/Project/cCode/systemProgram $ gcc -lpthread mythread.c ;./a.out 
pid is 15125
tid is 3068077152
data is hello one
thread is same? 0
pid is 15125
tid is 3059684448
data is hello two
pid is 15125
tid is 3069980800
data is hello main

gnu c는 pthread가 전부인가 보다.