嵌入式第二十五天

最新推荐文章于 2022-04-29 15:47:56 发布
最新推荐文章于 2022-04-29 15:47:56 发布
阅读量182 收藏
点赞数
文章标签： 进程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cgj19960119/article/details/81875515
版权


复习： 
进程间通信方式：信号、管道、共享内存、消息队列、信号量、socket套接字 

信号： 
种类：   kill -l   (man 7 signal)
SIGINT  
SIGQUIT 
SIGALRM 
SIGTSTP
信号的处理方式： 捕捉、忽略 、默认  
函数： signal  kill(pid,SIGINT);  raise  alarm    

管道： 
无名管道： pipe int pfd[2];  pfd[0]读端   pfd[1]写端 
有名管道： mkfifo("pathname",0664);   

新知识：    
共享内存 --- 进程间通信最快

为了在多个进程间交换信息，内核专门留出一块内存区。这段内存可以由需要访问的进程
将其映射到自己的私有地址空间，因此进程就可以直接读写这一段内存区，而不需要数据的复制。
从而大大提高了效率。 

一、 步骤
1. 创建共享内存对象  shmget 
2. 映射          shmat
3. 读写             
4. 解除映射      shmdt
5. 删除共享内存对象  shmctl 


二、 函数
1. 创建共享内存对象  shmget 
函数原型：  int shmget(key_t key, size_t size, int shmflg);
头文件：    #include <sys/ipc.h>
            #include <sys/shm.h>
参数：    参数一： key ：IPC_PRIVATE
                         共享内存的键值。 
          参数二： size ： 共享内存大小 
          参数三： open() 函数的权限位。 O_RDONLY  O_WRONLY  O_RDWR   O_CREAT  权限位也可以用8进制表示： 0664
*返回值： 成功： 共享内存段标识符  shmid  
         失败： -1 

示例：  shmget(IPC_PRIVATE,128,O_CREAT|O_WRONLY);
        shmget(key,256,O_RDONLY);


函数2：  ftok();  
函数原型：  key_t ftok(const char *pathname, int proj_id);
头文件：      #include <sys/types.h>
             #include <sys/ipc.h>
参数：  参数1： pathname  路径。 要求此路径必须是存在的。 
        参数2： proj_id   1 ~ 255 之间的整数即可。 
*返回值：  是一个键值。可以提供给消息队列或者共享内存使用。 
        
示例： 
        
#include  <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>
#include <stdio.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <fcntl.h>
int main()
{
    key_t key = ftok("/mnt",'a');         
    int shmid = shmget(key,128,O_CREAT|O_WRONLY);
    if(shmid < 0)
    {
        perror("shmget");
        exit(-1);
    }
    printf("OK\n");
    return 0;
}        
    

2. 映射          shmat
函数原型：      void *shmat(int shmid, const void *shmaddr, int shmflg);
头文件：        #include <sys/types.h>
                #include <sys/shm.h>
参数：       参数1：  shmget 的返回值。 
             参数2； shmaddr 将共享内存映射到指定地址。 （通常写 NULL）
             参数3： SHM_RDONLY   共享内存只读。 
                       0      共享内存可读写  
*返回值：  成功： 被映射的段地址 
           失败： -1   
3. 读写             

示例： 
write.c 
///
#include  "my.h"
int main()
{
    key_t key = ftok("/home",66);         
//    printf("key : %d\n",key);
    int shmid = shmget(key,256,IPC_CREAT|0664);  //当参数1为key时，权限使用的是： IPC_CREAT,不是O_CREAT 
    if(shmid < 0)
    {
        perror("shmget");
        exit(-1);
    }
    int *p = shmat(shmid,NULL,0);
    *p = 999;
    return 0;
}

read.c 
/
#include "my.h"
int main()
{
    key_t key = ftok("/home",66);         
    int shmid = shmget(key,256,0);
    if(shmid < 0)
    {
        perror("shmget");
        exit(-1);
    }
    int *p = shmat(shmid,NULL,0);
    printf("%d\n",*p);

    return 0;
}

