아래 포스팅보다 더 많은 정보와 예제를 담은 리눅스 교재를 배포했습니다. 아래의 페이지에서 리눅스 교재를 받아가세요.

https://reakwon.tistory.com/233

 

리눅스 프로그래밍 note 배포

티스토리에 리눅스에 관한 내용을 두서없이 여지껏 포스팅했었데요. 저도 제 포스팅을 찾기가 어렵기도 하고 티스토리에서 코드삽입을 하게 되면 이게 일자로 쭉 쓰여져있는 x같은 현상이 생겨

reakwon.tistory.com

 

사용자 ID(Real User ID, Effective User ID,  Saved User ID) 그룹 ID(Real Group ID, Effective Group ID, Saved Group ID)

리눅스에서 사용자는 각 User ID라는 값을 갖습니다. 그리고 그 사용자는 어느 그룹의 일원이 되죠. 그래서 Group ID도 같이 갖습니다. 이렇게 id를 부여하는 이유는 각각 사람들마다 다른 권한을 갖고 있기 때문입니다. 각 사용자들은 자신들의 파일을 만들고 그 파일에 대해 권한을 부여합니다. 즉, 이 파일을 어디까지 허용할지 말이죠. 파일을 누구에게 까지 읽고 쓰는 것을 허락하느냐, 실행파일이라면 실행을 누구에게 까지 허락하느냐 이러한 허용 말입니다.

그런데 실행 파일이라면 특수한 권한 하나가 더 생깁니다. 이 파일을 실행할 경우에 갖는 권한, 즉 실행 할 때만 유효한 권한이요. 그게 뭐냐면 실행할 때만 소유주의 권한, 혹은 소유주 그룹의 권한으로 실행되는 권한입니다. 예를 들어서 파일을 읽는 어떤 프로그램이 있다고 칩시다. 그리고 이 프로그램의 소유주는 “기쁨”이라고 할게요. 어떤 사용자 “똘똘이”가 프로그램을 통해서 파일을 읽을 땐 똘똘이의 파일밖에 못 읽습니다. 기쁨이의 파일을 함부로 볼 수가 없죠. 근데 착한 기쁨이는 나의 프로그램을 쓸 때 나의 파일은 읽을 수 있게 특별한 권한을 이 프로그램에 준다면 똘똘이는 기쁨이의 파일도 읽게 될 수 있습니다. 이와 같은 상황을 권한이 확장되었다라고 합니다.

 

전문용어로 정리하면 아래와 같습니다. 그리고 여기서는 uid에만 포커스를 맞춰서 보겠습니다. 왜냐면 gid도 역시 uid와 같은 방식으로 동작되지 때문이죠.

UID 종류 설명
Real UID(User ID)
ruid
실제 사용자 ID를 의미합니다. 여러분들이 로그인할 때 접속하는 그 user의 ID입니다. 이 실제 id에 대한 정보는 /etc/passwd 파일에 기록이 되어있지요. 줄여서 ruid라고 하겠습니다.
Effective UID(User ID)
euid
프로그램 실행 시 갖는 권한을 의미하며 실행 파일의 소유주 권한입니다. 보통은 사용자 ruid와 같습니다. 실행파일의 user 실행 권한에 setuid 권한이 있을 경우에 달라집니다. 줄여서 euid라고 합니다.
Saved UID(User ID)
suid
저장된 사용자의 ID라고 합니다. 프로그램에 권한을 더 쎈 권한을 주어야할 때나 권한을 더 줄여야할 때에 유기적으로 쓰이게 됩니다. 줄여서 suid라고 합니다. suid의 쓰임새에는 조금 나중에(맨 아래에서) 코드로 설명을 드리겠습니다.

 

GID 종류 설명
Real GID(Group ID)
rgid
실제 사용자 그룹의 ID입니다. Ruid와 마찬가지로 로그인할때 부여되는 gid를 의미합니다. 줄여서 rgid라고 합니다.
Effective GID(Group ID)
egid
유효 사용자 그룹의 ID입니다. 역시 보통은 rgid와 같습니다. 실행파일에 setgid비트가 켜져있으면 rgid와 달라질 수 있습니다.
Saved GID(Group ID)
sgid
저장된 그룹의 ID입니다. 줄여서 sgid라고 합니다.

이제 uid와 관련한 함수들을 보면서 어떤 특징을 갖는지 확인해보도록 합시다. 현재 접속한 사용자가 누군지 쉽게 알아보게 하기 위해서 프롬프트 앞에 사용자 계정명을 같이 표시하겠습니다.

1. 사용자 uid 읽기 - getuid, geteuid, getresuid

#include <unistd.h>
uid_t getuid(void);
uid_t geteuid(void);
int getresuid(uid_t *ruid, uid_t *euid, uid_t *suid);

getuid는 사용자의 진짜 레알 아이디인 ruid를 가져옵니다.
geteuid는 프로그램의 실행 중 권한 euid를 가져옵니다.
getresuid는 프로그램의 ruid, euid뿐만 아니라 suid까지 가져옵니다. 실패시 -1을 가져옵니다.

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

void pr_resuid(){
        uid_t ruid, euid, suid;
       
        if(getresuid(&ruid, &euid, &suid) < 0){
                printf("getresuid error\n");
                exit(1);
        }

        printf("ruid : %d, euid :%d, suid :%d\n",
                        ruid, euid, suid);

}
int main(){
        pr_resuid();
}

보통의 상황이라면 ruid와 euid, suid는 같게 될 겁니다. 아래와 같이 u+s를 주어 setuid를 설정합니다. 그리고 실행하면 ruid와 euid는 0입니다. 여기까지는 다들 예상 하실 겁니다.

root# ls -l a.out 
-rwxr-xr-x 1 root root 8968 Jun 19 11:27 a.out
root# chmod u+s a.out
root# ./a.out 
ruid : 0, euid :0, suid :0

만약 다른 사용자로 로그인하게 되면 아래와 같이 실제 ruid는 바뀌지 않으나 euid는 바뀌죠. 여기까지 다 아는 내용입니다. 단순히 getresuid를 통해서 세가지 uid(ruid, euid, suid)를 가져오는 예제일 뿐입니다. 이 함수는 3개의 uid인 ruid, euid, suid를 모두 가져올 수 있기 때문에 지금부터 아래의 예제들은 이 함수로 uid들을 출력하도록 하겠습니다. 아, suid는 맨 처음 euid와 같은 점은 눈여겨 보시기 바랍니다.

root# su ubuntu
ubuntu$ ./a.out 
ruid : 1000, euid :0, suid :0

 

2. uid 설정 함수들

setuid, setgid

#include <unistd.h>
int setuid(uid_t uid);
int setgid(uid_t gid);

setuid : 사용자가 루트일 경우 ruid, euid, suid를 전달된 인자인 uid로 변경할 수 있는 함수입니다(ruid = euid = suid = uid). 다만, 일반 조건에 맞는 유저일 경우만 제한적으로 euid만 자신의 uid로 변경됩니다.

자, 여기서 잘 생각해보세요. 아무나 ruid, 혹은 euid 혹은 suid를 바꾸면 될까요? 안될까요? 그러니까 아무나 본인의 학번이나 사번을 바꾼다고 생각해보세요. 있을 수가 없는 일이죠. 결론부터 말씀드리자면 setuid는 프로그램이 루트 권한으로 실행되면 루트사용자일 경우에 ruid, euid, suid 모두 변경합니다. 루트는 킹 중의 킹, 전설의 레전드입니다. 루트가 바꾸면 토 달지말고 그냥 바꾸는 겁니다.

다시 말하면 프로그램의 euid가 루트일때, setuid는 ruid, euid, suid 모두 바꿔버립니다. 즉, “유효 사용자 id가 root이면(현재 프로그램의 euid가 root이면) 모든 id(ruid, euid, suid)를 setuid를 통해서 바꿀 수 있다.” 입니다. 그런데 루트 사용자의 권한이 아닌 프로그램이고 그 안에서 setuid를 통해서 인자인 uid를 바꾸려하면, 사용자의 ruid 혹은 suid가 setuid의 인자로 전달되는 uid와 같을 때 euid만 변경이 됩니다. 그러니까 루트 사용자가 아닌 경우에는 실제 uid, 즉 ruid는 죽었다 깨어나도 변경할 수 없다는 의미입니다. euid만 바꿀 수 있습니다. 자신의 ruid 혹은 suid로만 말이죠.

얘기가 길었죠. 간단히 정리하면, 현재 유효 사용자 ID가 루트인 경우 ruid, euid, suid 가 원하는 uid로 바꿀 수 있습니다. 현재 유효 사용자 ID가 일반 유저인 경우 현재의 실 사용자 id(ruid) 혹은 현재의 저장된 사용자 id(suid)로 euid만 바꿀 수 있습니다.

다음은 setuid의 특징을 알아보는 코드입니다.

 

//setuid.c

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

void pr_resuid(){
        uid_t ruid, euid, suid;
       
        if(getresuid(&ruid, &euid, &suid) < 0){
                printf("getresuid error\n");
                exit(1);
        }

        printf("ruid : %d, euid :%d, suid :%d\n",
                        ruid, euid, suid);

}

int main(int argc, char *argv[]){
        uid_t uid;
        if(argc < 2){
                printf("%s uid(>=0)\n", argv[0]);
                return 0;
        }

        pr_resuid();

        uid = atoi(argv[1]);
        printf("setuid(%d)\n", uid);
        if(setuid(uid) == -1){
                printf("setuid error : %s\n", strerror(errno));
                exit(0);
        }

        pr_resuid();
}

ubuntu의 계정으로 컴파일 합니다. 이때 ruid는 1000번입니다.

ubuntu$ gcc setuids.c 
ubuntu$ chmod u+s a.out
ubuntu$ id
uid=1000(ubuntu) gid=1000(ubuntu) groups=1000(ubuntu),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),110(lxd)

이 프로그램을 다른 계정으로 실행해보면 어떻게 될까요? euid 1000인 프로그램에서 실제 ruid가 다른 1001로 바꾸려고 할 때는 아래와 같이 에러가 발생합니다. 당연하겠죠. euid도 누군가가 함부로 남의 euid를 쓸 수는 없는 겁니다.

ubuntu$ ./a.out 1000
ruid : 1000, euid :1000, suid :1000
setuid(1000)
ruid : 1000, euid :1000, suid :1000

ubuntu$ ./a.out 1001
ruid : 1000, euid :1000, suid :1000
setuid(1001)
setuid error : Operation not permitted

 

