Search     or:     and:
 LINUX 
 Language 
 Kernel 
 Package 
 Book 
 Test 
 OS 
 Forum 
 iakovlev.org 
 Books
  Краткое описание
 Linux
 W. R. Стивенс TCP 
 W. R. Стивенс IPC 
 A.Rubini-J.Corbet 
 K. Bauer 
 Gary V. Vaughan 
 Д Вилер 
 В. Сталлинг 
 Pramode C.E. 
 Steve Pate 
 William Gropp 
 K.A.Robbins 
 С Бекман 
 Р Стивенс 
 Ethereal 
 Cluster 
 Languages
 C
 Perl
 M.Pilgrim 
 А.Фролов 
 Mendel Cooper 
 М Перри 
 Kernel
 C.S. Rodriguez 
 Robert Love 
 Daniel Bovet 
 Д Джеф 
 Максвелл 
 G. Kroah-Hartman 
 B. Hansen 
NEWS
Последние статьи :
  Rust 07.11   
  Go 25.12   
  EXT4 10.11   
  FS benchmark 15.09   
  Сетунь 23.07   
  Trees 25.06   
  Apache 03.02   
  SQL 30.07   
  JFS 10.06   
  B-trees 01.06   
 
TOP 20
 Go Web ...756 
 Httpd-> История Ap...491 
 2.0-> Linux IP Networking...366 
 MySQL & PosgreSQL...334 
 Trees...334 
 Secure Programming for Li...331 
 Assembler...266 
 Secure Programming for Li...237 
 TCP 2...236 
 Mod_perl 1...229 
 Steve Pate 3...218 
 Advanced Bash Scripting G...208 
 Linux Inline Assembly...201 
 Максвелл 3...199 
 Steve Pate 1...196 
 Python...195 
 Cluster 3...194 
 Rodriguez 8...193 
 Rubni-Corbet -> Глав...192 
 Mod_perl 2...185 
 
  01.06.2017 : 2215600 посещений 

iakovlev.org

Глава 11 , Семафоры System V

Исходники для этой страницы лежат тут

Семафоры бывают :

       
 	1 Бинарные , т.е. могут приобретать только 2 значения - 1 и 0
 	2 Счетчики , принимающие значения от 0 до некоторого значения
 	3 Набор семафоров-счетчиков ограниченного количества . для каждого такого набора
 		поддерживается структура semid_ds. Каждый элемент этой структуры
 		описывается с помощью другой структуры - sem .
 
Помимо этого , для каждого семафора ядро хранит 3 поля
       
 	1 id последнего процесса ,	изменившего процесс 
 	2 число процессов , ждущих , когда семафор увеличит значение
 	3 число процессов , ждущих , когда семафор обнулится
 
Если в структуре 2 семафора , то она выглядит примерно так :

Функция semget создает набор семафоров либо открывает доступ к уже существующим :

       
 	int semget(key_t key,int nsems,int flag)
 
    Возвращает положительный идентификатор в случае успеха ,
    который в дальнейшем будет использоваться функциями semop и semctl 
    
 	nsems задает число семафоров
 	
 	флаг - на чтение-запись
 	
 
Функция semop позволяет выполнить некоторые действия с созданным семафором .
       
 	int semop(int semid , struct sembuf *ptr , size_t s)
 
 	Указатель ptr указывает на массив структур sembuf
 
Число элементов в массиве sembuf задается 3-м параметром. Каждый элемент этого массива определяет операцию с одним конкретным семафором . sem_num - номер семафора . Каждая операция задается sem_op , которое может быть отрицательным , нулевым или положительным .
       
  struct sem {
 	ushort_t semval ; // значение семафора
 	short sempid;     // pid последнего процесса , вызвавшего semop() , SETVAL , SETALL
 	ushort_t semncnt; // количество ожидающих того , что значение превысит текущее
 	ushort_t semzcnt; // число ожидающих того , что значение семафора станет равным 0  
 	}
 
semop - медленный системный вызов , который прерывается перехватываемыми сигналами . Если семафор во время операции удаляется , semop возвращает ошибку .

В зависимости от того , каким является аргумент sem_op - отрицательным , нулем или положительным - поведение функции semop будет следующее :

       
 	1  Если sem_op > 0 , оно добавляется к semval . Это равносильно освобождению ресурсов , 
 		 захваченных семафором . Если указан флаг SEM_UNDO , значение semop вычитается .
 	2  Если sem_op = 0 , вызвавший поток блокируется до тех пор , пока знвчение semval
 		не станет равным нулю . Если semval = 0 , происходит возвращение из функции . 
 	3 Если sem_op < 0 , поток блокируется , пока semval не станет большим либо равным модулю sem_op.
 		Это равносильно запросу ресурса .
 		Если semval больше либо равно модулю sem_op , sem_op вычитается из semval .
 