//练习：进程a键盘获取字符串发给进程b 进程b收到后转为大写并输出    
write.c 
//
#include "my.h"
int main()
{
    key_t key = ftok("/home",'r');         
    int shmid = shmget(key,256,IPC_CREAT|0777);
    if(shmid < 0)
    {
        perror("shmget");
        exit(-1);
    }
    char *p = shmat(shmid,NULL,0);
    gets(p);
    return 0;
}

read.c 
///
#include "my.h"
void change(char *p)
{
    int i;
    for(i=0; p[i]!='\0'; i++)
    {
        if(p[i]>='a'&& p[i]<='z')
        {
            p[i] -= 32;
        }
    }
    return;
}
int main()
{
    key_t key = ftok("/home",'r');         
    int shmid = shmget(key,256,0);
    if(shmid < 0)
    {
        perror("shmget");
        exit(-1);
    }
    char *p = shmat(shmid,NULL,0);
    change(p);
    printf("%s\n",p);
    return 0;
}

/ 查看共享内存信息： ipcs  -m  
/ 删除共享内存信息： ipcrm -m  shmid 


4. 解除映射      shmdt
函数原型：  int shmdt(const void *shmaddr);
头文件：   同 shmat 
参数：     shmat 的返回值。 
返回值：    成功： 0 
            失败： -1  

5. 删除共享内存对象  shmctl 
函数原型：        int shmctl(int shmid, int cmd, struct shmid_ds *buf);
头文件：     #include <sys/ipc.h>
             #include <sys/shm.h>
参数：  参数1： shmget  的返回值。  
        参数2： IPC_STAT     获取共享内存状态信息
                IPC_SET      设置共享内存信息
                IPC_RMID     删除共享内存 
        参数3： struct shmid_ds * 
          struct shmid_ds {
               struct ipc_perm shm_perm;    /* Ownership and permissions */
               size_t          shm_segsz;   /* Size of segment (bytes) */
               time_t          shm_atime;   /* Last attach time */
               time_t          shm_dtime;   /* Last detach time */
               time_t          shm_ctime;   /* Last change time */
               pid_t           shm_cpid;    /* PID of creator */
               pid_t           shm_lpid;    /* PID of last shmat(2)/shmdt(2) */
               shmatt_t        shm_nattch;  /* No. of current attaches */
               ...
           };
           
//练习1. 一个进程将数据写入共享内存后 用信号通知另一个进程 
    另一个进程捕捉信号后 将信息打印
    
create.c 
///    
#include"../my.h"
int main()
{
    key_t key = ftok("/home",'w');
    if(key<0)
    {
        perror("ftok");
        exit(-1);
    }

    int shmid = shmget(key,256,IPC_CREAT|0777);
    if(shmid<0)
    {
        perror("shmget");
        exit(-1);
    }
    return 0;
}
    
write.c 

#include"../my.h"
int main(int argc,char*argv[])
{
    if(argc!=2)
    {
        printf("%s pid\n",argv[0]);
        exit(-1);
    }
    key_t key = ftok("/home",'w');
    if(key<0)
    {
        perror("ftok");
        exit(-1);
    }

    int shmid = shmget(key,0,0);
    if(shmid<0)
    {
        perror("shmget");
        exit(-1);
    }
    char *p = shmat(shmid,NULL,0);
    if(p==(void*)-1)
    {
        perror("shmat");
        exit(-1);
    }

    pid_t pid = atoi(argv[1]);
    while(1)
    {
        puts("please input a string:");
        gets(p);
        kill(pid,SIGINT);
    }
    return 0;
}