아까 조건에서도 봤듯이 ruid 혹은 suid가 변경하려는 uid와 같아야 euid만 변경이 됩니다. 여기 1001인 유저 hello로 로그인해서 확인해보겠습니다.

ubuntu$ su hello
Password: 
hello$ id
uid=1001(hello) gid=1001(hello) groups=1001(hello) 

hello$ ./a.out 1000    <- ruid:1001, suid: 1000이므로 euid를 1000으로 변경 가능
ruid : 1001, euid :1000, suid :1000
setuid(1000)
ruid : 1001, euid :1000, suid :1000

hello$ ./a.out 1001  <- ruid:1001, suid: 1001이므로 euid를 1001으로 변경 가능
ruid : 1001, euid :1000, suid :1000
setuid(1001)
ruid : 1001, euid :1001, suid :1000

hello$ ./a.out 1       <- ruid:1001, suid: 1000이므로 1로 변경 불가 
ruid : 1001, euid :1000, suid :1000
setuid(1)
setuid error : Operation not permitted

그렇다면 만약 프로그램의 주인이 루트라면 위 상황은 어떻게 될까요? 아래 명령을 통해서 owner를 바꾸고 setuid도 같이 바꿔줍니다.

root# chown root:root a.out     <- 절대무적 루트가 나타나 owner를 자신으로
root# chmod u+s a.out               <- 실행시 root의 권한을 갖는다.

그리고 계정을 root로 바꿔서 실행해보면 ruid, euid, suid를 전부 바꾼다는 것을 알 수 있습니다. 이는 프로그램이 실행될 때 root의 권한으로 실행(초기 euid가 root) 되어지기 때문에 이라는 것을 설명드렸어요. 루트는 절대무적이니까요.

ubuntu$ ./a.out 0
ruid : 1000, euid :0, suid :0.     <- 현재 유효사용자 id(euid)는 root
setuid(0)
ruid : 0, euid :0, suid :0   <- euid가 root이기 때문에 모든id를 바꿀 수 있다.

ubuntu$ ./a.out 1000
ruid : 1000, euid :0, suid :0
setuid(1000)
ruid : 1000, euid :1000, suid :1000

ubuntu$ ./a.out 1001
ruid : 1000, euid :0, suid :0
setuid(1001)
ruid : 1001, euid :1001, suid :1001

ubuntu$ ./a.out 1
ruid : 1000, euid :0, suid :0
setuid(1)
ruid : 1, euid :1, suid :1

 

seteuid, setegid

#include <unistd.h>
int seteuid(uid_t euid);
int setegid(gid_t egid);

현재의 euid를 바꿉니다. 유효사용자가 root라면 euid를 원하는 값으로 바꿀 수 있습니다. 그런데 일반 사용자라면 euid는 현재의 ruid 혹은 현재의 suid로만 바꿀 수 있습니다. 실패시 -1을 반환합니다.

setreuid, setregid

#include <unistd.h>
int setreuid(uid_t ruid, uid_t euid);
int setregid(gid_t rgid, gid_t egid);

위 함수들은 ruid, euid를 바꾸는 것 처럼 보이죠? 맞습니다. 그런데 추가로 suid도 바꿉니다. suid는 euid와 같이 바꿉니다. 이전에 보았던 setuid는 일반 유저가 ruid를 바꾸는게 불가능했었습니다. 그런데 이 함수는 가능합니다. 일반유저인 경우 setreuid 함수는 현재 ruid, euid(현재 suid와는 상관없습니다.) 중에서만 변경할 수 있습니다. 변경을 원치 않는 uid인 경우 -1을 넣어주면 됩니다.

ex) setreuid(-1, 1000);

실패시 -1을 반환합니다.

setresuid, setresgid

#include <unistd.h>
int setresuid(uid_t ruid, uid_t euid, uid_t suid);
int setresgid(gid_t rgid, gid_t egid, gid_t sgid);

만약 ruid, euid, suid를 모두 개별적으로 바꾸고 싶다면 이 함수를 사용하면 됩니다. 단, 이 함수도 아무 id나 바꿀 수는 없겠죠? root를 제외한 나머지 유저들은 ruid, euid, suid 각각의 값을 현재 ruid, euid, suid 중의 값으로만 바꿀 수 있습니다. 실패 시 -1을 반환합니다. 만약 현 uid를 그대로 유지하고 싶다면 해당하는 인자에 -1을 넣어주세요.

그럼 여기까지 uid 설정 함수들을 정리합니다.

현재 ruid, euid, suid = ruid`, euid`, suid`

Ø  유효 사용자 ID = Root

함수 ruid euid suid
setuid ruid`, euid`, suid와 상관없이 원하는 uid로 변경
seteuid 변경 불가 원하는 값으로 설정 가능 변경 불가
setreuid ruid`, euid`, suid와 상관없이 원하는 uid로 변경 euid와 같음
setresuid ruid`, euid`, suid와 상관없이 원하는 uid로 변경

 

Ø  유효 사용자 ID = 일반 유저

함수 ruid euid suid
setuid 변경 불가 ruid` 혹은 suid`로 변경 가능 변경 불가
seteuid 변경 불가 ruid` 혹은 suid`로 변경 가능 변경 불가
setreuid ruid`, euid` 중 하나로 변경 가능 ruid`, euid` 중 하나로 변경 가능 euid와 같음
setresuid ruid`, euid`, suid`  중 하나로 변경 가능 ruid`, euid`, suid`  중 하나로 변경 가능 ruid`, euid`, suid`  중 하나로 변경 가능

 

아래 setuid, setreuid, setresuid를 차례차례 알아보는 코드와 위의 표 내용이 맞는 지 확인하는 실행 결과를 보여줍니다.

//setuids_test.c

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

void pr_resuid(){
        uid_t ruid, euid, suid;

        if(getresuid(&ruid,&euid,&suid) < 0){
                printf("getresuid error\n");
                exit(1);
        }

        printf("ruid : %d, euid : %d, suid : %d\n", 
                        ruid, euid, suid);

}
void setuid_test(){
        uid_t uid;
        printf("uid :");
        scanf("%d", &uid);

        if(setuid(uid) < 0){
                printf("setuid %d로 변경 불가 \n", uid);
        }
        pr_resuid();
}
void seteuid_test(){
        uid_t euid;
        printf("euid :");
        scanf("%d", &euid);
        if(seteuid(euid) < 0){
                printf("seteuid %d로 변경 불가 \n", euid);
        }
        pr_resuid();
}
void setreuid_test(){
        uid_t ruid, euid;
        printf("ruid euid :");
        scanf("%d %d", &ruid, &euid);
        if(setreuid(ruid, euid) < 0){
                printf("setreuid %d %d로 변경 불가\n", ruid, euid);
        }
        pr_resuid();
}
void setresuid_test(){
        uid_t ruid, euid, suid;
        printf("ruid euid suid :");
        scanf("%d %d %d", &ruid, &euid, &suid);
        if(setresuid(ruid, euid, suid) < 0){
                printf("setresuid %d %d %d로 변경 불가\n", ruid, euid, suid);
        }
        pr_resuid();
}
int main(){
        printf("현재 uid\n");
        pr_resuid();

        while(1){
                char c;
                printf("(1)setuid-test\n");
                printf("(2)seteuid-test\n");
                printf("(3)setreuid-test\n");
                printf("(4)setresuid-test\n");
                printf("(other)exit\n");

                scanf(" %c", &c);
                switch(c){
                        case '1':
                                setuid_test();
                                break;
                        case '2':
                                seteuid_test();
                                break;
                        case '3':
                                setreuid_test();
                                break;
                        case '4':
                                setresuid_test();
                                break;
                        default:
                                return 0;
                }

        }

}

 

아래의 상황은 ubuntu(1000)의 유효사용자 id를 갖는 위 프로그램을 hello(1001)라는 유저가 실행했을 때의 상황입니다.

hello$ ls -l a.out
-rwsr-xr-x 1 ubuntu ubuntu 13616 Jun 23 08:43 a.out
hello$ ./a.out 
현재 uid
ruid : 1001, euid : 1000, suid : 1000
(1)setuid-test
(2)seteuid-test
(3)setreuid-test
(4)setresuid-test
(other)exit
1
uid :1001
ruid : 1001, euid : 1001, suid : 1000   <- euid만 변경됨
(1)setuid-test
(2)seteuid-test
(3)setreuid-test
(4)setresuid-test
(other)exit
2
euid :1000
ruid : 1001, euid : 1000, suid : 1000  <- 현재 ruid, suid로만 euid만 변경됨
(1)setuid-test
(2)seteuid-test
(3)setreuid-test
(4)setresuid-test
(other)exit
3
ruid euid :1000 1001
ruid : 1000, euid : 1001, suid : 1001   <- euid와 suid는 같은 값이 됨
(1)setuid-test
(2)seteuid-test
(3)setreuid-test
(4)setresuid-test
(other)exit
3
ruid euid :1000 1000       <- setresuid(1000, 1000, 1000)과 같다.
ruid : 1000, euid : 1000, suid : 1000
(1)setuid-test
(2)seteuid-test
(3)setreuid-test
(4)setresuid-test
(other)exit
2
euid :1001   <- 3개의 uid가 전부 같은 1000이므로 euid를 바꿀 어떤 방법이 없다
seteuid 1001로 변경 불가 
ruid : 1000, euid : 1000, suid : 1000
(1)setuid-test
(2)seteuid-test
(3)setreuid-test
(4)setresuid-test
(other)exit
4
ruid euid suid :1000 1000 1001  <- 위와 같은 이유로 setresuid를 통해서도 바꿀 수없음
setresuid 1000 1000 1001로 변경 불가
ruid : 1000, euid : 1000, suid : 1000
(1)setuid-test
(2)seteuid-test
(3)setreuid-test
(4)setresuid-test
(other)exit
4
ruid euid suid :1000 1000 1000  <- 이게 무슨 의미가 있을까
ruid : 1000, euid : 1000, suid : 1000
(1)setuid-test
(2)seteuid-test
(3)setreuid-test
(4)setresuid-test
(other)exit
q         <- 분노의 종료

 

실제 사용자 ID(Real UID), 그리고 유효 사용자 ID(Effective UID)는 대충 알겠는데, saved UID는 어떤 경우에 사용이 되는 걸까요? 포스팅이 너무 길어지니 아래의 포스팅에서 설명하도록 하겠습니다.

https://reakwon.tistory.com/234

 

리눅스 - 코드로 이해하는 저장된 사용자 ID(Saved UID)가 있는 이유

저장된 사용자 ID - Saved UID Saved UID를 이해하기 위해서는 실제 사용자 ID(Real UID)와 유효 사용자 ID(Effective UID)에 대한 이해가 깔려있어야합니다. 아직 개념이 안잡혀있다면 아래의 포스팅을 먼저

