Linux Process_control

最新推荐文章于 2024-02-22 14:05:02 发布
原创 最新推荐文章于 2024-02-22 14:05:02 发布 · 1.7k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#linux #c++

本文详细介绍了Linux下的进程控制，包括进程标识pid、fork、wait和waitpid、exec、用户标识、进程调度、进程关系（如进程组、session、controlling Terminal和job control）等内容，还讲解了shell如何执行程序。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

文章目录

进程标识pid

id=0的是调度进程(swapper),该进程是内核的一部分,并不执行磁盘的任何的程序,也被称为系统进程
id=1 是init进程,属于用户态进程,但是以超级用户特权运行,是所有孤儿进程的父进程

#include <unistd.h>
pid_t getpid(void);
Returns: process ID of calling process
pid_t getppid(void);
Returns: parent process ID of calling process
uid_t getuid(void);
Returns: real user ID of calling process
uid_t geteuid(void);
Returns: effective user ID of calling process
gid_t getgid(void);
Returns: real group ID of calling process
gid_t getegid(void);
Returns: effective group ID of calling process

#include <unistd.h>
int setuid(uid_t uid);
int setgid(gid_t gid);
Both return: 0 if OK, −1 on error

#include <unistd.h>
int setreuid(uid_t ruid, uid_t euid);
int setregid(gid_t rgid, gid_t egid);
Both return: 0 if OK, −1 on error

fork

#include <unistd.h>
pid_t fork(void);
Returns: 0 in child, process ID of child in parent, −1 on error

fork函数调用一次,返回两次,其中返回0是child进程,pid>0则是子进程的pid.内核一般保存父进程的区域堆栈,数据段的完全副本,且副本的访问权限只读,父进程或者子进程试图修改的话,内核就会建立修改区域的副本,(Copyy-On-Write)

在这里插入图片描述

wait and waitpid

#include <sys/wait.h>
pid_t wait(int *statloc);
pid_t waitpid(pid_t pid, int *statloc, int options);
/* Wait for a child to die. When one does, put its status in *STAT_LOC
and return its process ID. For errors, return (pid_t) -1.

This function is a cancellation point and therefore not marked with
__THROW. */
extern __pid_t wait (int *__stat_loc);


void tl::testProcess(){

	auto preStatus = [](int status)->void {
		if (WIFEXITED(status))
			printf("normal termination, exit status = %d\n",
				WEXITSTATUS(status));
		else if (WIFSIGNALED(status))
			printf("abnormal termination, signal number = %d%s\n",
				WTERMSIG(status),
#ifdef WCOREDUMP
				WCOREDUMP(status) ? " (core file generated)" : "");
#else
			"");
#endif
		else if (WIFSTOPPED(status))
			printf("child stopped, signal number = %d\n",
				WSTOPSIG(status));

	};

	pid_t pid;
	int status;
	if ((pid = fork()) < 0) {
		err_sys("fork error");
	}
	else if (pid == 0) /* child */
		exit(7);

	if (wait(&status) != pid) /* wait for child */
		err_sys("wait error");
	preStatus(status); /* and print its status */
	if ((pid = fork()) < 0) {
		err_sys("fork error");
	}
	else if (pid == 0) /* child */
		abort(); /* generates SIGABRT */
	if (wait(&status) != pid) /* wait for child */
		err_sys("wait error");

	preStatus(status); /* and print its status */
	if ((pid = fork()) < 0) {
		err_sys("fork error");
	}
	else if (pid == 0) /* child */
		status /= 0; /* divide by 0 generates SIGFPE */
	if (wait(&status) != pid) /* wait for child */
		err_sys("wait error");
	preStatus(status); /* and print its status */
	exit(0);
	

}


result:
└─$ ./tl.out
normal termination, exit status = 7
abnormal termination, signal number = 6
abnormal termination, signal number = 8

exec

该函数会创建一个进程，该进程完全取代原来的进程，从新进程的main开始执行

#include <unistd.h>
int execl(const char *pathname, const char arg0, … / (char *)0 */ );
int execv(const char *pathname, char *const argv[]);
int execle(const char *pathname, const char arg0, …
/ (char *)0, char *const envp[] */ );
int execve(const char *pathname, char *const argv[], char *const envp[]);
int execlp(const char *filename, const char arg0, … / (char *)0 */ );
int execvp(const char *filename, char *const argv[]);
int fexecve(int fd, char *const argv[], char *const envp[]);
All seven return: −1 on error, no return on success

在这里插入图片描述

#include "log/logx.h"
#include <error.h>
#include<sys/wait.h>
#include <sys/resource.h>
#include <string.h>
void test();

