Linux环境下C/C++编程与调试指南

需积分: 10 47 浏览量更新于2024-07-30 收藏 5.79MB PDF 举报

“Linux环境下的编程”是一本关于在Linux操作系统中进行C/C++编程的书籍，涵盖了从基础到高级的多个方面，旨在帮助读者理解和掌握Linux系统中的编程实践。书中详细讨论了调试过程、代码编写，以及与内核相关的函数。同时，作者期待读者分享更多经典的Linux编程书籍以促进学习交流。在Linux环境下进行编程，首先需要了解的是基本的Unix编程接口，这是Linux编程的基础。《Advanced Linux Programming》这本书中，第一章“Advanced Unix Programming with Linux”深入浅出地讲解了这一主题，包括文件操作、进程控制、信号处理等核心概念。第二章“Writing Good GNU/Linux Software”关注的是如何编写高质量的Linux软件，涵盖软件设计原则、版本控制、测试和调试技巧，这些都是一个优秀程序员必备的技能。接下来的章节详细介绍了Linux中的进程和线程管理。第三章“Processes”讨论了进程的创建、通信和同步，而第四章“Threads”则专注于线程的使用和多线程程序的设计问题。第五章“Interprocess Communication (IPC)”深入解析了进程间通信的各种机制，如管道、套接字、消息队列和共享内存等，这些都是构建复杂系统的关键。第六章“Mastering Linux”可能涉及了更高级的主题，如系统调用的使用、内核模块开发等，让开发者能够更深入地操控Linux系统。第七章“The /proc File System”讲述了Linux特有的/proc文件系统，它是获取系统状态和控制内核的重要接口。第八章“Linux System Calls”详细介绍了Linux提供的系统调用接口，包括打开、读写文件、网络通信等功能，这些都是直接与操作系统交互的基础。第九章“Inline Assembly Code”讨论了在C/C++程序中使用内联汇编，这对于优化性能或访问硬件特性至关重要。最后，第十章“Security”聚焦于Linux编程中的安全问题，如权限管理、缓冲区溢出和其他安全漏洞的防范。这些章节的PDF文件提供了深入学习Linux编程的具体内容，每个章节都是一个独立的主题，读者可以根据自身需求选择性地学习。通过阅读和实践书中的内容，开发者将能够熟练地在Linux环境中进行C/C++编程，并能应对各种复杂问题。

107

5.3 Mapped Memory

write (fd, “”, 1);

lseek (fd, 0, SEEK_SET);

/* Create the memory mapping. */

file_memory = mmap (0, FILE_LENGTH, PROT_WRITE, MAP_SHARED, fd, 0);

close (fd);

/* Write a random integer to memory-mapped area. */

sprintf((char*) file_memory, “%d\n”, random_range (-100, 100));

/* Release the memory (unnecessary because the program exits). */

munmap (file_memory, FILE_LENGTH);

return 0;

}

The mmap-write program opens the file, creating it if it did not previously exist.The

third argument to open specifies that the file is opened for reading and writing.

Because we do not know the file’s length, we use lseek to ensure that the file is large

enough to store an integer and then move back the file position to its beginning.

The program maps the file and then closes the file descriptor because it’s no longer

needed.The program then writes a random integer to the mapped memory, and thus

the file, and unmaps the memory.The munmap call is unnecessary because Linux would

automatically unmap the file when the program terminates.

Listing 5.6 (mmap-read.c) Read an Integer from a Memory-Mapped File, and

Double It

#include <stdlib.h>

#include <stdio.h>

#include <fcntl.h>

#include <sys/mman.h>

#include <sys/stat.h>

#include <unistd.h>

#define FILE_LENGTH 0x100

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

{

int fd;

void* file_memory;

int integer;

/* Open the file. */

fd = open (argv[1], O_RDWR, S_IRUSR

| S_IWUSR);

/* Create the memory mapping. */

file_memory = mmap (0, FILE_LENGTH, PROT_READ

| PROT_WRITE,

MAP_SHARED, fd, 0);

close (fd);

continues

06 0430 CH05 5/22/01 10:22 AM Page 107

108

Chapter 5 Interprocess Communication

/* Read the integer, print it out, and double it. */

scanf (file_memory, “%d”, &integer);

printf (“value: %d\n”, integer);

sprintf ((char*) file_memory, “%d\n”, 2 * integer);

/* Release the memory (unnecessary because the program exits). */

munmap (file_memory, FILE_LENGTH);

return 0;

}

The mmap-read program reads the number out of the file and then writes the doubled

value to the file. First, it opens the file and maps it for reading and writing. Because

we can assume that the file is large enough to store an unsigned integer, we need not

use lseek, as in the previous program.The program reads and parses the value out

of memory using sscanf and then formats and writes the double value using sprintf.

Here’s an example of running these example programs. It maps the file

/tmp/integer-file.

% ./mmap-write /tmp/integer-file

% cat /tmp/integer-file

% ./mmap-read /tmp/integer-file

value: 42

% cat /tmp/integer-file

Observe that the text 42 was written to the disk file without ever calling write, and

was read back in again without calling read. Note that these sample programs write

and read the integer as a string (using sprintf and sscanf) for demonstration purposes

only—there’s no need for the contents of a memory-mapped file to be text.You can

store and retrieve arbitrary binary in a memory-mapped file.

5.3.3 Shared Access to a File