reakwon.tistory.com

 

반응형
블로그 이미지

REAKWON

와나진짜

,

 

DM-verity 

Data Mapper Verity의 약자로 쓰이는데, 루트 파일 시스템(Root FS)의 검증에 쓰인다. 과거에 안드로이드에 쓰였지만 현재는 점차 임베디드에 쓰이기 시작한다. 기본 원리는 아래의 해시 트리(Hash-Tree)를 만드는 것인데, Data Block마다 Hash를 생성해서 가장 아래 level의 hash 노드를 만들기 시작하고 그 위 level의 hash 노드를 그 아래 level에 hash node를 이용하여 만들어 점차 트리를 완성시켜가는데, 이때 가장 맨 위의 Hash 노드를 Root Hash라고 하며 안전하게 보관되어져야한다. 이 Root Hash값을 이용해서 dm-verity를 검증해야하기 때문.   

이러한 Hash tree를 Merkel Tree라고도 한다. 

https://www.timesys.com/security/dm-verity-without-an-initramfs/

 

1. 블록 장치 생성 + 파일 시스템 설정

# truncate -s 10G data_partition.ext4
# mkfs -t ext4 data_partition.ext4
# mkdir mnt 
# mount -o loop data_partition.ext4 mnt/ 
# echo "hello" > mnt/one.txt 
# echo "integrity" > mnt/two.txt 
# umount mnt/ 
# truncate -s 100M hash_partition.verity

10G의 크기를 갖는 블록을 하나 생성하여 ext4 파일 시스템을 적용한다. 그리고 그 안에 one.txt, two.txt를 만들고 난 후 unmount를 한다.

이후 100M 크기의 hash의 값을 갖는 영역을 생성해낸다. 이곳에 dm-verity의 merkle-tree가 저장된다.

 

2. dm-verity format

# veritysetup -v --debug format data_partition.ext4 hash_partition.verity > root_hash.txt

 

root_hash.txt의 내용

# cryptsetup 2.2.2 processing "veritysetup -v --debug format data_partition.img hash_partition.img" 
# Running command format. 
# Allocating context for crypt device hash_partition.img. 
# Trying to open and read device hash_partition.img with direct-io. 
# Initialising device-mapper backend library. 
# Formatting device hash_partition.img as type VERITY. 
# Crypto backend (OpenSSL 1.1.1f  31 Mar 2020) initialized in cryptsetup library version 2.2.2. 
# Detected kernel Linux 5.13.0-52-generic x86_64. 
# Setting ciphertext data device to data_partition.img. 
# Trying to open and read device data_partition.img with direct-io. 
# Hash creation sha256, data device data_partition.img, data blocks 2621440, hash_device hash_partition.img, offset 1. 
# Using 4 hash levels. 
# Data device size required: 10737418240 bytes. 
# Hash device size required: 84557824 bytes. 
# Updating VERITY header of size 512 on device hash_partition.img, offset 0. 
VERITY header information for hash_partition.img 
UUID:               4da1ecb5-5111-4922-8747-5e867036d9de 
Hash type:          1 
Data blocks:        2621440 
Data block size:    4096 
Hash block size:    4096 
Hash algorithm:     sha256 
Salt:       	     f2790cf141405152cf61b6eb176128ad0676b41524dd32ac39760d3be2d495cf 
Root hash:          a2a8fd07889deb10b4cdf53c01637ed373212cd7d0877a8aa9ae6fd4240f0f71 
# Releasing crypt device hash_partition.img context. 
# Releasing device-mapper backend. 
# Closing read write fd for hash_partition.img. 
Command successful.

Root Hash(a2a8fd07889deb10b4cdf53c01637ed373212cd7d0877a8aa9ae6fd4240f0f71)의 내용은 trusted된 내용이어야하고, 안전하게 보관되어야한다.

 

3. dm-verity open

# veritysetup open \ 
>         data_partition.ext4 \ 
>         verity-test \ 
>         hash_partition.verity \ 
>         a2a8fd07889deb10b4cdf53c01637ed373212cd7d0877a8aa9ae6fd4240f0f71

data_partition.ext4의 mapper를 생성한다.

/dev/mapper/verity-test 가 생성된 것을 확인할 수 있다.

# mkdir mnt 
# mount /dev/mapper/verity-test mnt/ 
mount: /home/ubuntu/ext4/mnt: WARNING: source write-protected, mounted read-only.
# cat mnt/one.txt mnt/two.txt 
hello
integrity

read-only로 mount 되었다.

 

4. dm-verity verify

user-space에서 검증이 가능하다.

  • 검증 성공 시
# veritysetup verify \
> /dev/mapper/verity-test \
> hash_partition.verity \
> a2a8fd07889deb10b4cdf53c01637ed373212cd7d0877a8aa9ae6fd4240f0f71
#
  • 검증 실패 시

  hash의 값을 변경(끝 네자리 0f71 0f73)

# veritysetup verify \
> /dev/mapper/verity-test \
> hash_partition.verity \
> a2a8fd07889deb10b4cdf53c01637ed373212cd7d0877a8aa9ae6fd4240f0f73
Verification of root hash failed.

 

5. Corruption 발생 처리

dm-verity는 디스크를 binary level 수준으로 보호하기 때문에 한 비트라도 어긋나게 되면 corruption 발생 처리하며 mount되지 않는다.

disk를 read-write로 mount하는 것 만으로도 meta-data 변형이 일어나기 때문에 binary가 변경된다. 따라서 corruption을 일으키기 충분하다.

# umount mnt/ 
# veritysetup close verity-test 
# mount -o loop data_partition.ext4 mnt/ 
# umount mnt/ 
# veritysetup open \ 
>         data_partition.ext4 \ 
>         verity-test \ 
>         hash_partition.verity \ 
>         a2a8fd07889deb10b4cdf53c01637ed373212cd7d0877a8aa9ae6fd4240f0f71 
Verity device detected corruption after activation 
root# mount /dev/mapper/verity-test mnt/ 
mount: /path/to/mnt: can't read superblock on /dev/mapper/verity-testroot## mount /dev/mapper/verity

 

dmesg를 확인하면 kernel에서 dm-verity의 log를 확인 할 수 있다.

[412036.212897] device-mapper: verity: 7:16: data block 0 is corrupted 
[412036.212996] device-mapper: verity: 7:16: data block 0 is corrupted 
[412036.213009] buffer_io_error: 91 callbacks suppressed 
[412036.213011] Buffer I/O error on dev dm-0, logical block 0, async page read 
[412036.223697] device-mapper: verity: 7:16: data block 0 is corrupted

 

5. dm-verity status

현재 mapping 상태를 확인한다.

# veritysetup status verity-test
/dev/mapper/verity-test is active.
  type:        VERITY
  status:      corrupted
  hash type:   1
  data block:  4096
  hash block:  4096
  hash name:   sha256
  salt:        f2790cf141405152cf61b6eb176128ad0676b41524dd32ac39760d3be2d495cf
  data device: /dev/loop11
  data loop:   /home/ubuntu/ext4/data_partition.ext4
  size:        20971520 sectors
  mode:        readonly
  hash device: /dev/loop10
  hash loop:   /home/ubuntu/ext4/hash_partition.verity
  hash offset: 8 sectors
  root hash:   a2a8fd07889deb10b4cdf53c01637ed373212cd7d0877a8aa9ae6fd4240f0f71

 

6. dm-verity close

mapping을 제거한다.

# veritysetup close verity-test

/dev/mapper에서 사라진것을 확인할 수 있다.

 

Reference)

https://www.timesys.com/security/dm-verity-without-an-initramfs/

 

DM-Verity Without an Initramfs - Timesys

Learn how you can implement file system verification on your embedded system without the use of an initramfs. This can significantly save boot time and storage requirements in many situations.

www.timesys.com

https://www.starlab.io/blog/dm-verity-in-embedded-device-security

반응형
블로그 이미지

REAKWON

와나진짜

,

디바이스 드라이버에 Argument 전달

디바이스 드라이버가 등록될때나 실행되고 있을때 인자를 전달할 수 있을까요? 예를 들면 우리가 ls 명령어를 실행할때 ls -l /etc/와 같이 -l /etc/와 같은 인자들을 전달하는 것처럼 말이죠. 응용 프로그램에서는 간단합니다. 우리는 알고 있죠. C언어를 사용한다면 main에서 argc와 args를 사용해서 목적을 달성 할 수 있다는 것을 말이죠. 

int main(int argc, char* argv[])

 

리눅스의 디바이스 드라이버에서도 가능합니다. 바로 아래의 매크로들을 이용하면 됩니다. 포스팅 아래에서는 아래의 매크로를 통해서 예제 코드를 구현합니다.

  • module_param(name, type, perm) : 변수 name을 설정합니다. name의 자료형은 type이고, perm은 권한을 나타냅니다.
  • module_param_array(name, type, num, perm) : 배열 버전입니다. num이 자료형의 배열 크기를 나타냅니다.
  • module_param_cb(name, &ops, &name, perm) : 만약 paremeter의 값이 바뀐 경우 알아차려야한다면, 이 매크로를 사용하면 됩니다. cb는 callback의 약자입니다.

 

그리고 이러한 파라미터를 읽거나 수정할때 권한(permission)을 지정할 수 있습니다. S_I를 Prefix로 하고, R(Read), W(Write), X(eXecute)를 의미하며 USR은 user, GRP는 group 권한을 의미합니다. |(OR)을 통해서 여러 권한을 줄 수 있습니다.

  • S_IRUSR
  • S_IWUSR
  • S_IXUSR
  • S_IRGRP
  • S_IWGRP
  • S_IXGRP

 

아래의 코드를 보면서 어떻게 위의 매크로들이 사용되는지 알아보도록 하겠습니다. 


소스코드 

//passing_params.c
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/moduleparam.h>


int value, arr_value[4];
char *name;
int cb_value = 0;

module_param(value, int, S_IWUSR|S_IRUSR);
module_param(name, charp, S_IRUSR|S_IWUSR);
module_param_array(arr_value,int, NULL, S_IRUSR|S_IWUSR);

// module_param_cb를 위한 setter
int notify_param(const char *val, const struct kernel_param *kp){
        int res = param_set_int(val, kp);
        if(res == 0){
                printk(KERN_INFO "Call back function called...\n");
                printk(KERN_INFO "New value of cb_value = %d\n",cb_value);
                return 0;
        }
        return -1;
}