read.c 
/    
#include"my.h"
char *p;
void deal_fun(int sig)
{
    printf("%s\n",p);
}
int main()
{
    printf("%d\n",getpid());
    signal(SIGINT,deal_fun);
    key_t key = ftok("/home",'f');
    if(key<0)
    {
        perror("ftok");
        exit(-1);
    }
    int shmid = shmget(key,0,0);
    if(shmid<0)
    {
        perror("shmget");
        exit(-1);
    }
    p = shmat(shmid,NULL,SHM_RDONLY);
    if(p==(void*)-1)
    {
        perror("shmat");
        exit(-1);
    }
    while(1)
    {
        ;
    }
    return 0;
}
//
执行过程：  
gcc create.c -o create  
gcc write.c -o write 
gcc read.c -o read 
./create  
./r     (打印自己进程号)
./w  pid   (向进程号为 pid 的进程发送信号)


附： my.h  
//
#ifndef _MY 
#define _MY  1 

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <strings.h>
#include <string.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <signal.h>

#endif


三、函数（第二组）
1. 函数：  ftruncate
函数原型： int ftruncate(int fd, off_t length);
头文件：   #include <unistd.h>
           #include <sys/types.h>
功能：将参数fd 指定的文件大小，改为length指定的大小
参数：  fd 文件描述符。 
        length : 用这个参数，规定了fd 的大小。 

2. mmap
函数原型：  void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);
头文件：   #include <sys/mman.h>
功能： mmap将文件映射到调用进程的地址空间当中。当用mmap映射文件到进程后，
       就可以直接操作这段地址空间进行文件读写操作。
参数： 
参数1： 映射位置。 （一般写NULL, 系统会给分配地址）       
参数2： 空间的大小。 
参数3：PROT_EXEC  Pages may be executed.
       PROT_READ  Pages may be read.
       PROT_WRITE Pages may be written.
       PROT_NONE  Pages may not be accessed.
参数4： 
        MAP_SHARED   共享 
        MAP_PRIVATE  私有
参数5：指定要被映射的文件的描述符。
参数6：要映射的存储区，对应文件的起始偏移量。

返回值： 成功：实际的共享内存地址。 
         失败：MAP_FAILED  ( that is (void *)-1 )

使用示例：  mmap(NULL, 1024, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);


3.  int munmap(void *addr, size_t length);
功能：  解除映射。 
参数：   参数一 :  mmap  的返回值。 
         参数二 ： length  共享内存大小。  
返回值： 成功： 0 
         失败： -1 

示例： 
write.c 

1)打开文件 
2)设置文件大小 
3)映射
4)输入信息到共享内存/输出
5)解除映射 
6)关闭文件描述符 

read.c  
 
步骤同上。 

write.c 
//
#include "../my.h"
#include <sys/mman.h>

int main()
{
    int fd = open("file",O_CREAT|O_EXCL|O_RDWR,0777);
    if(fd < 0)
    {    
        perror("open");
        exit(-1);
    }
    ftruncate(fd,1024);
    int *p = mmap(NULL,1024,PROT_WRITE,MAP_SHARED,fd,0);
    if(p == MAP_FAILED)
    {
        perror("mmap");
        exit(-1);
    }
    *p = 12345;

    munmap(p,1024);
    close(fd);
    return 0;
}