int main() {
	test();
}

void test() {
	if (execl("/usr/bin/cal", "cal",nullptr) < 0) {
		LOGXF("error", strerror(errno));
	}
	else LOGXA("start succeed");//this will not run ,because execl will use this process 
}
/*
┌──(kali㉿kali)-[~/…/TestLinux/bin/x64/Debug]
└─$ sudo ./TestLinux.out
     April 2022
Su Mo Tu We Th Fr Sa
                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

*/

用户标识

char *getlogin(void);
char *getuid(void);

#include "log/logx.h"
#include <error.h>
#include<sys/wait.h>

void test();

int main() {
	test();
}

void test() {
	LOGXA(VAR_DATA(getlogin()));
	LOGXA(VAR_DATA(getuid()));
}

进程调度

int nice(int incr);
Returns: new nice value − NZERO if OK, −1 on error
只会影响自己的值,不会影响其他进程的,incr越小优先级越大,系统会自动调整到合适的值

#include <sys/resource.h>
int getpriority(int which, id_t who);
Returns: nice value between −NZERO and NZERO−1 if OK, −1 on error

#include <sys/resource.h>
int setpriority(int which, id_t who, int value);
Returns: 0 if OK, −1 on error

#include "log/logx.h"
#include <error.h>
#include<sys/wait.h>
#include <sys/resource.h>

void test();

int main() {
	test();
}

void test() {
	int result = nice(20);
	LOGXA(VAR_DATA(result));
	result = getpriority(PRIO_PROCESS, 0);
	LOGXA(VAR_DATA(result));
	result= setpriority(PRIO_PROCESS, 0, 25);
	LOGXA(VAR_DATA(result));
	result = getpriority(PRIO_PROCESS, 0);
	LOGXA(VAR_DATA(result));
}

┌──(kali㉿kali)-[~/…/TestLinux/bin/x64/Debug]
└─$ ./TestLinux.out
[+] log construction, can use it  /home/kali/projects/TestLinux/bin/x64/Debug/_log/log.html
[0]09:01:18[info][140028126343552]      [test]  result:  19   (test_main.cpp:14)
[1]09:01:18[info][140028126343552]      [test]  result:  19   (test_main.cpp:16)
[2]09:01:18[info][140028126343552]      [test]  result:  0   (test_main.cpp:18)
[3]09:01:18[info][140028126343552]      [test]  result:  19   (test_main.cpp:20)
[+] ~log deconstruction

进程关系

进程组

pid_t getpgrp(void); //获取进程组的gid

#include "log/logx.h"
#include <error.h>
#include<sys/wait.h>
#include <sys/resource.h>
void test();

int main() {
	test();
}

void test() {
	while (true){
		LOGXD(getpgrp());
		std::this_thread::sleep_for(std::chrono::seconds(1));
	}
}
/*
┌──(kali㉿kali)-[~]
└─$ /home/kali/projects/TestLinux/bin/x64/Debug/TestLinux.out
[+] log construction, can use it  /home/kali/_log/log.html
[0]06:13:12[debg][140493772470080]      [test]  138810   (test_main.cpp:16)
[1]06:13:13[debg][140493772470080]      [test]  138810   (test_main.cpp:16)
[2]06:13:14[debg][140493772470080]      [test]  138810   (test_main.cpp:16)
[3]06:13:15[debg][140493772470080]      [test]  138810   (test_main.cpp:16)
[4]06:13:16[debg][140493772470080]      [test]  138810   (test_main.cpp:16)
[5]06:13:17[debg][140493772470080]      [test]  138810   (test_main.cpp:16)
[6]06:13:18[debg][140493772470080]      [test]  138810   (test_main.cpp:16)
[7]06:13:19[debg][140493772470080]      [test]  138810   (test_main.cpp:16)
[8]06:13:20[debg][140493772470080]      [test]  138810   (test_main.cpp:16)
[9]06:13:21[debg][140493772470080]      [test]  138810   (test_main.cpp:16)
[10]06:13:22[debg][140493772470080]     [test]  138810   (test_main.cpp:16)




root      138715  0.0  0.0      0     0 ?        I    06:10   0:00 [kworker/u64:2-events_unbound]
kali      138810  0.0  0.0   6028  1824 pts/3    S+   06:13   0:00 /home/kali/projects/TestLinux/bin/x64/Debug/TestLinux.out
kali      138812  0.0  0.1   9800  3628 pts/0    R+   06:13   0:00 ps -aux
*/

pid_t getpgid(pid_t pid);
getpgid(0) == getpgrp()
int setpgid(pid_t pid, pid_t pgid);