const struct kernel_param_ops my_param_ops = {
        .set = &notify_param, //위에 정의한 setter
        .get = &param_get_int, // standard getter
};

module_param_cb(cb_value, &my_param_ops, &cb_value, S_IRUGO|S_IWUSR);

static int __init my_module_init(void){
        int i;
        printk(KERN_INFO "===== Print Params =====\n");
        printk(KERN_INFO "value = %d \n", value);
        printk(KERN_INFO "cb_value = %d \n", cb_value);
        printk(KERN_INFO "name = %s\n", name);
        for(i = 0; i < sizeof(arr_value)/sizeof(int); i++){
                printk(KERN_INFO "arr_value[%d] = %d \n", i, arr_value[i]);
        }
        return 0;
}

static void __exit my_module_exit(void){
        printk(KERN_INFO "Kernel Module Removed ...\n");
}

module_init(my_module_init);
module_exit(my_module_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Reakwon");
MODULE_DESCRIPTION("A simple parameter test module");
MODULE_VERSION("1:1.0");

 

Makefile

obj-m += passing_params.o
KDIR = /lib/modules/$(shell uname -r)/build

all :
        make -C $(KDIR) M=$(shell pwd) modules

clean :
        make -C $(KDIR) M=$(shell pwd) clean

insmod로 parameter 전달

$ sudo insmod passing_params.ko value=4 name="reakwon" arr_value=1,2,3,4

dmesg를 확인하면 잘 전달되고 읽히는 것을 확인할 수 있습니다.

insmod parameter 전달

 


파라미터 업데이트시 Callback

만약 parameter를 디바이스 드라이버가 실행 중일때 변경하고 이에 따른 동작을 수행하고자 한다면 어떻게 할까요? module_param_cb가 이런 이유때문에 존재합니다. 

모듈의 parameter는 /sys/module 아래의 자신의 모듈 이름의 디렉토리 하위 parameters 디렉토리에서 관리가 됩니다. 확인해볼까요? 

$ ls /sys/module/passing_params/parameters/
arr_value  cb_value  name  value

 

그래서 parameters의 하위의 변수들의 값을 바꿀수 있습니다. 이때 callback 함수를 등록하면 호출이 되게 됩니다.  위의 전체 코드 중 이와 관련한 코드가 여깄습니다.

// module_param_cb를 위한 setter
int notify_param(const char *val, const struct kernel_param *kp){
        //...//
}

const struct kernel_param_ops my_param_ops = {
        .set = &notify_param, //위에 정의한 setter
        .get = &param_get_int, // standard getter
};

module_param_cb(cb_value, &my_param_ops, &cb_value, S_IRUGO|S_IWUSR);

 

kernel_param_ops가 callback을 관리하는 구조체이고 여기의 멤버로 .set, .get, .free가 있습니다. 

struct kernel_param_ops 
{
 int (*set)(const char *val, const struct kernel_param *kp);
 int (*get)(char *buffer, const struct kernel_param *kp);
 void (*free)(void *arg);
};

 

아래와 같이 parameter의 값을 변경해봅시다. 

$ sudo sh -c "echo 1010 > /sys/module/passing_args/parameters/cb_value"

 

그리고 dmesg를 통해서 kernel 메시지를 확인하면 우리가 등록한 notify_param Callback함수가 호출됨을 알 수 있습니다. 

callback 호출

 

 

이 포스팅은 embetronicx의 contents를 참고하여 작성된 포스팅입니다. 여기에 다 담지못하는 부분은 아래의 페이지에서 참고하시기 바랍니다. 앞으로도 embetronicx의 tutorial을 기반으로 작성할 예정입니다.

https://embetronicx.com/tutorials/linux/device-drivers/linux-device-driver-tutorial-part-3-passing-arguments-to-device-driver/

 

반응형
블로그 이미지

REAKWON

와나진짜

,

메모리 대응 입출력과 더불어 더 많은 정보와 예제를 담은 리눅스 교재를 배포했습니다. 아래의 페이지에서 리눅스 교재를 받아가세요.

https://reakwon.tistory.com/233

 

리눅스 프로그래밍 note 배포

티스토리에 리눅스에 관한 내용을 두서없이 여지껏 포스팅했었데요. 저도 제 포스팅을 찾기가 어렵기도 하고 티스토리에서 코드삽입을 하게 되면 이게 일자로 쭉 쓰여져있는 x같은 현상이 생겨

reakwon.tistory.com

 

메모리 대응 입출력(memory-mapped I/O)

메모리 대응 입출력 기법은 디스크의 파일을 메모리에 한 부분인 버퍼에 대응을 시켜 읽거나 쓰는 동작을 할 수 있는 기법입니다. 그래서 파일 입출력을 위한 read나 write를 사용할 필요가 없습니다. 메모리 대응 입출력을 사용하려면 커널에 파일을 메모리에 대응(mapping)시키겠다고 정보들을 알려줘야합니다. 그렇기 위해서 우리는 mmap함수를 비롯해 몇가지 함수를 사용합니다. 그래서 마지막에는 메모리 대응 입출력을 활용하여 파일을 copy하는 프로그램을 만들어보도록 하겠습니다.

1. mmap 함수

mmap은 아래와 같이 정의가 되어있습니다. 주어지는 정보들은 아래와 같습니다.

#include <sys/mman.h>

void *mmap(void *addr, size_t length, int prot, int flags,
                 int fd, off_t offset);

 

- 반환값 : 성공시 메모리의 맵핑된 주소를 반환합니다. void* 형으로 자료형에 따라 알맞게 변환할 수 있습니다. 실패시에는 MAP_FAILED를 반환합니다. MAP_FAILED는 (void*) -1을 의미합니다. 

- addr : 메모리 대응 영역의 시작주소를 뜻합니다. 보통 0을 넣어 적절한 주소를 반환시킵니다. 이때 addr은 시스템의 가상 메모리 페이지의 크기 배수로 설정이 되어야한다는 것을 주의하시기 바랍니다.

- length : 얼마만큼의 메모리를 초기화 할 것인지 크리를 정합니다. 이때 offset 이후부터라는 점을 기억하시기 바랍니다. offset은 아래의 설명이 있습니다.

- prot : 메모리를 보호하는 방식을 설정합니다. 아래의 표와 같이 정의가 되어있습니다. 인수의 이름은 꽤나 직관적이니 뭐 굳이 자세한 설명은 필요없을 것 같네요.

prot 인수 설명
PROT_READ 메모리 영역 읽기 가능
PROT_WRITE 메모리 영역 쓰기 가능
PROT_EXEC 메모리 영역 실행 가능
PROT_NONE 메모리 영역 접근 불가

 

- flags : 메모리 대응 영역에 특성을 설정합니다. 여기서는 세가지만 설명하는데 리눅스 혹은 다른 구현에서는 많은 옵션이 존재할 수 있습니다.

flag 이름 설명
MAP_FIXED 반환값이 정확히 전달받은 addr의 주소와 같은데, 이 flag는 이식성을 저하시키므로 사용하지 않는 것을 권합니다. 
MAP_SHARED 영역에 대응된 파일을 수정합니다. 그러므로 메모리의 수정이 일어나면 파일의 수정이 일어납니다. 아래의 MAP_PRIVATE나 MAP_SHARED 중 하나를 설정해야합니다.
MAP_PRIVATE 유추가 되죠? 영역에 대응된 파일을 수정하는 MAP_SHARED와는 달리 메모리 대응 영역만 수정이 일어날뿐 실제 파일에는 수정이 일어나지 않습니다. 이를 비공유 복사본이 생성된다고 합니다. 

 

- fd : 대응시킬 파일 서술자를 뜻합니다. fd는 어디서 얻어오죠? open에서 얻어올 수 있습니다. 네, mmap을 사용하기 전에 file을 열어야합니다. 

 

- offset : 파일의 시작에서 부터 얼마만큼 떨어진 영역을 메모리에 대응시킬것인가를 뜻합니다. 이떄 offset은 가상 메모리 페이지 크기의 정수배여야합니다.

 > 가상 메모리 페이지 크기

그렇다면 가상 메모리 파이지 크기는 어떻게 알 수 있을까요? 아래의 코드로 얻어올 수 있습니다.

page_size = sysconf(_SC_PAGESIZE);

 

2. munmap

메모리 대응 영역은 프로세스가 종료되면 자동으로 해제가 되는데, munmap을 사용하여 직접 해제시킬 수 있습니다.

#include <sys/mman.h>

int munmap(void *addr, size_t length);

 

- 반환값 : 성공시 0, 실패시 -1을 의미하며 errno에 에러 정보가 저장됩니다.

- addr : 해제할 메모리 영역의 주소를 지정합니다.

- length : 얼마만큼의 영역을 해제할 것인지 size를 지정합니다.

 

3. memcpy

#include <string.h>

void *memcpy(void *dest, const void *src, size_t n);

메모리를 copy하는 함수입니다. 단순히 설명하면 src의 내용을 dest로 n만큼을 복사합니다. 성공시 dest의 주소를 반환하여 줍니다.

 

4. msync

MAP_SHARED으로 메모리를 대응시켰을 경우 일정 시간이 지나면 파일로 내용을 동기시키긴 하지만,  msync 함수를 호출하면 변경된 내용이 바로 실제 파일로 적용이 됩니다. 단, MAP_PRIVATE는 파일에 변경사항이 저장되지 않는 다는 점을 기억하세요. 

#include <sys/mman.h>

int msync(void *addr, size_t length, int flags);

addr과 length는 mmap의 내용과 같습니다. flags의 내용은 대충 아래 표와 같습니다.

flag 설명
MY_ASYNC 페이지들이 호출 반환 후에 방출되게 하고 싶으면 이 인수를 사용합니다.
MY_SYNC 쓰기들이 실제로 완료된 후에 호출이 반환되게 하려면 이 flag를 사용합니다.
둘 중 하나는 설정해야합니다. 

 

5. 메모리 대응 입출력을 이용한 파일 복사 프로그램

cp 명령 아시죠? cp src dst 를 하게 되면 src의 내용이 dst라는 파일로 복사가 됩니다. 아래는 이를 메모리 대응 입출력을 통해서 구현해보는 소스코드입니다.

#include <stdio.h>
#include <sys/mman.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>

int main(int argc, char *argv[]){
        int srcfd, dstfd; //src 파일 서술자, dst 파일 서술자
        void *src, *dst;  //src 메모리 주소, dst 메모리 주소
        size_t copysz; //다음 copy할  메모리 내용 size
        struct stat sbuf;
        off_t fsz = 0; //다음 읽기, 쓰기를 기록할 위치(offset)
        long page_size; //시스템의 PAGE SIZE

        if((srcfd = open(argv[1], O_RDONLY)) < 0) {
                fprintf(stderr, "can't open %s for reading \n",argv[1]);
                exit(1);
        }

        if((dstfd = open(argv[2], O_RDWR | O_CREAT | O_TRUNC, 0777)) < 0){
                fprintf(stderr, "can't open %s for writing\n", argv[2]);
                exit(1);
        }


        //file 사이즈 얻기 위한 용도
        if(fstat(srcfd, &sbuf) < 0){
                fprintf(stderr, "fstat error\n");
                exit(1);
        }

        if(ftruncate(dstfd, sbuf.st_size) < 0){
                fprintf(stderr, "ftruncate error\n");
                exit(1);
        }

        page_size = sysconf(_SC_PAGESIZE);
        printf("page_size : %ld\n", page_size);

        while(fsz < sbuf.st_size){

                if((sbuf.st_size - fsz ) > page_size)
                        copysz = page_size;
                else
                        copysz = sbuf.st_size - fsz;

                //src 주소 설정
                if((src = mmap(0, copysz, PROT_READ, MAP_SHARED, srcfd, fsz))
                                == MAP_FAILED){
                        fprintf(stderr, "mmap error for input \n");
                        printf("error : %s\n",strerror(errno));
                        exit(1);
                }

                //dst 주소 설정 , 여기서 MAP_SHARED를 MAP_RPIVATE로 바꾸면? dst파일에 저장되지 않는다.
                if((dst = mmap(0, copysz, PROT_READ|PROT_WRITE, MAP_SHARED, dstfd, fsz)) == MAP_FAILED){
                        fprintf(stderr, "mmap error for output\n");
                        exit(1);
                }

                //src -> dst로 내용 복사
                memcpy(dst, src, copysz);

                //메모리 해제
                munmap(src, copysz);
                munmap(dst, copysz);
                //복사한 내용만큼 다음 메모리 위치를 이동시킬 offset 증가
                fsz += copysz;

        }

        exit(0);
}

 

argv[1]은 복사할 파일 이름, argv[2]는 복사하여 나온 파일 이름입니다. ftruncate 함수로 출력 파일의 크기를 설정해줍니다. 

ftruncate는 아래와 같이 정의되어 있습니다. 간단히 설명하면 파일 서술자 fd의 길이를 length로 잘라버린다는 겁니다. 즉, 크기 지정한다고 보면 됩니다. 

#include <unistd.h>
#include <sys/types.h>

int ftruncate(int fd, off_t length);

 

이후 sysconf로 현재 나의 컴퓨터의 PAGE SIZE를 가져옵니다. 아까 말했듯이 addr과 offset은 PAGE SIZE의 배수여야한다고 했습니다. 

while 루프 안에서는 파일을 끝까지 복사할때까지 계속 반복합니다.

        while(fsz < sbuf.st_size){
        	//... 파일 복사 ...//
        }

while 루프 안의 로직은 어렵지 않습니다 .아까 배운 mmap을 통해서 src와 dst의 메모리를 대응 시킨 뒤에 memcpy 함수로 src의 내용을 dst의 내용으로 복사합니다.  그 이후 munmap으로 메모리를 해제하네요. 그 다음 page_size를 넘을만큼 그다면 다시 page_size 이후의 내용을 읽어야겠죠? fsz를 증가하는 이유가 그 이유입니다.

 

이상으로 메모리 대응 입출력에 대한 포스팅을 마치겠습니다.

반응형
블로그 이미지

REAKWON

와나진짜

,

리눅스에 관한 더 많은 정보와 예제를 담은 리눅스 교재를 배포했습니다. 아래의 페이지에서 리눅스 교재를 받아가세요.

https://reakwon.tistory.com/233

 

리눅스 프로그래밍 note 배포

티스토리에 리눅스에 관한 내용을 두서없이 여지껏 포스팅했었데요. 저도 제 포스팅을 찾기가 어렵기도 하고 티스토리에서 코드삽입을 하게 되면 이게 일자로 쭉 쓰여져있는 x같은 현상이 생겨

reakwon.tistory.com

 

readn, writen

네트워크같은 환경에서 어마어마한 데이터가 쓰여질 경우 일반 read함수로는 전부 읽어올 수 없는 상황이 발생할 수 있습니다. 또 반대의 경우에도 마찬가지입니다. 큰 데이터가 한번에 쓰여질 경우 write함수로는 쓰여지지 않을 수 있습니다. 아래와 같은 두가지의 상황이 발생하기 때문인데요.

1) read 연산이 요청보다 작은 바이트를 되돌려줄 경우에는 이는 오류가 아닙니다. 단지, 더 읽어야할 데이터가 있다는 뜻입니다. 2) write 역시 요청보다 작은 바이트를 돌려줄 수 있는 경우가 있는데, 커널의 출력 버퍼가 꽉 찼을때 이런 경우가 발생합니다.