read.c 
///
#include "../my.h"
#include <sys/mman.h>
int main()
{
    int fd = open("file",O_RDWR);
    if(fd < 0)
    {    
        perror("open");
        exit(-1);
    }
    ftruncate(fd,1024);
    int *p = (int *)mmap(NULL,1024,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
    
    printf("%d\n",*p);
    munmap(p,1024);
    close(fd);
    return 0;
}

//练习：进程1从键盘获取一个字符串 传递给进程2  进程2收到串后 转为大写 在输出到屏幕
write.c 
/
#include "../my.h"
#include <sys/mman.h>

int main()
{
    int fd = open("file",O_CREAT|O_EXCL|O_RDWR,0777);
    if(fd < 0)
    {    
        perror("open");
        exit(-1);
    }
    ftruncate(fd,1024);
    char *p = mmap(NULL,1024,PROT_WRITE,MAP_SHARED,fd,0);
    if(p == MAP_FAILED)
    {
        perror("mmap");
        exit(-1);
    }
    puts("Input a string:");
    gets(p);

    munmap(p,1024);
    close(fd);
    return 0;
}

read.c 
//
#include "../my.h"
#include <sys/mman.h>
void change(char *p)
{
    int i;
    for(i=0; p[i]!='\0'; i++)
    {
        if(p[i]>='a'&& p[i]<='z')
        {
            p[i] -= 32;
        }
    }
    return;
}
int main()
{
    int fd = open("file",O_RDWR);
    if(fd < 0)
    {    
        perror("open");
        exit(-1);
    }
    ftruncate(fd,1024);
    char *p = (char *)mmap(NULL,1024,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
    change(p);    
    printf("%s\n",p);

    munmap(p,1024);
    close(fd);
    return 0;
}

//作业答案： 有名管道版本的 cat 功能： 

create.c 

#include "my.h"
int main(int argc,char *argv[])
{
    if(argc != 2)
    {
        printf("%s pipe_name\n",argv[0]);
    }
    int ret = mkfifo(argv[1],0644);
    if(ret < 0)
    {
        perror("mkfifo");
        exit(-1);
    }
    return 0;
}

write.c 
/// 
#include "my.h"
int main(int argc,char *argv[])
{
    if(argc != 3)
    {
        printf("%s pipe_name src_name:\n",argv[0]);
        exit(-1);
    }
    int fd = open(argv[1],O_WRONLY);
    int file_fd = open(argv[2],O_RDONLY);
    if(fd < 0||file_fd < 0)
    {
        perror("open");
        exit(-1);
    }

    char buf[50] = "\0";
    while(1)
    {
        bzero(buf,sizeof(buf)) ;
        int ret = read(file_fd,buf,sizeof(buf));
        if(ret == 0)
        {
            break;
        }
        write(fd,buf,sizeof(buf));
    }
    close(file_fd);
    close(fd);
    return 0;
}
 
read.c 
/
#include "my.h"
int main(int argc,char *argv[])
{
    if(argc != 2)
    {
        printf("%s pipe_name:\n",argv[0]);
        exit(0);
    }
    int fd = open(argv[1],O_RDONLY);
    if(fd < 0)
    {
        perror("open");
        exit(-1);
    }
    char buf[50] = "\0";
    while(1)
    {
        bzero(buf,sizeof(buf));
        int ret = read(fd,buf,sizeof(buf));
        if(ret == 0)
        {
            break;
        }
        puts(buf);
    }    
    close(fd);
    unlink(argv[1]);
    return 0;
}


复习本周内容：
 
标准IO : 
FILE *fp = fopen("file.c",'w+');
fclose(fp);
perror();          %s -- strerror(errno);
c = fgetc(fp);                fputc(c,fp);
fgets(buf,n,fp);           fputs(buf,fp);
fread(buf,4,100,fp);       fwrite(buf,4,100,fp);
fseek(fp,-1,SEEK_SET);     num = ftell(fp);
fprintf(fp,"%d,%d\n",a,b);     fscanf(fp,"%d%s",&a,s);
fnprintf(fp,50,"%d,%d\n",a,b);

文件IO : 
int fd = open("/home/linux/a.c",O_CREAT|O_EXCL|O_RDWR|O_TRUNC,0664); 
close(fd);
read(fd,buf,100);
write(fd,buf,100);
lseek(fd,0,SEEK_SET);
bzero(buf,100); 
menset(buf,'a',100);  //一个字节一个字节 操作。 

目录文件： 
DIR *dirp = opendir("/home/linux");
closedir(dirp);
struct dirent *p = readdir(dirp);
                    struct dirent {    
                        d_ino;
                        d_time;
                        ...
                        d_name[256];
                    };
                    printf("%s\n",p->d_name);    
stat("/home/linux",&a);
                    struct stat {
                        st_ino;
                        st_mode;
                        st_nlink;
                        ...
                    };
a.st_mode   -->  S_ISREG()  S_ISDIR()

进程线程： 
day1:  进程、守护进程   
ps -ef    

getpid();  
getppid();
fork();
            if(id == 0)
            {
                child ;
            }
            else if(id > 0)
            {
                father ;
            }
exit(0);    
_exit(0);
wait(NULL);   wait(&a);  // a 是输出型参数：函数执行完，变量a 获取一个值。 
waitpid(pid,&a,0);    // 0 阻塞状态      WNOHANG 非阻塞
execl("/bin/ls","ls","-l",NULL);
execv("/bin/ls",cmd);    char *cmd[] = {"ls","-l",NULL};
execvp("ls",cmd);    char *cmd[] = {"ls","-l",NULL};

守护进程： 
1. fork();   if(id > 0) exit(0);
2. setsid();
3. chdir("/tmp");
4. umask(0);
5. close(0); close(1); close(2);

进程间通信方式： 信号、管道、共享内存、消息队列、信号量、socket套接字
day2: 信号、管道  
man 7 signal   
signal(SIGINT,fun);
signal(SIGALRM,SIG_IGN);
signal(SIGTSTP,SIG_DFL);
kill(pid, SIGALRM);
raise(SIGALRM);
alarm(45);

管道： 
无名管道： 
单工、亲缘关系的进程间、不是文件
先创建管道、后创建进程。 
pipe(int pfd[2]);     pfd[0]  读。 pfd[1]  写。   

有名管道：
是文件。任意进程间通信。 
mkfifo("./fifo",0664);


day3： 共享内存
key = ftok("/home",88);
shmid = shmget(key,128,IPC_CREAT|O_RDWR|0777);
void *p = shmat(shmid,NULL,0);  // NULL 系统会自动分配地址。 0 ： 可读写（权限）
p;
shmdt(p);
shmctl(shmid,IPC_RMID,NULL); 
 
 
 
 

//作业：创建子进程代表售票员 父进程代表司机 
售票员捕捉信号SIGINT（代表开车） 发SIGUSR1给司机 司机打印"ready-go!"
售票员捕捉SIGQUIT(代表停车) 发SIGUSR2给司机     司机打印 "stop..."
售票员捕捉SIGTSTP（代表车到总站）发SIGUSR1给售票员 售票员打印 get off!

//作业：实现shell组合   ls|grep w
提示：用pipe实现
1 fork 
2 dup2(pfd[1],1) //所有输出到屏幕的数据都会输出到管道pfd[1]
3 execlp("ls","ls",NULL)
4 dup2(pfd[0],0);//从标准输入里读 改成从管道中读
5 execlp("grep","grep","w",NULL);

不为人知的小小鸟
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
共享内存函数（shmget、shmat、shmdt、shmctl）及其范例
guoping16的专栏
07-04 13万+
共享内存函数由shmget、shmat、shmdt、shmctl四个函数组成。下面的表格列出了这四个函数的函数原型及其具体说明。1.   shmget函数原型shmget(得到一个共享内存标识符或创建一个共享内存对象)所需头文件#include #includ
进程间通信——共享内存
zhuboke3344的博客
04-15 260
一、概念共享内存：允许两个不相关的进程访问同一个逻辑内存，不同进程之间共享的内存通常为同一段物理内存。进程可以将同一段共享内存连接到它们自己的地址空间中，所有进程都可以访问共享内存中的地址。如果某个进程向共享内存写入数据，所做的改动将立即回影响到可以访问同一段共享内存的其他进程。二、共享内存的特点·共享内存是所有进程间通信最快的（直接是用户到用户）·不带互斥与同步机制·生命周期随内核三、函数1、s...
56-System V 共享内存-shmat 与 shmdt
进击的小学生
01-12 1974
在理解内核对象后，接下来谈谈 System V 共享内存的 shmat 和 shmdt 函数。1. shmget 函数再次回顾一下 shmget 函数。图1 中左侧表示的是一个进程空间（未区分内核空间与用户空间），进程空间中并非所有的线性地址被分配（或者说并非所有线性地址都被映射到物理页），黑色部分表示的是未分配的线性地址。 图1 进程空间与物理页 当你使用 shmget 创建出共享内存后，
IPC之共享内存（shmget函数、shmat函数、shmdt函数）及其代码示例——linux系统编程
z5z5z5z56的博客
08-01 2640
文章目录共享内存介绍shmget：创建共享内存shmat：将创建好的共享内存连接到某个进程，并指定内存空间shmdt：脱钩函数，把共享内存与当前进程脱离开代码实例 共享内存介绍 共享内存是IPC中效率最高的一个，它是原理是linux内核在内存中开辟一个空间，给进程进行读写。 每个进程都会通过API函数，把这块linux内核中的内存映射到自己的进程空间里面来，是映射的，虚拟的，不是实际在进程内存中。 通过这种方法来达到进程间共享数据目的 • 共享内存使用的函数与信号量的很相似，涉及到的函数如下 void *s
0基础学会共享内存（内附源码）
小石_coding
03-14 717
0基础学会共享内存（内附源码）
第十五届蓝桥杯嵌入式省赛真题解析
04-13
在第十五届蓝桥杯嵌入式省赛中，参赛者们可能面临的是对这类系统的理论理解与实践操作的挑战。嵌入式系统广泛应用于各个行业，如消费电子、医疗设备、工业自动化、汽车电子等，其核心在于高效、低功耗、实时性强和...
第十五届蓝桥杯嵌入式省赛真题题目和答案
最新发布
04-13
### 第十五届蓝桥杯嵌入式省赛真题题目解析及知识点梳理 #### 嵌入式系统基础知识概述 嵌入式系统是计算机科学的一个分支，它涉及到将微处理器、外围设备和软件集成到一个单一的产品中，以执行特定的任务。这类...
第十三届第二场蓝桥杯嵌入式G431，程序题完美实现！
06-11
该压缩包文件包含完整的程序设计题工程文件，在第十三届第一场中主要使用到了串口通信、PWM产生、定时器的应用、EEPROM以及基本的LED,LCD,按键的应用。 其中串口通信使用的是DMA空闲中断的方式接收数据，定时器主要...
第十四届蓝桥杯嵌入式省赛
02-23
"第十四届蓝桥杯嵌入式省赛"是针对这一技术进行的专业竞赛，旨在考察参赛者的嵌入式系统设计与应用能力。 一、嵌入式系统基础 嵌入式系统是指以应用为中心，以计算机技术为基础的，软硬件可裁剪的专用计算系统。它...
（转）Linux共享内存使用常见陷阱与分析(2)-多次进行shmat会出现什么问题
caoli98033的专栏
03-25 4379
转自http://os.51cto.com/art/201311/418977_1.htm 多次进行shmat会出现什么问题？ 当首次创建共享内存段时，它并不能被任何进程所访问。为了使共享内存区可以被访问，则必须通过 shmat 函数将其附加( attach )到自己的进程空间中，这样进程就与共享内存建立了连接。该函数声明在 linux/shm.h中： #include #inclu
LINUX共享内存使用常见陷阱与分析
duola_rain的专栏
05-30 1629
所谓共享内存就是使得多个进程可以访问同一块内存空间，是最快的可用IPC形式。是针对其他通信机制运行效率较低而设计的。往往与其它通信机制，如信号量结合使用，来达到进程间的同步及互斥。其他进程能把同一段共享内存段“连接到”他们自己的地址空间里去。所有进程都能访问共享内存中的地址。如果一个进程向这段共享内存写了数据，所做的改动会即时被有访问同一段共享内存的其他进程看到。共享内存的使用大大降低了在大规模数
shmat 函数的使用
热门推荐
wangshiqueque的专栏
07-30 2万+
shmat 函数的使用   shmat（）是用来允许本进程访问一块共享内存的函数，与shmget（）函数共同使用。 shmat的原型是：void *shmat（int shmid，const void *shmaddr,int shmflg）; 它需要如下3个参数： 第一个是参数是 shmid 是shmget 返回的标识符， 第二个参数 三种情况 1.
共享内存shm
JaweG
10-25 1580
1.最快的IPC通信方式 共享内存区是最快的IPC形式。一旦这样的内存映射到共享它的进程的地址空间，这 些进程间数据传递不再涉及到内核，换句话说是进程不再通过执行进入内核的系统调 用来传递彼此的数据。 图：用管道或者消息队列传递数据 图：用共享内存传递数据 2.相关API [1]shmget int shmget(key_t key, size_t size, int shmflg); ...
【Linux操作系统】-- 基础IO
qq_53413129的博客
04-29 374
我们写的程序最终都是要访问硬件：显示器，键盘，文件（磁盘）这些东西的。那么OS（操作系统就是硬件的管理者）。但是用户/语言，程序，lib不能直接访问硬件，也不能直接访问驱动，也不能直接访问OS。所以，所有的语言上的对“文件”的操作，都必须贯穿OS！ 我们知道OS对外界是不公开的，操作系统不相信任何人，如果要访问操作系统，需要通过系统调用接口！ 几乎所有的语言fopen,fclose,fread,fwrite,fgets,fputs,fgetc,fputc等底层一定需要使用OS提供的接口调用。所有的语言要
共享内存shmat shmget shmdt shmctl ipcs ipcmk ipcrm
纯，属虚构
04-23 1594
查 ipcs -m 增 ipcmk -M 1024(size) ipcmk -M 1024(size) -p 0666 删 ipcrm -m 1024(id) size的上限：4G [chenming@localhost src]$ cat /proc/sys/kernel/shmmax 4294967295 ------------------
[OS-Linux]详解Linux的基础IO (1) ------- 文件描述符fd
RMA515T的博客
10-13 9234
本文由文件IO相关操作的一些操作，进一步详解了文件描述符fd，重定向。 一、C语言中的文件I/O操作 首先来回顾一下C语言中的文件I/O操作[C/C++]C语言中对文件的操作方法_RMA515T的博客-CSDN博客 之前的博客中就有详细的介绍。这里就只做简单演示。 #include <stdio.h> int main() { FILE *fp = fopen("zht2", "w+"); if(!fp) { printf("erroe"); r.
Linux系统编程--read/write
木牛的博客
06-01 979
4. read/write  read函数从打开的设备或文件中读取数据。 #include  ssize_t read(int fd, void *buf, size_t count); 返回值：成功返回读取的字节数，出错返回-1并设置errno，如果在调read之前已到达文件末尾，则这次read返回0 参数count是请求读取的字节数，读上来的数据保存在缓冲区buf中，同时文件的
嵌入式系统设计——进程间通信（7）
qq_45794091的博客
04-20 283
进程管理 嵌入式Linux多任务：进程，线程 硬件条件：单个CPU单个核 单任务：一个任务执行完毕之后，下个任务才能执行 多任务：任务的执行可以被中断，中断之后可以执行其他任务（并发，并行） 单核CPU:并发 多核CPU:并发，并行 进程实现多任务 特点：给每个进程分配独立的地址空间，4G大小（1G内核，3G用户空间） 进程创建方式：fork>exec函数族>system>vfo...
嵌入式linux基础教程 第2版pdf
06-24
第二章涵盖了Linux操作系统的安装和配置，包括如何选择和下载适合嵌入式系统的Linux内核、使用交叉编译器进行交叉编译、安装组件等。 在第三章，本书介绍了Linux系统中的文件和目录结构，软件包管理等内容；第四章...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值