#include "log/logx.h"
#include <error.h>
#include<sys/wait.h>
#include <sys/resource.h>
void test();

int main() {
	test();
}

void test() {
	while (true){
		LOGXD(VAR_DATA(getpgid(0)),VAR_DATA(getpgrp()),VAR_DATA(getpgid(139656)));
		std::this_thread::sleep_for(std::chrono::seconds(1));
	}
}
/*
└─$ /home/kali/projects/TestLinux/bin/x64/Debug/TestLinux.out                                                                                    130 ⨯
[+] log construction, can use it  /home/kali/_log/log.html
[0]06:48:56[debg][140477147711296]      [test]  getpgid(0):  139942  getpgrp():  139942  getpgid(139656):  139641   (test_main.cpp:13)
[1]06:48:57[debg][140477147711296]      [test]  getpgid(0):  139942  getpgrp():  139942  getpgid(139656):  139641   (test_main.cpp:13)
[2]06:48:58[debg][140477147711296]      [test]  getpgid(0):  139942  getpgrp():  139942  getpgid(139656):  139641   (test_main.cpp:13)
[3]06:48:59[debg][140477147711296]      [test]  getpgid(0):  139942  getpgrp():  139942  getpgid(139656):  139641   (test_main.cpp:13)
[4]06:49:00[debg][140477147711296]      [test]  getpgid(0):  139942  getpgrp():  139942  getpgid(139656):  139641   (test_main.cpp:13)

*/
session

一个session由一个或多个进程组组成

pid_t setsid(void); 该进程如果不是进程组的组长，则会新建会话，如果该进程是组长了则返回错误，解决的办法是fork进程，然后子进程会有单独的pid

void test() {
	if (setsid() == -1) {
		auto pid=fork();
		if (pid == 0) {
			LOGXD("child", getpid());
			LOGXD(VAR_DATA(setsid()));
			LOGXD(VAR_DATA(getsid(getpgid(0))));
		}
		else {
			LOGXD("parent", getpid());
		}
	}
}


/*


└─$ ./TestLinux.out
[+] log construction, can use it  /home/kali/projects/TestLinux/bin/x64/Debug/_log/log.html
[+] log construction, can use it  /home/kali/projects/TestLinux/bin/x64/Debug/_log/log.html
[0]07:12:43[debg][140152152371584]      [test]  child  140575   (test_main.cpp:15)
[0]07:12:43[debg][140152152371584]      [test]  parent  140574   (test_main.cpp:21)
[1]07:12:43[debg][140152152371584]      [test]  setsid():  140575   (test_main.cpp:16)
[2]07:12:43[debg][140152152371584]      [test]  getsid(getpgid(0)):  140575   (test_main.cpp:17)
[+] ~log deconstruction
[+] ~log deconstruction

*/
controlling Terminal

会话会存在一个控制终端，让会话和控制终端联系的叫控制进程，每个控制终端将会话分成一个前台进程组和若干后台进程组

需要有一种方法来通知内核哪一个进程组是前台进程组，这样，终端设备驱动程序就能了解将终端输入和终端产生的信号送到何处。

#include <unistd.h>
pid_t tcgetpgrp(int filedes); //返回值：若成功则返回前台进程组的进程组ID，出错则返回-1.
int tcsetpgrp(int filedes, pid_t pgrpid); //返回值：成功则返回0，出错则返回-1.

void test() {
	LOGXD("now_process_group_id:", VAR_DATA(getpgrp()));
	LOGXD("pre_process_group_id:" VAR_DATA(tcgetpgrp(STDIN_FILENO)));
	if (tcsetpgrp(STDIN_FILENO, getpgrp()) == 0) {
		LOGXD("pre_process_group_id:" VAR_DATA(tcgetpgrp(STDIN_FILENO)));
	}
	else {
		LOGXW("set fail");
	}
}
/*

└─$ ./TestLinux.out
[+] log construction, can use it  /home/kali/projects/TestLinux/bin/x64/Debug/_log/log.html
[0]07:41:27[debg][139648735146368]      [test]  now_process_group_id:  getpgrp():  141108   (test_main.cpp:12)
[1]07:41:27[debg][139648735146368]      [test]  pre_process_group_id:tcgetpgrp(0):  141108   (test_main.cpp:13)
[2]07:41:27[debg][139648735146368]      [test]  pre_process_group_id:tcgetpgrp(0):  141108   (test_main.cpp:15)
[+] ~log deconstruction

*/
job control

后台运行： xx &—（在后面加上&）
查看后台程序：jobs
将后台转入前台：fg %[后台序号]