1), 2)는 어떻게 해결할 수 있을까요? 답은 데이터가 요청된 값이 될때까지 읽거나 쓰는 것입니다. 이런 함수가 아래의 readn, writen 함수입니다.

- 아래의 코드는 Advanced Programming in the UNIX Environment 3판을 참고하여 만든 코드입니다.

 rean 함수

ssize_t readn(int fd, void *data, size_t n){
        size_t left;    //남은 바이트
        size_t read_n;  //읽은 바이트

        left = n;

        while(left > 0){
                if((read_n = read(fd, data, left)) < 0){
                        if(left == n) return -1;
                        else break;
                }else if(read_n == 0) break;
                left -= read_n; //얼마나 남았는지 갱신
                data += read_n; //남은 바이트 읽기 위해 포인터 이동
        }

        return n-left;
}

 

readn 함수를 보면 while문을 통해서 계속 다 읽을때까지 read를 호출하는 것을 볼 수 있습니다. read가 0을 반환하면 다 읽었다고 판단하여 while 루프를 종료하고 빠져나오면 됩니다.

 

writen 함수

ssize_t writen(int fd, const void *data, size_t n){
        size_t left;    //쓰기까지 남은 바이트
        ssize_t written_n;      //쓴 바이트

        left = n;

        while(left > 0){
                if((written_n = write(fd, data, left)) <0){
                        if(left == n) return -1;
                        else break;
                }else if(written_n == 0) break;
                left -= written_n;      //얼마나 남았는지 갱신
                data += written_n;      //남은 바이트 쓰기 위해 포인터 이동
        }

        return n-left;
}

 

writen 함수 역시 계속 data를 쓸때까지 while 루프로 계속 write를 호출하는 것을 볼 수 있습니다. write가 0을 반환하게 되면 다 썼다는 의미로 반복문을 빠져나오고 writen 함수가 종료됩니다.

 

readn, writen 함수는 read, write함수와 동일하게 사용이 가능합니다. 이 함수들은 socket과 같은 네트워크, 파이프, FIFO 등에서 대량의 바이트를 읽거나 쓰기위한 함수라는 것을 기억하시기 바랍니다. 일반 파일 IO에서는 read, write만 사용해도 무관합니다.

반응형
블로그 이미지

REAKWON

와나진짜

,

리눅스 네트워크 프로그래밍에 관한 더 많은 정보와 예제를 담은 리눅스 교재를 배포했습니다. 아래의 페이지에서 리눅스 교재를 받아가세요.

https://reakwon.tistory.com/233

 

리눅스 프로그래밍 note 배포

티스토리에 리눅스에 관한 내용을 두서없이 여지껏 포스팅했었데요. 저도 제 포스팅을 찾기가 어렵기도 하고 티스토리에서 코드삽입을 하게 되면 이게 일자로 쭉 쓰여져있는 x같은 현상이 생겨

reakwon.tistory.com

 

netstat

네트워크의 connection, routing table, interface 통계 등 네트워크 전반의 정보들을 나타내어주는 명령어입니다. netstat 명령어를 사용함으로써 시스템의 port들이 어떤 상태인지를 확인할 수 있게 됩니다. 예를 들어 현재 서버에서 socket이 열려서 client의 연결을 대기 중인 상태라면 listen 상태가 됩니다. 

netstat을 어떻게 사용하는 지 알아봅시다.

기본적으로 netstat만을 사용하면 열린 모든 socket들에 대해서 보여줍니다. 그런데 기본적으로 LISTENING 상태는 보여주지 않습니다. LISTENING 상태의 socket을 함께 보고싶으시면 아래의 설명할 -a, 혹은 -l 옵션을 지정해주어야합니다.

 

※  여기서 Active Internet connections, Active UNIX domain sockets라고 하여서 약간 다르게 나타나는게 보이시죠? Internet connections는 여러분이 알고 있는 네트워크 상의 connection을 의미하지만, UNIX Domain Sockets(UDS라고도 합니다.)은 시스템 내부에서 사용하는 socket으로 인터넷을 사용하지 않고 통신하기 위한 IPC 기법입니다. socket 파일을 통해서 통신합니다. ls -l 명령을 입력했을때 앞에 s가 바로 그 socket 파일입니다. 복잡한 네트워크를 사용하지 않기 때문에 아래에서 보겠지만 State가 Internet connections보다는 간단합니다. 함수는 인터넷 socket과 동일하게 사용합니다. 

 

netstat를 그냥 사용하면 정신없을 수도 있으니까 아래의 option들을 적절히 이용해서 사용하도록 합시다.

옵션 설명
-l Listening 중인 socket을 표시합니다.
-p socket을 사용하는 pid와 program 이름을 보여줍니다.
-n 주소등을 number로 표시합니다(ex localhost를 127.0.0.1 로 표현)
-i interface의 정보를 보여줍니다.
-t tcp 사용 socket을 보여줍니다.
-u udp 사용 socket을 보여줍니다.
-r routing table을 보여줍니다.
-a listening과 non-listening 상태 모두를 보여줍니다.
-c 매 초마다 명령을 계속적으로 실행합니다.

 

netstat -nltp : listen 중인 tcp를 사용하는 socket을 표시하는데, 그 socket을 사용하는 프로그램도 같이 표시. 주소를 숫자로 표현 

 

netstat -nltp | grep port 번호 : 특정 port가 어떤 상태인지 알아보려면 grep을 이용해서 찾을 수 있습니다.

 

netstat -r : 라우팅 테이블의 정보를 확인할 수 있습니다.

 

 

State

netstat을 사용하면 State라는 socket의 상태를 볼 수 있는데, Internet connection과 UDS를 아래의 표로 정리하였습니다.

- Internet 