Different processes can communicate using memory-mapped regions associated with

the same file. Specify the MAP_SHARED flag so that any writes to these regions are

immediately transferred to the underlying file and made visible to other processes.

If you don’t specify this flag, Linux may buffer writes before transferring them to

the file.

Alternatively, you can force Linux to incorporate buffered writes into the disk file

by calling msync. Its first two parameters specify a memory-mapped region, as for

munmap.The third parameter can take these flag values:

MS_ASYNC—The update is scheduled but not necessarily run before the call

returns.

MS_SYNC—The update is immediate; the call to msync blocks until it’s done.

MS_SYNC and MS_ASYNC may not both be used.

Listing 5.6 Continued

06 0430 CH05 5/22/01 10:22 AM Page 108

109

5.3 Mapped Memory

MS_INVALIDATE—All other file mappings are invalidated so that they can see the

updated values.

For example, to flush a shared file mapped at address mem_addr of length mem_length

bytes, call this:

msync (mem_addr, mem_length, MS_SYNC | MS_INVALIDATE);

As with shared memory segments, users of memory-mapped regions must establish

and follow a protocol to avoid race conditions. For example, a semaphore can be used

to prevent more than one process from accessing the mapped memory at one time.

Alternatively, you can use fcntl to place a read or write lock on the file, as described

in Section 8.3,“fcntl: Locks and Other File Operations,” in Chapter 8.

5.3.4 Private Mappings

Specifying MAP_PRIVATE to mmap creates a copy-on-write region. Any write to the

region is reflected only in this process’s memory; other processes that map the same

file won’t see the changes. Instead of writing directly to a page shared by all processes,

the process writes to a private copy of this page. All subsequent reading and writing by

the process use this page.

5.3.5 Other Uses for mmap

The mmap call can be used for purposes other than interprocess communications. One

common use is as a replacement for read and write. For example, rather than explic-

itly reading a file’s contents into memory, a program might map the file into memory

and scan it using memory reads. For some programs, this is more convenient and may

also run faster than explicit file I/O operations.

One advanced and powerful technique used by some programs is to build data

structures (ordinary struct instances, for example) in a memory-mapped file. On a

subsequent invocation, the program maps that file back into memory, and the data

structures are restored to their previous state. Note, though, that pointers in these data

structures will be invalid unless they all point within the same mapped region of

memory and unless care is taken to map the file back into the same address region

that it occupied originally.

Another handy technique is to map the special

/dev/zero file into memory.That

file, which is described in Section 6.5.2,“/dev/zero,” of Chapter 6, “Devices,” behaves

as if it were an infinitely long file filled with 0 bytes. A program that needs a source of

0 bytes can mmap the file /dev/zero.Writes to /dev/zero are discarded, so the mapped

memory may be used for any purpose. Custom memory allocators often map

/dev/zero to obtain chunks of preinitialized memory.

06 0430 CH05 5/22/01 10:22 AM Page 109

110

Chapter 5 Interprocess Communication

5.4 Pipes

A pipe is a communication device that permits unidirectional communication. Data

written to the “write end” of the pipe is read back from the “read end.” Pipes are

serial devices; the data is always read from the pipe in the same order it was written.

Typically, a pipe is used to communicate between two threads in a single process or

between parent and child processes.

In a shell, the symbol | creates a pipe. For example, this shell command causes the

shell to produce two child processes, one for ls and one for less:

% ls | less

The shell also creates a pipe connecting the standard output of the ls subprocess with

the standard input of the less process.The filenames listed by ls are sent to less in

exactly the same order as if they were sent directly to the terminal.

A pipe’s data capacity is limited. If the writer process writes faster than the reader

process consumes the data, and if the pipe cannot store more data, the writer process

blocks until more capacity becomes available. If the reader tries to read but no data is

available, it blocks until data becomes available.Thus, the pipe automatically synchro-

nizes the two processes.

5.4.1 Creating Pipes

To create a pipe, invoke the pipe command. Supply an integer array of size 2.The call

to pipe stores the reading file descriptor in array position 0 and the writing file

descriptor in position 1. For example, consider this code:

int pipe_fds[2];

int read_fd;

int write_fd;

pipe (pipe_fds);

read_fd = pipe_fds[0];

write_fd = pipe_fds[1];

Data written to the file descriptor read_fd can be read back from write_fd.

5.4.2 Communication Between Parent and Child Processes

A call to pipe creates file descriptors, which are valid only within that process and its

children.A process’s file descriptors cannot be passed to unrelated processes; however,

when the process calls fork, file descriptors are copied to the new child process.Thus,

pipes can connect only related processes.

In the program in Listing 5.7, a fork spawns a child process.The child inherits the

pipe file descriptors.The parent writes a string to the pipe, and the child reads it out.

The sample program converts these file descriptors into FILE* streams using fdopen.

Because we use streams rather than file descriptors, we can use the higher-level

standard C library I/O functions such as

printf and fgets.

06 0430 CH05 5/22/01 10:23 AM Page 110

剩余371页未读，继续阅读

XNZ0616

粉丝: 5
资源: 9

Linux环境下C/C++编程与调试指南

某培训机构嵌入式linux环境下编程课件

Linux环境高级编程

linux环境高级编程

linux环境高级编程 pdf

linux环境编程图文指南

linux环境编程和图文指南

linux环境下c++编程

最新资源