/*
┌──(kali㉿kali)-[~/…/TestLinux/bin/x64/Debug]
└─$ ./TestLinux.out &
[1] 141243

[+] log construction, can use it  /home/kali/projects/TestLinux/bin/x64/Debug/_log/log.html
[0]07:52:55[debg][140687585276288]      [test]  now_process_group_id:  getpgrp():  141243   (test_main.cpp:12)
[1]07:52:55[debg][140687585276288]      [test]  pre_process_group_id:tcgetpgrp(0):  137600   (test_main.cpp:13)
[1]  + suspended (tty output)  ./TestLinux.out
┌──(kali㉿kali)-[~/…/TestLinux/bin/x64/Debug]
└─$ jobs                                                                                                                                           1 ⚙
[1]  + suspended (tty output)  ./TestLinux.out

┌──(kali㉿kali)-[~/…/TestLinux/bin/x64/Debug]
└─$ fg %1                                                                                                                                          1 ⚙
[1]  + continued  ./TestLinux.out
[2]07:53:04[debg][140687585276288]      [test]  pre_process_group_id:tcgetpgrp(0):  141243   (test_main.cpp:15)
[+] ~log deconstruction

┌──(kali㉿kali)-[~/…/TestLinux/bin/x64/Debug]
└─$

*/

如果没有tcsetpgrp(STDIN_FILENO, getpgrp()) == 0这里，该程序是不会stop的，只因为设置了改进程是前台，但是他属于后台了，so

shell 执行程序
ps -o pid,ppid,pgid,sid,comm | cat1 | cat2

PID PPID PGID SID COMMAND
949 947 949 949 sh
1988 949 949 949 cat2
1989 1988 949 949 ps
1990 1988 949 949 cat1

在这里插入图片描述