State 설명
ESTABLISHED socket이 연결이 성립된 상태입니다.
SYN_SENT socket이 syn 패킷을 보냈으며 연결을 시도하려고 하는 상태입니다.
SYN_RECV socket이 연결 요청을 받은 상태입니다.
FIN_WAIT1 socket이 닫혔고, 연결이 해제되고 있는 상태입니다.
FIN_WAIT2 연결이 닫혔으며, socket은 remote end로부터 shutdown을 기다리고 있는 상태입니다.
TIME_WAIT close 이후 socket이 여전히 네트워크에 남아있는 패킷을 처리하기 위해  대기 중인 상태입니다. 일정시간이 지난 후 이 상태는 사라집니다.
CLOSE socket이 사용중이지 않는 상태입니다.
CLOSE_WAIT remote end가 연결을 해제하였고, 이 컴퓨터의 socket이 닫히기를 기다리고 있는 상태입니다. 
LAST_ACK remote end에서 shut down되었고, socket이 닫힌 상태입니다. 하지만 최종 ack 응답은 기다리는 상태입니다.
LISTEN socket이 연결을 위해서 listening 중인 상태입니다. 
CLOSING 양쪽 모두 socket이 닫혔지만, 페킷을 완전히 못받은 상태입니다, 즉, 페킷이 유실되었다는 의미입니다.
UNKNOWN 어떠한 이유에서 socket의 상태를 알수가 없는 상태입니다.

 

모두 알필요는 없으며, LISTEN, ESTABLISHED, WAIT과 관련된 것만 봐도 상관없을 것 같네요.

 

- Unix Domain Socket(UDS)

State 설명
FREE socket이 할당되지 않았습니다.
LISTENING connection을 대기하고 있습니다.  internet의 LISTENING과 같습니다.
CONNECTING connection을 막 하고 있는 상태입니다.
CONNECTED 연결이 된 상태입니다. internet의 ESTABLISHED 상태와 같습니다.
DISCONNECTING socket이 연결 해제 중입니다.
(empty) socket이 연결되지 않은 상태입니다.
UNKNOWN 절대로 발생할 수 없는 상태입니다. 

 

하지만 netstat은 오래된 프로그램이라서 ss 명령어로 대체가 되었습니다. 나중에 시간이 있으면 ss 명령어에 대해서 포스팅하도록 하겠습니다.

반응형
블로그 이미지

REAKWON

와나진짜

,

segmentation fault (core dumped)

이런 무시무시한 문구가 떴는데, 눈을 씻고 찾아봐도 coredump 파일을 찾을 수가 없었습니다. 분명 메시지는 coredump 파일 생성됐다고 써있는데 말이죠... 내눈이 잘못된건가, 아니면 내가 영어를 못하는건가.. 

그래서 제가 찾은 coredump를 찾는 몇가지 해결 방법을 알려드리도록 할게요. 

1. ulimit으로 core dump size를 확인

아래와 같은 명령어로 core file size를 확인합니다. 

# ulimit -a

 

0 이상이어야합니다. 그러니까 이 부분을 고쳐하겠죠. 0보다 크면 되긴하지만, unlimited로 바꿔보도록 합시다. 

# ulimit -c unlimited

 

 

위처럼 unlimited로 바뀐것을 알 수 있습니다. 이제 프로그램을 실행시키면 coredump 파일이 생성될 수도 있습니다. 물론 저처럼 두번째 문제가 있을때는 coredump 파일이 생성되지 않을 수도 있으니, 2번까지 확인해보세요.

한가지 더, ulimit으로 설정한 core dump size는 일시적입니다. 즉, reboot은 당연하고 세션이 끊어지면 초기화된다는 것이죠. 터미널 접속시 바로 설정되도록 적용하려면 아래와 같이 /etc/security/limites.conf 파일을 설정하시면 됩니다. 

# vi /etc/security/limits.conf

맨 아래에 아래와 같이 추가하여 저장하시면 반영구적으로 적용됩니다.

 

 

2. /proc/sys/kernel/core_pattern 편집하여 현재 디렉토리에 coredump 생성

원래 coredump 파일을 프로그램 실행 위치에 생성되는 것으로 알고 있는데, 저의 경우에는 그게 아니었습니다. 도대체 왜 나만 안되는거야 이러고 있을 때 google 형님께 여쭈어본 결과 /proc/sys/kernel/core_pattern에서 설정할수 있다고 하십니다. 이 파일이 coredump 파일을 어떻게 생성하는지 정의하고 있는데, 열어보면 어떤 이상한 경로로 되어있을 가능성이 있습니다. 저는 과감하게 바꿔줬습니다. 

# echo "core.%e.%p" > /proc/sys/kernel/core_pattern

 

%e와 %p는 format문자로 저도 모릅니다. google형님이 알려준대로 썼으니까요. 이제 바꿔주고 coredump되는 실행파일을 실행시켜주면 그 디렉토리에 coredump 파일이 뜨게 됩니다.

 

core 덤프 파일이름을 보면 %e는 프로그램 이름, %p는 pid인 듯 보이네요.

 

여러분도 저처럼 삽질에 시간쓰지 마시라고 공유합니다. 그럼 이만 포스팅 마칩니다~

반응형
블로그 이미지

REAKWON

와나진짜

,

poll, select, epoll관 관련한 다중 입출력의 내용과 더 많은 정보와 예제를 담은 리눅스 교재를 배포했습니다. 아래의 페이지에서 리눅스 교재를 받아가세요.

https://reakwon.tistory.com/233

 

리눅스 프로그래밍 note 배포

티스토리에 리눅스에 관한 내용을 두서없이 여지껏 포스팅했었데요. 저도 제 포스팅을 찾기가 어렵기도 하고 티스토리에서 코드삽입을 하게 되면 이게 일자로 쭉 쓰여져있는 x같은 현상이 생겨

reakwon.tistory.com

 

poll

select와 비슷한 함수입니다. 여러 file descriptor에 대해서 I/O를 수행하기 위한 준비가 될 때까지 기다리는 함수입니다. 여러 file descriptor를 감시하여 event가 발생할 때까지 기다린다고 보시면 됩니다.

예를 들어서 어떠한 서버가 여러 클라이언트에 대해서 연결을 갖게 되고, 입력을 처리하여야한다면 어떻게 해야할까요? 한가지 방법으로는 클라이언트 요청이 들어오면 쓰레드를 만들어서 따로 처리해줄 수 있죠. 그런데 이때 한계가 있습니다. 클라이언트의 요청이 많아질 경우에는 쓰레드를 그만큼 생성해야하는 문제가 있죠. 만약 client가 100개가 현재 연결되어 있는 서버에서는 100개의 쓰레드를 생성할 수는 없겠죠. 이보다는 100개의 socket에 대해서 지켜보다가 하나의 socket에 읽을 데이터가 생겼다면 그 socket에서 read를 하고 처리를 하면 되는 것이죠.

이 목적을 달성할 수 있는 함수가 poll입니다. poll은 여러 file descriptor에 대해서 이벤트가 발생하기를 기다렸다가, event가 발생하면 그에 대한 정보를 제공해줍니다. select와는 비슷한데, 더 섬세하게 다룰 수 있습니다. 먼저 함수의 원형을 봅시다.

 

함수 설명

int poll(struct pollfd *fds, nfds_t nfds, int timeout);

 - fds : pollfd의 구조체 포인터입니다. pollfd는 아래와 같이 선언되어 있습니다. 

struct pollfd {
   int   fd;         /* file descriptor */
   short events;     /* requested events */
   short revents;    /* returned events */
};

        fd : 점검할 file descriptor입니다. 

         events : fd에 대해서 주시할 event입니다. 이 event들은 OR(|)로 여러 가지를 줄 수 있습니다. event에 대해서는 아래 표에 설명해놓았습니다. 사용자가 설정합니다.

         revents : fd에 발생한 event를 의미합니다. 이는 사용자가 설정하는게 아니라 kernel이 설정해줍니다. 이 revents를 보고 어떤 event가 발생했는지 확인할 수 있습니다.

아래의 표를 보면 revents에는 모든 event가 설정이 되어질 수 있습니다. 하지만 events에는 아래의 3개는 설정할 수 없죠.

 

event 이름 event에 설정 가능 kernel이 revents에 설정 설명
POLLIN O O high priority 외의 자료를 바로 읽을 수 있음
(POLLRDNORM | POLLRDBAND와 동일)
POLLRDNORM O O 보통 자료를 바로 읽을 수 있음
POLLRDBAND O O 우선 순위 자료를 바로 읽을 수 있음
POLLPRI O O high priority 자료를 바로 읽을 수 있음
POLLOUT O O 보통의 자료를 쓸 수 있음
POLLWRNORM O O 보통의 자료를 쓸 수 있음
POLLWRBAND O O 우선 순위 자료를 바로 기록 할 수 있음
POLLERR   O 오류 발생
POLLHUP   O 연결 끊어짐
POLLNVAL   O fd가 열린 파일이 아님

 

- nfds : fds 배열의 크기를 의미합니다.

- timeout : poll이 대기할 시간을 설정할 수 있습니다. 여기서 단위는 ms이므로 1초만 대기하려면 timeout은 1000값이 되어야합니다. 이외에 0이거나 -1인 경우는 아래와 같습니다.

timeout == -1 : 무한정 기다립니다.

timeout == 0 : 전혀 기다리지 않습니다.

 

이를 이용해서 지난 select와 같은 역할을 하는 서버를 만들어보도록 합시다. 역시 네트워크에 대한 내용은 뺐습니다. 순수하게 poll이 어떻게 동작하는지만 확인할 것입니다. 그런데 한가지 알아두셔야할 것은 select와 마찬가지로 정규 파일에 대해서 사용하는 것은 적절하지 않다는 점은 알아두셔야합니다.  

//multiIO_poll.c 

#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <fcntl.h>
#include <poll.h>

#define FD_SIZE 3
#define BUF_SIZE 128

