File i/o
๐File i/o
ํ์ผ์ ์ด๊ณ , ์์ฑํ๊ณ , ์ฝ๊ณ , ์ฐ๊ณ , ๋ซ๋ ๊ณผ์
nano openfile.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include <stdio.h> // ํ์ค ์
๋ ฅ ๋ฐ ์ถ๋ ฅ ํจ์๋ฅผ ์ ๊ณต
#include <stdlib.h> // ์ผ๋ฐ์ ์ธ ์ ํธ๋ฆฌํฐ ํจ์๋ค์ ์ ๊ณต
#include <fcntl.h> // ํ์ผ ์ ์ด ๊ด๋ จ ์์๋ค๊ณผ ํ์ผ ์ ์ด ํจ์๋ค์ ์ ์
#include <unistd.h> // Unix ํ์ค ํจ์๋ค์ ์ ๊ณต
#include <string.h> // ๋ฌธ์์ด ๊ด๋ จ ํจ์๋ค์ ์ ๊ณต
int main() {
const char *path = "example.txt"; // ํ์ผ์ ๊ฒฝ๋ก๋ฅผ path์ ์ ์ฅํ๋ค
// ํ์ผ ์ด๊ธฐ ์๋ : ์ฝ๊ธฐ&์ฐ๊ธฐ ๊ถํ์ผ๋ก ์ด๊ณ , ํ์ผ์ด ์์ ๊ฒฝ์ฐ ์์ฑ, ์์ ์์ ๋ํ ์ฝ๊ธฐ&์ฐ๊ธฐ ๊ถํ ์ค์
int file_descriptor = open(path, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
if (file_descriptor == -1) { // ์คํจํ ๊ฒฝ์ฐ -1 ๋ฐํ
perror("open");
exit(EXIT_FAILURE); // exit(0)์ ์ ์์ ์ข
๋ฃ, exit(EXIT_FAILURE)์ ์ค๋ฅ๋ก ์ข
๋ฃ
}
// ํ์ผ์ ์ฐ๊ธฐ
char *message = "Hello, Unix!";
write(file_descriptor, message, strlen(message)); // ๋ฌธ์์ด์ ํ์ผ์ ์ฐ๊ธฐ
// ํ์ผ์์ ์ฝ๊ธฐ
char buffer[100]; // ๋ฌธ์ ๋ฐฐ์ด ์ ์ธ
lseek(file_descriptor, 0, SEEK_SET); // ํ์ผ ํฌ์ธํฐ๋ฅผ ํ์ผ ์์์ผ๋ก ์ด๋
read(file_descriptor, buffer, 100); // ์ต๋ 100๋ฐ์ดํธ๊น์ง ์ฝ๊ธฐ
printf("Read from file: %s\n", buffer); // ์ฝ์ด์จ ๋ฐ์ดํฐ ์ถ๋ ฅ
// ํ์ผ ๋ซ๊ธฐ
close(file_descriptor);
return 0;
}
gcc -o openfile openfile.c
./openfile
์ถ๊ฐ ์ค๋ช
const char *path = "example.txt";
ํ์ผ์ ๊ฒฝ๋ก, ์ฆ โexample.txtโ ๋ฌธ์์ด์ ์์ ์ฃผ์๋ฅผ path์ ์ ์ฅํ๋ค.
open()
open(์ด๋ ค๋ ํ์ผ์ ๊ฒฝ๋ก ๋๋ ์ด๋ฆ, ํ์ผ์ ์ด๋ป๊ฒ ์ด์ง๋ฅผ ์ง์ ํ๋ ํ๋๊ทธ, ํ์ผ์ ์์ฑํ ๋๋ง ์ฌ์ฉ)
- O_RDONLY: ์ฝ๊ธฐ ์ ์ฉ์ผ๋ก ํ์ผ ์ด๊ธฐ.
- O_WRONLY: ์ฐ๊ธฐ ์ ์ฉ์ผ๋ก ํ์ผ ์ด๊ธฐ.
- O_RDWR: ์ฝ๊ธฐ/์ฐ๊ธฐ ๋ชจ๋๋ก ํ์ผ ์ด๊ธฐ.
- O_CREAT: ํ์ผ์ด ์กด์ฌํ์ง ์์ผ๋ฉด ์๋ก ์์ฑ.
- O_APPEND: ํ์ผ ๋์ ์ฐ๊ธฐ ์ํด ํ์ผ ํฌ์ธํฐ๋ฅผ ์ด๋.
- O_TRUNC: ํ์ผ์ด ์ด๋ฏธ ์กด์ฌํ๋ฉด ํ์ผ ํฌ๊ธฐ๋ฅผ 0์ผ๋ก ์๋ผ๋ด๊ธฐ.
char *message = "Hello, Unix!"
โHello, Unix!โ๋ผ๋ ๋ฌธ์์ด์ ์ฃผ์๋ฅผ message์ ์ ์ฅํ๋ค.
write()
write(๋ฐ์ดํฐ๋ฅผ ์ธ file descriptor, ์ธ ๋ฐ์ดํฐ๊ฐ ๋ด๊ธด ๋ฒํผ์ ํฌ์ธํฐ, ์ธ ๋ฐ์ดํฐ์ ํฌ๊ธฐ (๋ฐ์ดํธ ๋จ์))
-> ๊ฒฐ๊ณผ๊ฐ์ ๋ฐ์ดํฐ์ ํฌ๊ธฐ๊ฐ ์ถ๋ ฅ๋๋ค.
lseek()
lseek(file descriptor, offset, whence) : ์๋ก์ด ํ์ผ ํฌ์ธํฐ์ ์์น๋ฅผ ๋ฐํ
- offset: ์คํ์ ๊ฐ. ์ด ๊ฐ์ ๊ธฐ์ค์ผ๋ก ํ์ผ ํฌ์ธํฐ์ ์์น๊ฐ ๋ณ๊ฒฝ
- whence: ํ์ผ ํฌ์ธํฐ๋ฅผ ๋ณ๊ฒฝํ๋ ๊ธฐ์ค
- SEEK_SET: ํ์ผ์ ์์์ ๊ธฐ์ค์ผ๋ก ์คํ์ ์ ์ค์
- SEEK_CUR: ํ์ฌ ํ์ผ ํฌ์ธํฐ ์์น๋ฅผ ๊ธฐ์ค์ผ๋ก ์คํ์ ์ ์ค์
- SEEK_END: ํ์ผ์ ๋์ ๊ธฐ์ค์ผ๋ก ์คํ์ ์ ์ค์
read()
read(file descriptor, ์ฝ์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ ๋ฒํผ์ ํฌ์ธํฐ, ์ฝ์ ๋ฐ์ดํฐ์ ํฌ๊ธฐ(๋ฐ์ดํธ ๋จ์))
๋ณต์ตํ๋ฉฐ ์๊ฒ๋ ๊ฒ๋ค.
file์ด open์ด๋ creat๋ก file descriptor๊ฐ ์๋ก ํ ๋น๋๊ณ , read๋ writeํ ๋ ์ด๋ฅผ ์ด์ฉํ๋ค. ์ด๋, user๊ฐ ์์ฑํ๋ ์ฒซ ๋ฒ์งธ ํ์ผ์ file descriptor๋ 3์ด ๋๋๋ฐ, ๊ทธ ์ด์ ๋ ๊ธฐ๋ณธ ์ธํ ์ผ๋ก
- 0 -> ํ์ค ์ ๋ ฅ (stdin)
- 1 -> ํ์ค ์ถ๋ ฅ (stdout)
- 2 -> ํ์ค ์ค๋ฅ (stderr)
์ file descriptor๊ฐ ํ ๋น๋์ด์๊ธฐ ๋๋ฌธ์ด๋ค.
๋ฉ๋ชจ๋ฆฌ์์ file descriptor๊ฐ ํ ๋น๋จ์ผ๋ก์จ, ์์คํ ์ ํ์ผ๊ณผ ์ฐ๊ฒฐ๋๋ค.
open()์ flag ์ค์ O_EXCL์ด ๊ต์ฅํ ๋ ํนํ๋ฐ, ํ์ผ์ด ์กด์ฌํ๋ฉด ์๋ฌ๋ฅผ ๋ด๊ณ open์ ์คํจํ๋ฉด์ return๊ฐ์ -1์ด ๋๋ค. ์ด๊ฒ ์กด์ฌํ๋ ์ด์ ๋ ํ์ผ์ด ์ด๋ฏธ ์กด์ฌํ๋ ๊ฒฝ์ฐ์ ์คํจ์ํด์ผ๋ก์จ ํ๋ก๊ทธ๋จ์ ์ ๋ขฐ์ฑ์ ํ๋ณดํ๊ธฐ ์ํจ์ด๋ค. ์๋์ ์ฝ๋๋ฅผ ์๋ก ๋ค ์ ์๋ค.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <stdlib.h>
#define LOCKFILE "lockfile"
#define DELAY 100000000
void delay(void)
{
int i;
for (i=0;i<DELAY;i++);
}
int main(void)
{
int fd, i;
while((fd = open(LOCKFILE, O_WRONLY | O_CREAT | O_EXCL, 0644)) < 0) {
if (errno != EEXIST) { //ํ์ผ์ด ์์์ผ๋ก์จ ๋ฐ์ํ๋ ์ค๋ฅ(EEXIST)๊ฐ ์๋๋ผ๋ฉด,
perror("open");
exit(1); // ์ข
๋ฃ
} // ํ์ง๋ง, ํ์ผ์ด ์์์ผ๋ก์จ ๋ฐ์ํ๋ ์ค๋ฅ(EEXIST)๋ผ๋ฉด, ๊ณ์ ๋ฌดํ๋ฃจํ..
}
for (i = 'a'; i <= 'z'; i++) {
putchar(i);
fflush(stdout);
delay();
}
printf("\n");
close(fd); // ํ์ผ ์ญ์
unlink(LOCKFILE);
return 0;
}
์ด ์ฝ๋๋ฅผ ์คํ์ํค๊ณ a-z๊ฐ ์ถ๋ ฅ๋๊ณ ์์ ๋, ctrl-c๋ฅผ ๋๋ฅด๋ฉด ์คํ์ด ๋ฉ์ถ๊ณ ์ข ๋ฃ๋๋ฉด์, lockfile์ด ์ญ์ ๋์ง ์๋๋ค. ํ์ผ์ด ์์์ผ๋ก์จ ๋ฐ์ํ๋ ์ค๋ฅ, ์ฆ EEXIST ์ค๋ฅ๋ฅผ ๋ฐ์์ํค๊ธฐ ์ํจ์ด๋ค. ๋ฐ๋ผ์ ์ด ์ํ์์ ๋ค์ ํ์ผ์ ์คํ์ํค๋ฉด ๋ฌดํ๋ฃจํ์ ๋น ์ ธ์ ํ์ผ์ด ์ข ๋ฃ๋์ง ์๊ณ ๊ณ์ ์งํ๋๋ค.