linux——进程（process）
小顽固的博客
10-20 1274
在linux系统中，触发任何一个事件时，系统都会将它定义为一个进程，并且给予该进程一个ID称为PID，同时依据启发该进程的用户与相关属性关系，给予这个PID一组有效的权限设定。 1、进程与程序 执行一个程序或指令就产生一个进程，获得一个PID，程序一般是存放在实体磁盘中，透过用户的执行来触发，触发后会加载到内存中成为一个个体，这就是进程，程序被触发后，执行者的权限与属性、程序的程序代码与所需数...
【Linux】进程 Process
最新发布
ciweic的博客
01-15 734
进程和程序的区别。
linux进程控制：process_control
10-21
计算机操作系统的第二个实验：1用fork（）创建两个进程，重复显示某字符；2，创建一个进程，并调用exec覆盖代码，显示new program。
process_control
weixin_30555125的博客
04-17 146
1 进程控制 2 3 ps aux 4 ps axj 5 ps axf 6 ps axm 7 8 一.进程标识符 9 pid_t ---->long int 10 进程的独一无二的标识 11 12 0 调用进程（内核） 13 1 init进程（用户态所有进程的祖先进程） ...
Linux - Process
liqingbing12的专栏
09-09 571
查看具体进程的pid pidof [process name] eg: $pidof rpcbind 54965 查看Core文件的pattern cat /proc/sys/kernel/core_pattern 查看具体进程的Linux资源限制 $cat /proc/`pidof rpcbind`/limits Limit Sof...
Day33 进程Process
hengheng114514的博客
02-22 989
进程和程序的区别。
oracle_db_process.zip_linux oracle_oracle
09-22
在这个“oracle_db_process.zip_linux oracle_oracle”压缩包中，包含的“dbprocess.c”和“dbprocess.h”文件可能是一个C语言编写的程序，用于与Oracle数据库进行交互，执行数据处理任务。现在，我们将深入探讨在...
CUDA_Multi_Process_Service_Overview.pdf
12-23
CUDA多进程服务（CUDA Multi-Process Service，简称MPS）是CUDA框架中的一个重要组件，专为提高多进程环境下GPU利用率和执行效率而设计。本文档主要介绍CUDA MPS的概述。 在了解CUDA MPS之前，首先需要了解MPS的...
linux WPA_supplicant
伊伊_f
11-27 1043
1.wpa_supplicant软件架构分析https://www.cnblogs.com/oracleloyal/p/5564786.html 2.wpa_supplicant-2.6移植 2.1libnl-1.1.4 (1)source code:https://pan.baidu.com/s/1mwni0CtOFA7tcPJFGg3F7Q (2)解压 $sudo tar -xvf *.gz ...
linux 进程 process,Linux启动过程（Linux boot process）
weixin_33329746的博客
04-28 822
Linux启动过程----By Joseph Griffiths这篇文档将从Linux的角度记录x86的引导过程。它将试图提供一个技术性的概述。所以，如果对十进制，八进制或者二进制不熟悉，你可以先温习一下它们。启动顺序基本输入输出(BIOS)完成自检(内存，中央处理器，磁盘)。BIOS执行MBR中的主引导代码。主引导代码中有两个功能(function)：识别所有活跃分区(active partit...
linux_process_mgt
03-28
slides about linux kernel porcess management.
linux 进程 process,Linux Process Manage
weixin_36060333的博客
04-28 386
Linux 下的工作都是依靠进程来执行的，控制了进程就相当于控制了 Linux 系统了。这篇博客将通过 Linux 系统的启动登录来探讨进程管理机制，看这种机制如何支撑和左右进程的命运。什么是进程先来了解了解什么是进程，程序这个词比较好理解，通常的程序是静态实体，进程是正在运行的程序实体，并且包括这个运行的程序中占据的所有系统资源，比如说CPU(寄存器)，IO，内存，网络资源等。进程描述符(PID...
Linux——Process(进程)相关命令——ps、nice、kill、bg&fg
m0_46156900的博客
06-14 1552
文章目录Process简单认识几个关于Linux Process的重要角色细心地，有个问题：psnicekillbg&fg Process简单认识 进程就是被执行的程序。 每个进程都是一个运行的实体， 都有自己的地址空间，并占用一定的系统资源。 口说话地说： 就好比， 写了一份活动策划书(程序代码)， 然后 ，让相关人员(比如操作系统) 按照策划书，有条不紊地举行活动（进程） 换专业一点点的说： 程序，是人类用编程语言编写的，可实现一定功能，并且可执行的代码集合。 而进程是正在执行中的程序
Linux系统编程之进程基础(PROCESS)
冯同学的博客
06-11 329
ps aux 查看进程详细信息 Linux中printf中加\n，表示强制刷新IO缓冲区
专业知识 | 操作系统与网络 | 4. Linux进程（process）
Mind and Hand
05-24 1465
不期待突如其来的好运， 只希望所有的努力终有回报！ 4. Linux进程（process） 4.1 冯诺依曼体系结构 4.1.1 计算机的四个主要结构化部件 （1）处理器（propcessor） 控制计算机的操作，执行数据处理功能，通常指CPU（中央处理器）； 通常使用两个内部存储器：存储器地址寄存器（确定下一次读写的存储器地址）和存储器缓冲寄存器（存放要写入存储器的数据或者从存储器中读取的数据）； （2）内存（main memory） 内存通常称为实存储器（real memory）或主存储器（prim.
linux下的进程（process）相关概念(定义、组成、状态、PCB、分类（僵尸、孤儿、守护进程）、进程的监控（查看命令）)及软件开发相关面试问题
JMW1407的博客
06-25 1542
linux下的进程创建相关API函数进程（process）1、进程定义2、进程的分类3、进程状态4、进程的组成4.1、正文段（text）和用户数据段4.2、PCB进程控制块参考 进程（process） 1、进程定义 进程是 Unix 和 Linux 系统中对正在运行中的应用程序的抽象，通过它可以管理和监视程序对内存、处理器时间和 I / O资源的使用。程序被触发后，执行者的权限与属性、程序的程序代码与所需数据等都会被加载内存中，操 作系统并给予这个内存内的单元一个标识符 (PID)，可以说，进程就是一个正
【Linux】什么是进程(process)？
DEXTERFUTIAN的博客
06-06 1959
了解什么是进程？进程与程序概念 描述进程-PCB、Windows进程与Linux进程、Linux进程操作子进程父进程、创建进程fork的使用
在linux中进程process表示的是,linux中关于进程那些事
weixin_29251131的博客
05-08 881
进程(Process)是系统进行资源分配和调度的基本单位，一个进程是一个程序的运行实例。而在Linux中，可以使用一个进程来创建另外一个进程。进程和程序是有本质区别的：进程是一个程序的一次执行过程，同时也是资源分配的最小单元。程序是静态的，它是一些保存在磁盘上的指令的有序集合，没有任何执行的概念；而进程是一个动态的概念，它是程序执行的过程，包括了动态创建、调度和消亡的整个过程。Linux操作系统包...
关于进程
道常无为
02-18 406
关于进程 process 什么是进程？ 进程是已启动的可执行程序的运行实例，进程有以下组成部分： • 已分配内存的地址空间； • 安全属性，包括所有权凭据和特权； • 程序代码的一个或多个执行线程； • 进程状态。 程序： 二进制文件，静态 /bin/date, /usr/sbin/httpd，/usr/sbin/sshd, /usr/local/nginx/sbin/ngix 进
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值