int main(int argc, char *argv[]){
        char buf[BUF_SIZE];
        struct pollfd fdarr[FD_SIZE];
        int n, i, ret, end_count = 0;

        //3개의 파일의 이름을 받는다.
        if(argc != 4){
                printf("usage : %s file1 file2 file3\n", argv[0]);
                return 0;
        }


        for(i = 0; i < FD_SIZE; i++){
                int fd = open(argv[i+1],O_RDONLY);
                if(fd >= 0){
                        fdarr[i].fd = fd;
                        //차단없이 읽는 것을 주시할 event로 넣는다.
                        fdarr[i].events = POLLIN;
                }
        }

        while(1){

                memset(buf, 0x00, BUF_SIZE);

                // timeout == -1은 지정된 파일 서술자중
                // 하나라도 준비될때까지 무한정 기다린다.
                ret = poll(fdarr, FD_SIZE, -1);

                if(ret == -1){
                        perror("poll error ");
                        exit(0);
                }

                for(i = 0; i < FD_SIZE; i++){
                        //파일 디스크립터가 -1이면 볼 필요 없음.
                        //받은 이벤트인 revents에 POLLIN이 있다면
                        if(fdarr[i].fd != -1 && fdarr[i].revents & POLLIN){
                                while((n = read(fdarr[i].fd, buf, BUF_SIZE)) > 0){

                                        //quit가 들어오면 fdarr[i] read 종료
                                        if(!strcmp(buf,"quit\n")){

                                                //파일디스크립터 close
                                                close(fdarr[i].fd);
                                                //안쓰는 fd로 업데이트하기 위해 -1 지정
                                                fdarr[i].fd = -1;
                                                end_count++;
                                                if(end_count == FD_SIZE) 
                                                        exit(0);
                                                continue;
                                        }

                                        printf("fd[%d] - %s",fdarr[i].fd, buf);
                                }
                        }
                }

        }
        return 0;
}

 

역시 테스트하기 위해서는 클라이언트 프로그램이 필요합니다. 여기서는 select에서 설명했던 클라이언트 역할을 할  소스 코드 fwrite.c를 그대로 사용합니다.

https://reakwon.tistory.com/117

 

[리눅스] 다중입출력 - select개념과 설명과 예제

다중입출력 아래와 같은 상황을 생각해볼까요? 어떤 프로세스가 다음과 같이 파일 3개를 처리하는데 그 중 입력이 있는 파일을 프로세스에 처리하는 상황을 어떻게 구현할 수 있을까요? 이때 우

reakwon.tistory.com

역시 테스트 하기 위해서는 a, b, c라는 파일 3개를 새로 만들고 시작합시다. 그리고 fwrite.c와 multiIO_poll.c는 아래와 같이 컴파일 하시구요. 

# gcc multiIO_poll.c 
# gcc fwrite.c -o fwrite

 

자, 테스트할 준비는 이제 완료되었고, 아래와 같은 결과를 보입니다. 

./a.out a b c
# ./a.out a b c
fd[3] - hello, ifd[3] - 'm writifd[3] - ng file fd[3] - a
fd[4] - hello, ifd[4] - 'm writifd[4] - ng file fd[4] - b~~
fd[5] - hello, ifd[5] - 'm writifd[5] - ng file fd[5] - c..
fd[3] - bye pollfd[3] - 
fd[4] - bye! 
fd[5] - i have tfd[5] - o go nowfd[5] -
./fwrite a ./fwrite b ./fwrite c
# ./fwrite a
hello, i'm writing file a
bye poll
quit
# ./fwrite b
hello, i'm writing file b~~
bye! 
quit 
# ./fwrite c
hello, i'm writing file c..
i have to go now 
quit 

 

역시나 poll은 정규 파일에 대해서 항상 준비되어있다고 판단하기 때문에 루프에다가 로그 printf를 찍어보면 엄청나게 바쁜 루프를 도는 것을 확인할 수 있습니다. 

반응형
블로그 이미지

REAKWON

와나진짜

,

systemd 뿐만 아니라 데몬의 특징을 담은 더 많은 정보와 예제를 담은 리눅스 교재를 배포했습니다. 아래의 페이지에서 리눅스 교재를 받아가세요.

https://reakwon.tistory.com/233

 

리눅스 프로그래밍 note 배포

티스토리에 리눅스에 관한 내용을 두서없이 여지껏 포스팅했었데요. 저도 제 포스팅을 찾기가 어렵기도 하고 티스토리에서 코드삽입을 하게 되면 이게 일자로 쭉 쓰여져있는 x같은 현상이 생겨

reakwon.tistory.com

 

systemd

systemd에서 끝 d는 daemon을 의미합니다. deamon은 background에서 실행이 되는  프로세스입니다. 그러한 deamon을 실행하고 관리하게 해주는 daemon이 바로 systemd입니다. systemd는 부팅하고나서 가장 먼저 실행되는 데몬입니다. 

이전에는 init이라는 데몬이 있었는데 이를 대체하고 init보다 기능이 추가되어서 나온 것이 systemd입니다. 그래서 이전의 init과 같이 PID가 1이 됩니다. 부모프로세스가 없으므로 PPID 또한 1이 됩니다. 

systemd는 리소스를 unit이라고 불리는 단위로 관리합니다. 어떤 type의 unit이 있을까요? 아래의 표로 정리하였습니다. 

.service .socket .device .mount .automount .swap .target .path .timer
.snapshot .slice .scope            

 

 - 여기서는 .service만 설명합니다. 가장 많이 쓰니까요~ .service에서는 service나 application을 서버상에서 어떻게 관리할지를 명세합니다. service의 시작, 중지, 그리고 어떠한 상황에서 자동적으로 실행하는지, 어떠한 종속성을 가지고 있는지에 대한 정보를 갖고 있습니다.

만약 .service를 추가하려면 /etc/systemd/system 디렉토리에 끝 확장자로 .유닛타입 식으로 써주면 됩니다. service의 경우에는 끝 확장자가 .service가 됩니다. 그리고 시스템은 일반적으로 unit file들을 /lib/systemd/system 하위에 복사하여 유지합니다. 여기서 아주 간단한 service를 등록하고 실행하는 방법을 알아보도록 하겠습니다. 

 

1. 실행 파일 생성

사용할 실행 파일(myservice.c)

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>
#include <unistd.h>

int main(){
        int fd;
        char buf[64] = "myservice start!\n";

        fd = open("/tmp/log.txt",O_CREAT|O_WRONLY|O_TRUNC,0644);
        //열기 실패시
        if(fd<0) return -1;

        write(fd, buf, strlen(buf));

        while(1){
                //계속 running되게 하기 위해 무한 loop
                sleep(1);
        }
        close(fd);
        return 0;

}

위 소스코드로 컴파일하여 아래의 실행 파일로 만들어보도록 하겠습니다. 권한 문제가 생길까봐 777을 부여했습니다.

# gcc myservice.c -o myservice
# chmod 777 myservice

 

2. Unit 파일 생성

우리는 service를 생성할 것이기 때문에 /etc/systemd/system 하위에 myservice.service 파일을 생성하도록 하겠습니다. 

[Unit]
Description=test service

[Service]
ExecStart=/home/ubuntu/systemd/myservice

[Install]
WantedBy=multi-user.target

 

2.1 Unit Section

보통 가장 처음 등작하는 Section입니다. 여기서는 유닛에 대한 meta data와 다른 유닛간의 관계를 설정하는 곳입니다. 

Description : 이 Unit에 대한 설명을 뜻합니다. 짧고, 간략하지만 핵심 정보를 담고 있도록 설명하는 곳입니다.

Documentation : 이 서비스에 대한 문서가 있는 URI를 제공합니다. man 페이지나 웹 사이트가 될 수 있습니다. 이런 정보들은 systemctl status 명령어에서 노출됩니다.

After : 이 Unit보다 먼저 실행되어야할 Unit들을 나열합니다.

Before : 이 Unit보다 늦게 실행되어야할 Unit들을 나열합니다. 

Requires : 이 Unit이 의존하는 모든 Unit을 나열합니다. 여기서 나열된 Unit들은 전부 성공적으로 실행이 되고 있어야합니다.

Wants : Requires와 유사합니다만, Requires보다는 그렇게 엄격하지 않습니다. 다른 Unit이 실패하더라도 지금 Unit을 실행합니다.

BindsTo : Requires와 유사합니다. 대신 연관된 유닛이 종료되면 같이 service가 종료됩니다.

 

2.2 Service Section 

Service Section은 서비스에만 적용할 수 있는 특징을 정의합니다. Unit에는 여러 종류가 있다고 위에서 표로 정의해놓았죠? mount도 있고, swap도 있고... 그중 Service에만 적용하는 구성입니다.

Type : service가 어떤 형태로 동작이 되는지를 설정합니다. systemd에게 이 service가 어떻게 관리되고 상태를 탐지하는지 알려주는 지시자입니다. 아래 중 하나로 동작이 됩니다. 

  ● simple : 명시하지 않을 경우 simple로 동작합니다. ExecStart는 설정이 되어 있어야합니다. 

  ● forking : service가 자식 프로세스를 생성할때 사용합니다. 이때 자식을 생성한 프로세스는 곧 장 나갈때 사용됩니다.

  ● oneshot : 프로세스가 오래 실행되지 않을때 systemd가 이 service가 종료되기를 기다려야할때 이 값을 사용할 수 있습  니다. service가 종료된 후 systemd가 진행을 계속하게 됩니다.

  ● dbus : 지정된 Bus Name이 D-Bus에 준비될때까지 기다리고, D-Bus가 준비되면 service가 실행됩니다.

  ● notify : service가 startup이 끝날때 notification(signal)을 발생시킵니다. 이런 상황이 발생할때 systemd는 다음 unit으로 넘어갑니다. 

  ● idle :  모든 작업이 실행될때까지 서비스가 실행이 되지 않습니다. 즉, 모든 작업이 실행되어서야 실행됩니다.

ExecStart : 실행할 command의 절대경로를 지정합니다.  

ExecStartPre : 서비스가 실행하기 전의 command를 지정합니다. 서비스 시작전 명령어를 실행합니다.

ExecStartPost : 서비스를 시작하고 나서의 command를 지정합니다. 서비서 시작 후에 명령어를 실행하기 됩니다.

ExecStop : 서비스가 stop될때 실행되어야할 command를 정합니다. 

Restart : systemd가 자동으로 재시작하려고 시도하는 상황을 정의합니다. alway, on-success, on-failure, on-abnormal, on-abort, on-watchdog를 사용할 수 있습니다. 

TimeoutSec : systemd가 service가 실행할때까지 기다리는 시간을 의미합니다. service를 stop할때까지 기다리는 시간이라고도 말할 수 있겠네요.

FailureAction : service 실패시 어떤 동작할 할지를 정의합니다. none, reboot, reboot-force, reboot-immediate, poweroff, poweroff-force, poweroff-immediate, exit, exit-force 중 하나를 사용합니다.

User : service가 실행될때 어떠한 권한으로 실행이 되는지를 설정합니다. user 이름이 될 수 있고, user id로 설정할 수도 있습니다. 그러나 user 이름이 알아보기 좋겠죠? 

Group : User와 마찬가지로 service가 실행될때 가지는 그룹 권한을 설정합니다. 

 

2.3 Install Section

