Cơ sở dữ liệu - Linux programing

Nội dung text: Cơ sở dữ liệu - Linux programing

1. Linux Programing
2. System calls  System call thường là một yêu cầu đến hệ điều hành để làm một tác vụ phần cứng/chuyên biệt hệ thống hay tác vụ đặc quyền hệ thống .  Trong Linux-1.2 có 140 system calls được định nghĩa.  System calls như close() được hiện thực trong Linux libc.  Việc hiện thực này xoay quanh việc gọi một là syscall().  Các tham số truyền vào syscall() là số hiệu system call và được theo sau bởi các tham số cần thiết
3. System calls  Số hiệu của system call có tìm thể thấy ở   Trong đó được cập nhật với libc mới.  Nếu có các calls xuất hiện mà chúng chưa có trong libc, ta có thể gọi syscall().
4. System calls  Ví dụ, ta có thể đóng file dùng syscall() như sau (không khuyến khích):  #include  extern int syscall(int, );  int my_close(int filedescriptor)  {  return syscall(SYS_close, filedescriptor);  }
5. System call Parameters  Trên kiến trúc i386 , system calls bị giới hạn đến 5 tham số không kể đến số hiệu system call bởi vì việc hạn chế số lượng thanh ghi  Nếu bạn dùng Linux trên một kiến trúc khác, ta có thể check kiểm tra để tìm các syscall macros để xem phần cứng của bạn có thể hỗ trợ đến bao nhiêu tham số  Các syscall macro này có thể được dùng thay thế cho syscall(), nhưng nó không được khuyến khích khi đã có những macro được phát triển thành các hàm đầy đủ tồn tại trong thư viện lập trình
6. System call Parameters (tt)  Do đó chỉ có những tay chuyên nghiệp mới nên chơi với các syscall macros. Ví dụ đây là một hàm close() có dùng syscall macro. #include _syscall1(int, close, int, filedescriptor);  syscall1 macro mở rộng hàm close(). Do đó ta có close() xuất hiện 2 lần: một trong libc và một trong chương trình của ta. Giá trị trả về của syscall() hay syscall macro là -1 nếu system call thất bại và 0 hoặc lớn hơn nếu thành công.
7. System Call không có trong Linux  Các system call sau là tồn tại trên BSD và SYS V nhưng không tồn tại trên Linux:  audit(), auditon(), auditsvc(), fchroot(), getauid(), getdents(), getmsg(), mincore(), poll(),putmsg(), setaudit(), setauid().
8. The “swiss army knife” ioctl  phillips screwdriver, screwdriver, screwdriver, screwdriver, corkscrew, scissors, metal saw, wood saw, can opener, mini screwdriver, nailfile, metal file, wire bender, large blade, small blade, cap lifter, wire stripper, reamer, punch, key ring, tweezers, multi-purpose hook, chisel, wire cutters, pin, nail cleaner, multipurpose pliers, clef 6 pans 5mm pour connecteurs D- SUB,embout Pozidrive 0, embout Pozidrive 1, embout tournevis, embout Phillips 2, embout Hex (inbus), embout Torx 8, embout Torx 10, embout Torx 15, long ballpoint pen, toothpick
9. The “swiss army knife” ioctl  ioctl viết tắt cho input/output control và nó được dùng để thao tác đến các character device thông qua filedescriptor.  Format của ioctl là  ioctl(unsigned int fd, unsigned int request, unsigned long argument).  Giá trị trả về là -1 nếu có lỗi và =0 nếu request thành công (tương tự như các system call khác).
10. ioctl (tt)  Kernel phân biệt các file đặc biệt và file thông thường . File đặc biệt là những file nằm trong /dev và /proc. Chúng khác với các file thông thường là chúng dấu các giao diện với driver và không phải là một file thật sự chứa dữ liệu text hay binary. Đây là triết lý của UNIX và cho phép dùng các thao tác read/write thông thường trên tất cả các file.  Bạn sẽ cần dùng ioctl nhiều khi thao tác với các file đặc biệt hơn là với các file thường. Nhưng bạn cũng có thể dùng ioctl trên các file thường !
11. InterProcess Communications-IPC  Cơ chế IPC trong Linux cung cấp một phương pháp cho nhiều tiến trình giao tiếp với nhau. Có nhiều phương pháp IPC cho Linux C programmers áp dụng:  Half-duplex UNIX pipes  FIFOs (named pipes)  SYSV style message queues  SYSV style semaphore sets  SYSV style shared memory segments  Networking sockets (Berkeley style, không đề cập )  Full-duplex pipes (STREAMS pipes,, không đề cập )  Các phương pháp này, khi được dùng một cách hiệu quả, sẽ mang lại một framework vững chắc cho client/server development trên bất kỳ một hệ UNIX nào (bao gồm cả Linux).
12. Half-duplex UNIX Pipes  Khái niệm căn bản: pipe là một phương pháp của việc kết nối standard output của một tiến trình process vào một standard input của tiến trình khác. Pipes là một công cụ IPC cổ nhất, nó có từ giai đoạn phôi thai nhất của HĐH UNIX. Chúng cung cấp một của việc giao tiêế 1 chiều (thuật ngữ half-duplex) giữa các process. Tính năng này được dùng rộng rãi, thậm chí trong shell của Unix ls | sort | lp
13. Half-duplex UNIX Pipes  Tạo pipes trong C  Để tạo một pipe đơn giản trong C, ta cần dùng pipe() system call. Nó cần 1 tham số, đó là một array có 2 số integer và nếu thành công, array sẽ chứa 2 file descriptors mới để được dùng cho pipeline. Sau khi tạo pipe, process thường sinh ra 1 tiến trình mới (lưu ý rằng, tiến trình con thừa kế mô tả file đã mở).
14. Tạo pipes trong C  SYSTEM CALL: pipe();  PROTOTYPE: int pipe( int fd[2] );  RETURNS: 0 on success  -1 on error: errno = EMFILE (no free descriptors)  EMFILE (system file table is full)  EFAULT (fd array is not valid)  NOTES: fd[0] is set up for reading, fd[1] is set up for writing
15. Tạo pipes trong C  Giá trị integer đầu tiên trong array được thiết lập và mở ra cho việc đọc, trong khi số integer thứ hai được thiết lập và mở ra cho việc ghi.  Nói một cách hình tượng, output của fd1 trở thành input cho fd0. Một lần nữa, tất cả data di chuyển thông qua pipe đi vào kernel. #include #include #include main() { int fd[2]; pipe(fd); }
16. Ví dụ / MODULE: pipe.c / /* Send "string" through the output #include side of pipe */ #include write(fd[1], string, strlen(string)); #include exit(0); int main(void) } { int fd[2], nbytes; else { pid_t childpid; /* Parent process closes up output char string[] = "Hello, world!\n"; side of pipe */ char readbuffer[80]; close(fd[1]); pipe(fd); /* Read in a string from the pipe */ if((childpid = fork()) == -1){ nbytes = read(fd[0], readbuffer, perror("fork"); sizeof(readbuffer)); exit(1); } printf("Received string: %s", if(childpid == 0) { readbuffer); } /* Child process closes up input side return(0); of pipe */ } close(fd[0]);
17. Các lưu ý trong half-duplex pipes  pipes hai chiều có thể được tạo ra bằng cách mở hai pipes, và được gán lại file descriptors một cách thích hợp trong tiến trình con .  Lời gọi pipe() phải được thực hiện trước khi gọi fork(), nếu không thì descriptors sẽ không được thừa kế bởi tiến trình con !  Với half-duplex pipes, bất kỳ tiến trình kết nối nào phải được chia sẽ cùng một tổ tiên. Khi pipe cư trú bên trong sự kềm hãm của kernel, bất cứ một tiến trình nào mà không cùng tổ tiên của pipe thì không có cách nào tìm đến được nó.
18. Named Pipes (FIFOs)  Khái niệm: named pipe hoạt động giống như pipe thông thường, nhưng có một số khác biệt đáng chú ý:  Named pipes tồn tại như là một device special file trong file system.  Các tiến trình khác tổ tiên có thể chia sẽ data thông qua một named pipe.  Khi tất cả I/O được hoàn tất bởi các tiến trình chia sẻ, named pipe còn lưu lại trong file system để dùng sau.
19. Tạo FIFO  Có nhiều cách để tạo một named pipe. Hai cách đầu tiên là tạo trực tiếp từ shell.  mknod MYFIFO p  mkfifo a=rw MYFIFO  FIFO files có thể được xác định trong physical file system bởi ký tự “p” ở đầu tiên: [root@pascal root]# ls -l MYFIFO prw-r r 1 root root 0 Aug 23 23:35 MYFIFO [root@pascal root]#
20. Tạo FIFO trong C  Để tạo FIFO trong C, ta có thể dùng mknod() system call: LIBRARY FUNCTION: mknod(); PROTOTYPE: int mknod( char *pathname, mode_t mode, dev_t dev); RETURNS: 0 on success, -1 on error:errno=EFAULT (pathname invalid) EACCES (permission denied) ENAMETOOLONG (pathname too long) ENOENT (invalid pathname) ENOTDIR (invalid pathname)  NOTES: Tạo filesystem node (file, device file, or FIFO)
21. mknod  Muốn biến rõ hơn về mknod thì hãy dùng lệnh man,nhưng xét ví dụ đơn giản sau trong C:  mknod("/tmp/MYFIFO", S_IFIFO|0666, 0);  Ở đây, file “/tmp/MYFIFO” được tạo ra như là một FIFO file. Quyền của file là “0666”, mặc dù chúng bị ảnh hưởng bởi umask setting như sau:  final_umask = requested_permissions & ˜original_umask  Một mẹo nhỏ dùng umask() system call để tạm thời vô hiệu giá trị umask :  umask(0);  mknod("/tmp/MYFIFO", S_IFIFO|0666, 0);
22. Thao tác FIFO  Các thao tác I/O trên FIFO là cần thiết như đối với các pipe thông thường, với một ngoại lệ chính yếu. Một “open” system call hay hàm thư viện cần phải được dùng để physically open up một kênh tới pipe. Với half-duplex pipes, điều này là không cần thiết, bởi vì khi đó pipe nằm trong kernel và không phải trên physical filesystem. Trong ví dụ, chúng ta sẽ xem như pipe là một stream, mở nó ra với fopen() và đóng với fclose().
23. fifoserver.c  #include  #include  #include  #include  #include  #define FIFO_FILE "MYFIFO"  int main(void)  {  FILE *fp;  char readbuf[80];  /* Create the FIFO if it does not exist */  umask(0);  mknod(FIFO_FILE, S_IFIFO|0666, 0);
24. fifoserver.c (tt)  while(1)  {  fp = fopen(FIFO_FILE, "r");  fgets(readbuf, 80, fp);  printf("Received string: %s\n", readbuf);  fclose(fp);  }  return(0);  }
25. fifoclient.c  #include  #include  #define FIFO_FILE "MYFIFO"  int main(int argc, char *argv[])  {  FILE *fp;  if ( argc != 2 ) {  printf("USAGE: fifoclient [string]\n");  exit(1);  }
26. fifoclient.c (tt)  if((fp = fopen(FIFO_FILE, "w")) == NULL) {  perror("fopen");  exit(1);  }  fputs(argv[1], fp);  fclose(fp);  return(0);  }
27. Blocking Actions on a FIFO  Thông thường, blocking xảy ra trên FIFO. Nói cách khác nếu FIFO được mở để đọc, process sẽ ”block” cho đến khi một vài process khác mở nó ra để viết vào. Nếu hành vi này là không mong muốn thì một cờ O_NONBLOCK có thể được dùng trong open() call để disable default blocking action.
28. Infamous SIGPIPE Signal  Một chú ý cuối cùng, pipes phải có một reader và một writer. Nếu một process cố gắng ghi vào một pipe mà không có reader, nó sẽ được gửi đến 1 tín hiệu SIGPIPE từ kernel. Điều này là bắt buộc khi có nhiều hơn hai tiến trình thao tác với một pipeline.
29. TCP/IP in Linux  Introduction  Socket  Client.c  Server.c
30. Introduction
31. Socket
32. Client.c #include len = sizeof(address); #include result = connect(sockfd, #include #include (struct sockaddr #include *)&address, len); #include if(result == -1) { int main() perror("oops: client1 problem"); { exit(1); int sockfd; } int len; struct sockaddr_in address; write(sockfd, &ch, 1); int result; read(sockfd, &ch, 1); char ch = 'A'; printf("char from server = %c\n", sockfd = socket(AF_INET, ch); SOCK_STREAM, 0); close(sockfd); address.sin_family = AF_INET; address.sin_addr.s_addr = exit(0); inet_addr("127.0.0.1"); } address.sin_port = 9734;
33. Server.c #include bind(server_sockfd, #include (struct sockaddr # include //như trên *)&server_address, server_len); int main() { listen(server_sockfd, 5); int server_sockfd, client_sockfd; while(1) { int server_len, client_len; char ch; struct sockaddr_in server_address; printf("server waiting\n"); struct sockaddr_in client_address; client_sockfd = server_sockfd = socket(AF_INET, SOCK_STREAM, 0); accept(server_sockfd, server_address.sin_family = (struct sockaddr AF_INET; *)&client_address, &client_len); server_address.sin_addr.s_addr = read(client_sockfd, &ch, 1); inet_addr("127.0.0.1"); ch++; server_address.sin_port = 9734; write(client_sockfd, &ch, 1); server_len = sizeof(server_address); close(client_sockfd); } }