Функция semctl выполняет управляющие операции :
       
 	int semctl(int semid , int semnum , int cmd , union semum arg
 
 	Возвращает положительное число в случае успеха
 
Четвертый аргумент - дополнительный , добавляется в зависимости от команды cmd :
       
 	union semun{
 		int val;
 		struct semid_ds *buf;
 		ushort *array;
 		}
 
Его нужно декларировать в приложении . Оно передается по значению . Аргумент cmd может приобретать значения :
       
 	GETVAL 
 	SETVAL 
 	GETPID 
 	GETNCNT 
 	GETZCNT 
 	GETALL 
 	SETALL 
 	IPC_RMID
 	IPC_SET
 	IPC_STAT 
 
Программа semcreate создает набор семафоров - флаг -e соответствует IPC_EXCL при вызове semget :
       
 //svsem/semcreate.c
 
 int
 main(int argc, char **argv)
 {
 	int		c, oflag, semid, nsems;
 
 	oflag = SVSEM_MODE | IPC_CREAT;
 	while ( (c = Getopt(argc, argv, "e")) != -1) {
 		switch (c) {
 		case 'e':
 			oflag |= IPC_EXCL;
 			break;
 		}
 	}
 	if (optind != argc - 2)
 		err_quit("usage: semcreate [ -e ] < pathname> < nsems>");
 	nsems = atoi(argv[optind + 1]);
 
 	semid = Semget(Ftok(argv[optind], 0), nsems, oflag);
 	exit(0);
 }
 	
 
Программа semrmid удаляет набор семафоров , для этого используется semctl с флагом IPC_RMID :
       
 int
 main(int argc, char **argv)
 {
 	int		semid;
 
 	if (argc != 2)
 		err_quit("usage: semrmid < pathname>");
 
 	semid = Semget(Ftok(argv[1], 0), 0, 0);
 	Semctl(semid, 0, IPC_RMID);
 
 	exit(0);
 }
 
 
Программа semsetvalues устанавливает значения семафоров . Вызываются semget , потом semctl с флагом IPC_STAT
       
 	int
 main(int argc, char **argv)
 {
 	int		semid, nsems, i;
 	struct semid_ds	seminfo;
 	unsigned short	*ptr;
 	union semun	arg;
 
 	if (argc < 2)
 		err_quit("usage: semsetvalues < pathname> [ values ... ]");
 
 		/* 4first get the number of semaphores in the set */
 	semid = Semget(Ftok(argv[1], 0), 0, 0);
 	arg.buf = &seminfo;
 	Semctl(semid, 0, IPC_STAT, arg);
 	nsems = arg.buf->sem_nsems;
 
 		/* 4now get the values from the command line */
 	if (argc != nsems + 2)
 		err_quit("%d semaphores in set, %d values specified", nsems, argc-2);
 
 		/* 4allocate memory to hold all the values in the set, and store */
 	ptr = Calloc(nsems, sizeof(unsigned short));
 	arg.array = ptr;
 	for (i = 0; i < nsems; i++)
 		ptr[i] = atoi(argv[i + 2]);
 	Semctl(semid, 0, SETALL, arg);
 
 	exit(0);
 }
 
 
Программа semgetvalues получает значения семафоров :
       
 int
 main(int argc, char **argv)
 {
 	int		semid, nsems, i;
 	struct semid_ds	seminfo;
 	unsigned short	*ptr;
 	union semun	arg;
 
 	if (argc != 2)
 		err_quit("usage: semgetvalues < pathname>");
 
 		/* 4first get the number of semaphores in the set */
 	semid = Semget(Ftok(argv[1], 0), 0, 0);
 	arg.buf = &seminfo;
 	Semctl(semid, 0, IPC_STAT, arg);
 	nsems = arg.buf->sem_nsems;
 
 		/* 4allocate memory to hold all the values in the set */
 	ptr = Calloc(nsems, sizeof(unsigned short));
 	arg.array = ptr;
 
 		/* 4fetch the values and print */
 	Semctl(semid, 0, GETALL, arg);
 	for (i = 0; i < nsems; i++)
 		printf("semval[%d] = %d\n", i, ptr[i]);
 
 	exit(0);
 }
 
 
Программа semops запускается с флагом -n , что соответствует флагу IPC_NOWAIT , параметр -u соответствует флагу SEM_UNDO.
       
 int
 main(int argc, char **argv)
 {
 	int		c, i, flag, semid, nops;
 	struct sembuf	*ptr;
 
 	flag = 0;
 	while ( (c = Getopt(argc, argv, "nu")) != -1) {
 		switch (c) {
 		case 'n':
 			flag |= IPC_NOWAIT;		/* for each operation */
 			break;
 
 		case 'u':
 			flag |= SEM_UNDO;		/* for each operation */
 			break;
 		}
 	}
 	if (argc - optind < 2)			/* argc - optind = #args remaining */
 		err_quit("usage: semops [ -n ] [ -u ]  operation ...");
 
 	semid = Semget(Ftok(argv[optind], 0), 0, 0);
 	optind++;
 	nops = argc - optind;
 
 		/* 4allocate memory to hold operations, store, and perform */
 	ptr = Calloc(nops, sizeof(struct sembuf));
 	for (i = 0; i < nops; i++) {
 		ptr[i].sem_num = i;
 		ptr[i].sem_op = atoi(argv[optind + i]);	/* <0, 0, or >0 */
 		ptr[i].sem_flg = flag;
 	}
 	Semop(semid, ptr, nops);
 
 	exit(0);
 }
 	
 
Теперь запустим цепочку команд :
       
  touch /tmp/rich
  ./semcreate -e /tmp/rich 3
  ./semsetvalues  /tmp/rich 1 2 3
  ./semgetvalues  /tmp/rich
 
 Вывод :
 
 semval[0] = 1
 semval[1] = 2
 semval[2] = 3
 
 Далее выполним :
 
 ./semops -n /tmp/rich 1 2 3
 ./semgetvalues  /tmp/rich
 
 Вывод :
 
 semval[0] = 2
 semval[1] = 4
 semval[2] = 6
 
 
На семафоры System V накладываются ограничения . В следующей таблице в первом столбике - переменная ядра , хранящая ограничение :

Следующая система определяет ограничения для системы :

       
 	int
 main(int argc, char **argv)
 {
 	int		i, j, semid, sid[MAX_NIDS], pipefd[2];
 	int		semmni, semvmx, semmsl, semmns, semopn, semaem, semume, semmnu;
 	pid_t	*child;
 	union semun	arg;
 	struct sembuf	ops[MAX_NOPS];
 
 		/* 4see how many sets with one member we can create */
 	for (i = 0; i <= MAX_NIDS; i++) {
 		sid[i] = semget(IPC_PRIVATE, 1, SVSEM_MODE | IPC_CREAT);
 		if (sid[i] == -1) {
 			semmni = i;
 			printf("%d identifiers open at once\n", semmni);
 			break;
 		}
 	}
 		/* 4before deleting, find maximum value using sid[0] */
 	for (j = 7; j < MAX_VALUE; j += 8) {
 		arg.val = j;
 		if (semctl(sid[0], 0, SETVAL, arg) == -1) {
 			semvmx = j - 8;
 			printf("max semaphore value = %d\n", semvmx);
 			break;
 		}
 	}
 	for (j = 0; j < i; j++)
 		Semctl(sid[j], 0, IPC_RMID);
 
 		/* 4determine max # semaphores per semaphore set */
 	for (i = 1; i <= MAX_MEMBERS; i++) {
 		semid = semget(IPC_PRIVATE, i, SVSEM_MODE | IPC_CREAT);
 		if (semid == -1) {
 			semmsl = i-1;
 			printf("max of %d members per set\n", semmsl);
 			break;
 		}
 		Semctl(semid, 0, IPC_RMID);
 	}
 
 		/* 4find max of total # of semaphores we can create */
 	semmns = 0;
 	for (i = 0; i < semmni; i++) {
 		sid[i] = semget(IPC_PRIVATE, semmsl, SVSEM_MODE | IPC_CREAT);
 		if (sid[i] == -1) {
 /* $$.bp$$ */
 			/*
 			 * Up to this point each set has been created with semmsl
 			 * members.  But this just failed, so try recreating this
 			 * final set with one fewer member per set, until it works.
 			 */
 			for (j = semmsl-1; j > 0; j--) {
 				sid[i] = semget(IPC_PRIVATE, j, SVSEM_MODE | IPC_CREAT);
 				if (sid[i] != -1) {
 					semmns += j;
 					printf("max of %d semaphores\n", semmns);
 					Semctl(sid[i], 0, IPC_RMID);
 					goto done;
 				}
 			}
 			err_quit("j reached 0, semmns = %d", semmns);
 		}
 		semmns += semmsl;
 	}
 	printf("max of %d semaphores\n", semmns);
 done:
 	for (j = 0; j < i; j++)
 		Semctl(sid[j], 0, IPC_RMID);
 
 		/* 4see how many operations per semop() */
 	semid = Semget(IPC_PRIVATE, semmsl, SVSEM_MODE | IPC_CREAT);
 	for (i = 1; i <= MAX_NOPS; i++) {
 		ops[i-1].sem_num = i-1;
 		ops[i-1].sem_op = 1;
 		ops[i-1].sem_flg = 0;
 		if (semop(semid, ops, i)  == -1) {
 			if (errno != E2BIG)
 				err_sys("expected E2BIG from semop");
 			semopn = i-1;
 			printf("max of %d operations per semop()\n", semopn);
 			break;
 		}
 	}
 	Semctl(semid, 0, IPC_RMID);
 
 		/* 4determine the max value of semadj */
 		/* 4create one set with one semaphore */
 	semid = Semget(IPC_PRIVATE, 1, SVSEM_MODE | IPC_CREAT);
 	arg.val = semvmx;
 	Semctl(semid, 0, SETVAL, arg);		/* set value to max */
 	for (i = semvmx-1; i > 0; i--) {
 		ops[0].sem_num = 0;
 		ops[0].sem_op = -i;
 		ops[0].sem_flg = SEM_UNDO;
 		if (semop(semid, ops, 1)  != -1) {
 			semaem = i;
 			printf("max value of adjust-on-exit = %d\n", semaem);
 			break;
 		}
 	}
 	Semctl(semid, 0, IPC_RMID);
 /* $$.bp$$ */
 		/* 4determine max # undo structures */
 		/* 4create one set with one semaphore; init to 0 */
 	semid = Semget(IPC_PRIVATE, 1, SVSEM_MODE | IPC_CREAT);
 	arg.val = 0;
 	Semctl(semid, 0, SETVAL, arg);		/* set semaphore value to 0 */
 	Pipe(pipefd);
 	child = Malloc(MAX_NPROC * sizeof(pid_t));
 	for (i = 0; i < MAX_NPROC; i++) {
 		if ( (child[i] = fork()) == -1) {
 			semmnu = i - 1;
 			printf("fork failed, semmnu at least %d\n", semmnu);
 			break;
 		} else if (child[i] == 0) {
 			ops[0].sem_num = 0;			/* child does the semop() */
 			ops[0].sem_op = 1;
 			ops[0].sem_flg = SEM_UNDO;
 			j = semop(semid, ops, 1);	/* 0 if OK, -1 if error */
 			Write(pipefd[1], &j, sizeof(j));
 			sleep(30);					/* wait to be killed by parent */
 			exit(0);					/* just in case */
 		}
 		/* parent reads result of semop() */
 		Read(pipefd[0], &j, sizeof(j));
 		if (j == -1) {
 			semmnu = i;
 			printf("max # undo structures = %d\n", semmnu);
 			break;
 		}
 	}
 	Semctl(semid, 0, IPC_RMID);
 	for (j = 0; j <= i && child[j] > 0; j++)
 		Kill(child[j], SIGINT);
 
 		/* 4determine max # adjust entries per process */
 		/* 4create one set with max # of semaphores */
 	semid = Semget(IPC_PRIVATE, semmsl, SVSEM_MODE | IPC_CREAT);
 	for (i = 0; i < semmsl; i++) {
 		arg.val = 0;
 		Semctl(semid, i, SETVAL, arg);		/* set semaphore value to 0 */
 
 		ops[i].sem_num = i;
 		ops[i].sem_op = 1;					/* add 1 to the value */
 		ops[i].sem_flg = SEM_UNDO;
 		if (semop(semid, ops, i+1) == -1) {
 			semume = i;
 			printf("max # undo entries per process = %d\n", semume);
 			break;
 		}
 	}
 	Semctl(semid, 0, IPC_RMID);
 
 	exit(0);
 }
 
  
 
Оставьте свой комментарий !

Ваше имя:
Комментарий:
Оба поля являются обязательными

 Автор  Комментарий к данной статье