보통 파일의 마지막에 존재합니다. 이 Section은 optional입니다. Unit이 enable하거나 disable 될때 Unit의 행동을 정의합니다.

WantedBy : 어떻게 Unit이 활성화(enable)되는지 명세합니다. 

Also : service가 enable, disable될때 집합 단위로 같이 enable, disable할 serivce들을 의미합니다.

Alias : 이 service의 별칭을 줍니다. 

 

3. service 실행, 상태, 종료

service 실행 : service를 실행하는 명령어는 아래와 같습니다. 서비스가 새로 추가됐으니, daemon을 다시 load하는 과정도 있어야합니다.

# systemctl daemon-reload
# systemctl start myservice

 

자, 실행이 되었다면 /tmp 하위에 log.txt라는 파일이 생겨나고 파일 내용이 적혀져 있어야합니다. 확인해볼까요? 

# cat /tmp/log.txt
myservice start!

 

위처럼 파일이 생겼으며 내용도 채워져있음을 확인했습니다. 그리고 현재 데몬이 실행되고 있는지 확인해봅시다. 

# ps -ef | grep myservice
root       42450       1  0 19:51 ?        00:00:00 /home/ubuntu/systemd/myservice

 

위와 같이 PID가 42450인 프로세스가 있는 것을 확인했습니다. 부모 PID는 1입니다. 시스템 데몬이라는 것을 알 수 있죠?

 

service 상태 확인 : service의 상태가 어떤지 보고 싶다면 status를 옵션으로 주면 됩니다. 4번째줄에 active로 실행중인 상태를 확인할 수 있습니다.

# systemctl status myservice
● myservice.service - test service
     Loaded: loaded (/etc/systemd/system/myservice.service; static; vendor preset: enabled)
     Active: active (running) since Mon 2022-06-27 19:45:00 KST; 51s ago
   Main PID: 42434 (myservice)
      Tasks: 1 (limit: 2295)
     Memory: 140.0K
     CGroup: /system.slice/myservice.service
             └─42434 /home/ubuntu/systemd/myservice

 6월 27 19:45:00 ubuntu-VirtualBox systemd[1]: Started test service.

 

service 종료 : service를 종료하고 싶다면 stop을 옵션으로 주면 됩니다.

# systemctl stop myservice
# systemctl status myservice
● myservice.service - test service
     Loaded: loaded (/etc/systemd/system/myservice.service; static; vendor preset: enabled)
     Active: inactive (dead)

 

service 재시작 : stop과 start를 하면 재시작이 되죠. 한번에 할 수도 있습니다.

# systemctl restart myservice

 

service 부팅시 시작, 해제 : 이 서비스를 부팅시에 자동으로 실행하게 만들 수 있습니다. 단, Install Section을 정의해놔야합니다. 반대로 부팅시 시작 해제하려면 disable을 사용하면 됩니다. 

# systemctl enable myservice
# systemctl disable myservice

 

기본적으로 systemd에 service를 등록하고 실행하는 방법을 알아보았습니다. 이 밖에도 훨씬 많은 내용이 존재하여 이 포스팅에 전부 담아낼 수가 없습니다. 그래서 아래의 페이지에서 필요할때 찾아서 적용하시면 되겠습니다.

https://www.digitalocean.com/community/tutorials/understanding-systemd-units-and-unit-files#install-section-directives

 

 

Understanding Systemd Units and Unit Files | DigitalOcean

 

www.digitalocean.com

 

https://www.freedesktop.org/software/systemd/man/systemd.directives.html

 

systemd.directives

Name systemd.directives — Index of configuration directives Unit directives Directives for configuring units, used in unit files....

www.freedesktop.org

 

반응형
블로그 이미지

REAKWON

와나진짜

,

tar

tar 명령어는 Tape Archiver의 약자로 여러 파일들을 하나의 파일로 묶어주는 명령어입니다. tar 명령어에 대해서 압축 명령어로 오해하시는 분들이 많은데, tar는 단순 파일을 하나로 묶는 명령입니다. 하지만 여러 옵션을 주어서 압축까지하는 것이 가능합니다. 예를 들어서 아래의 그림은 gzip이라는 압축 방식을 사용한 과정입니다. 아래의 그림을 보시면 쉽게 이해가 가능합니다.

file 1부터 file n까지가 있다면 tar 명령어를 통해서 하나의 files.tar 파일(확장자 .tar는 tar로 묶었음을 알리는 확장자입니다.)로 묶을 수 있습니다. 이때 압축한 상태가 되지는 않지요. 만일 압축방식의 하나인 gzip압축을 거치게 된다면 files.tar.gz(확장자 .gz은 gzip으로 압축이 되었다는 것을 알려주는 확장자입니다.)이라는 하나의 압축파일이 나올 수 있습니다. 그러니 ~.tar.gz은 tar로 파일들을 일단 하나의 파일로 묶고 나서 gzip 방식으로 압축을 한 파일이라는 것을 알 수 있겠죠.

그리고 압축을 해제할때는 이 과정의 역순을 거치게 됩니다. 

tar의 명령어 옵션은 너무 많아 포스팅에 전부 담을 수 없습니다. 주요한 옵션 몇가지만 보고 사용해도 문제없습니다. 

option 설명
-c(create) 파일 합치기
-v(verbose) tar의 과정을 보여주기, 굳이 사용하지 않아도 무방합니다.
-f(file) tar 아카이브 지정, 즉 압축 파일명을 지정합니다.
-x(extract) 파일 추출
-z(gzip) gzip 압축. 확장자 gz
-j(bzip2) bzip2 압축. 확장자 bz2
-t(list) 파일의 리스트 확인

 

위의 옵션들을 이용해서 tar로 파일들을 묶고 압축, 혹은 해제하는 방법을 아래의 명령을 통해서 보실 수 있습니다.

 

1. 파일 묶기

$ ls -l
합계 8
-rw-rw-r-- 1 ubuntu ubuntu 6  4월 24 12:33 file1.txt
-rw-rw-r-- 1 ubuntu ubuntu 6  4월 24 12:33 file2.txt
$ tar -cvf files.tar file1.txt file2.txt   <-- files.tar로 묶기
file1.txt
file2.txt
$ ls -l
합계 20
-rw-rw-r-- 1 ubuntu ubuntu     6  4월 24 12:33 file1.txt
-rw-rw-r-- 1 ubuntu ubuntu     6  4월 24 12:33 file2.txt
-rw-rw-r-- 1 ubuntu ubuntu 10240  4월 24 12:46 files.tar

 

 

2. 파일 풀기

$ ls -l
합계 12
-rw-rw-r-- 1 ubuntu ubuntu 10240  4월 24 12:46 files.tar
$ tar -xvf files.tar  <-- files.tar 파일 풀기
file1.txt
file2.txt
$ ls -l
합계 20
-rw-rw-r-- 1 ubuntu ubuntu     6  4월 24 12:33 file1.txt
-rw-rw-r-- 1 ubuntu ubuntu     6  4월 24 12:33 file2.txt
-rw-rw-r-- 1 ubuntu ubuntu 10240  4월 24 12:46 files.tar

 

3. gzip으로 압축

$ ls -l files/
합계 8
-rw-rw-r-- 1 ubuntu ubuntu 6  4월 24 12:33 file1.txt
-rw-rw-r-- 1 ubuntu ubuntu 6  4월 24 12:33 file2.txt
$ tar -cvzf files.tar.gz files <-- gzip 압축
files/
files/file1.txt
files/file2.txt
$ ls -l
합계 8
drwxrwxr-x 2 ubuntu ubuntu 4096  4월 24 12:55 files
-rw-rw-r-- 1 ubuntu ubuntu  185  4월 24 12:56 files.tar.gz

 

그런데 이렇게 명령어 옵션을 섞어서 쓸때 간과하는 점이 있는데 f는 아카이브 파일의 이름을 지정해야하는 옵션입니다. 그러니 -f 뒤에는 파일명이 나와야합니다. 이런 사실을 모르면 아래와 같은 에러 메시지를 볼 수 있게 됩니다.

$ tar -cvfz files.tar.gz files
tar: files.tar.gz: stat할 수 없습니다: 그런 파일이나 디렉터리가 없습니다
files/
files/file1.txt
files/file2.txt
tar: 앞서 발생한 오류로 실패 코드를 반환하며 빠져나감

 

만약 무슨 소리가 뭔지 모르겠다면 f를 항상 마지막에 써주고 파일명을 입력하시면 됩니다. tar -cvzf files.tar.gz files 이렇게요.

 

4. gzip 압축 해제

 

$ ls -l
합계 4
-rw-rw-r-- 1 ubuntu ubuntu 185  4월 24 12:56 files.tar.gz
$ tar -xvzf files.tar.gz <-- gzip 압축 해제
files/
files/file1.txt
files/file2.txt
$ ls -l
합계 8
drwxrwxr-x 2 ubuntu ubuntu 4096  4월 24 12:55 files
-rw-rw-r-- 1 ubuntu ubuntu  185  4월 24 12:56 files.tar.gz
$ ls -l files
합계 8
-rw-rw-r-- 1 ubuntu ubuntu 6  4월 24 12:33 file1.txt
-rw-rw-r-- 1 ubuntu ubuntu 6  4월 24 12:33 file2.txt

 

5. bzip2 압축

$ ls -l files
합계 8
-rw-rw-r-- 1 ubuntu ubuntu 6  4월 24 12:33 file1.txt
-rw-rw-r-- 1 ubuntu ubuntu 6  4월 24 12:33 file2.txt
$ tar -cvjf files.tar.bz2 files <-- bzip2 압축
files/
files/file1.txt
files/file2.txt
$ ls -l
합계 8
drwxrwxr-x 2 ubuntu ubuntu 4096  4월 24 12:55 files
-rw-rw-r-- 1 ubuntu ubuntu  191  4월 24 13:07 files.tar.bz2

 

6. bzip2 압축 해제

$ ls -l
합계 4
-rw-rw-r-- 1 ubuntu ubuntu 191  4월 24 13:07 files.tar.bz2
$ tar -xvjf files.tar.bz2
files/
files/file1.txt
files/file2.txt

 

7. 파일의 contents(list) 확인

$ ls
files.tar.bz2
$ tar -tf files.tar.bz2 <-- files.ar.bz2 안의 파일 확인, 압축 해제한것이 아님
files/
files/file1.txt
files/file2.txt
$ ls  
files.tar.bz2

 

여기까지만 알아도 tar을 통해서 압축하고 해제하는 데에는 아무 문제없습니다. 너무 쉽죠?

반응형
블로그 이미지

REAKWON

와나진짜

,