Something went wrong. Try again.
(I'm so sorry!) Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
Something went wrong. Try again.
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475// SPDX-License-Identifier: GPL-2.0-or-later/* * Various unit tests for the "ntsync" synchronization primitive driver. * * Copyright (C) 2021-2022 Elizabeth Figura <zfigura@codeweavers.com> */
#define _GNU_SOURCE#include <sys/ioctl.h>#include <sys/stat.h>#include <sys/wait.h>#include <fcntl.h>#include <sched.h>#include <time.h>#include <pthread.h>#include <linux/ntsync.h>#include "kselftest_harness.h"
#ifndef CLONE_NEWTIME#define CLONE_NEWTIME 0x00000080#endif
static int read_sem_state(int sem, __u32 *count, __u32 *max){ struct ntsync_sem_args args; int ret;
memset(&args, 0xcc, sizeof(args)); ret = ioctl(sem, NTSYNC_IOC_SEM_READ, &args); *count = args.count; *max = args.max; return ret;}
#define check_sem_state(sem, count, max) \ ({ \ __u32 __count, __max; \ int ret = read_sem_state((sem), &__count, &__max); \ EXPECT_EQ(0, ret); \ EXPECT_EQ((count), __count); \ EXPECT_EQ((max), __max); \ })
static int release_sem(int sem, __u32 *count){ return ioctl(sem, NTSYNC_IOC_SEM_RELEASE, count);}
static int read_mutex_state(int mutex, __u32 *count, __u32 *owner){ struct ntsync_mutex_args args; int ret;
memset(&args, 0xcc, sizeof(args)); ret = ioctl(mutex, NTSYNC_IOC_MUTEX_READ, &args); *count = args.count; *owner = args.owner; return ret;}
#define check_mutex_state(mutex, count, owner) \ ({ \ __u32 __count, __owner; \ int ret = read_mutex_state((mutex), &__count, &__owner); \ EXPECT_EQ(0, ret); \ EXPECT_EQ((count), __count); \ EXPECT_EQ((owner), __owner); \ })
static int unlock_mutex(int mutex, __u32 owner, __u32 *count){ struct ntsync_mutex_args args; int ret;
args.owner = owner; args.count = 0xdeadbeef; ret = ioctl(mutex, NTSYNC_IOC_MUTEX_UNLOCK, &args); *count = args.count; return ret;}
static int read_event_state(int event, __u32 *signaled, __u32 *manual){ struct ntsync_event_args args; int ret;
memset(&args, 0xcc, sizeof(args)); ret = ioctl(event, NTSYNC_IOC_EVENT_READ, &args); *signaled = args.signaled; *manual = args.manual; return ret;}
#define check_event_state(event, signaled, manual) \ ({ \ __u32 __signaled, __manual; \ int ret = read_event_state((event), &__signaled, &__manual); \ EXPECT_EQ(0, ret); \ EXPECT_EQ((signaled), __signaled); \ EXPECT_EQ((manual), __manual); \ })
static int wait_objs(int fd, unsigned long request, __u32 count, const int *objs, __u32 owner, int alert, __u32 *index){ struct ntsync_wait_args args = {0}; struct timespec timeout; int ret;
clock_gettime(CLOCK_MONOTONIC, &timeout);
args.timeout = timeout.tv_sec * 1000000000 + timeout.tv_nsec; args.count = count; args.objs = (uintptr_t)objs; args.owner = owner; args.index = 0xdeadbeef; args.alert = alert; ret = ioctl(fd, request, &args); *index = args.index; return ret;}
static int wait_any(int fd, __u32 count, const int *objs, __u32 owner, __u32 *index){ return wait_objs(fd, NTSYNC_IOC_WAIT_ANY, count, objs, owner, 0, index);}
static int wait_all(int fd, __u32 count, const int *objs, __u32 owner, __u32 *index){ return wait_objs(fd, NTSYNC_IOC_WAIT_ALL, count, objs, owner, 0, index);}
static int wait_any_alert(int fd, __u32 count, const int *objs, __u32 owner, int alert, __u32 *index){ return wait_objs(fd, NTSYNC_IOC_WAIT_ANY, count, objs, owner, alert, index);}
static int wait_all_alert(int fd, __u32 count, const int *objs, __u32 owner, int alert, __u32 *index){ return wait_objs(fd, NTSYNC_IOC_WAIT_ALL, count, objs, owner, alert, index);}
TEST(semaphore_state){ struct ntsync_sem_args sem_args; struct timespec timeout; __u32 count, index; int fd, ret, sem;
clock_gettime(CLOCK_MONOTONIC, &timeout);
fd = open("/dev/ntsync", O_CLOEXEC | O_RDONLY); ASSERT_LE(0, fd);
sem_args.count = 3; sem_args.max = 2; sem = ioctl(fd, NTSYNC_IOC_CREATE_SEM, &sem_args); EXPECT_EQ(-1, sem); EXPECT_EQ(EINVAL, errno);
sem_args.count = 2; sem_args.max = 2; sem = ioctl(fd, NTSYNC_IOC_CREATE_SEM, &sem_args); EXPECT_LE(0, sem); check_sem_state(sem, 2, 2);
count = 0; ret = release_sem(sem, &count); EXPECT_EQ(0, ret); EXPECT_EQ(2, count); check_sem_state(sem, 2, 2);
count = 1; ret = release_sem(sem, &count); EXPECT_EQ(-1, ret); EXPECT_EQ(EOVERFLOW, errno); check_sem_state(sem, 2, 2);
ret = wait_any(fd, 1, &sem, 123, &index); EXPECT_EQ(0, ret); EXPECT_EQ(0, index); check_sem_state(sem, 1, 2);
ret = wait_any(fd, 1, &sem, 123, &index); EXPECT_EQ(0, ret); EXPECT_EQ(0, index); check_sem_state(sem, 0, 2);
ret = wait_any(fd, 1, &sem, 123, &index); EXPECT_EQ(-1, ret); EXPECT_EQ(ETIMEDOUT, errno);
count = 3; ret = release_sem(sem, &count); EXPECT_EQ(-1, ret); EXPECT_EQ(EOVERFLOW, errno); check_sem_state(sem, 0, 2);
count = 2; ret = release_sem(sem, &count); EXPECT_EQ(0, ret); EXPECT_EQ(0, count); check_sem_state(sem, 2, 2);
ret = wait_any(fd, 1, &sem, 123, &index); EXPECT_EQ(0, ret); ret = wait_any(fd, 1, &sem, 123, &index); EXPECT_EQ(0, ret);
count = 1; ret = release_sem(sem, &count); EXPECT_EQ(0, ret); EXPECT_EQ(0, count); check_sem_state(sem, 1, 2);
count = ~0u; ret = release_sem(sem, &count); EXPECT_EQ(-1, ret); EXPECT_EQ(EOVERFLOW, errno); check_sem_state(sem, 1, 2);
close(sem);
close(fd);}
TEST(mutex_state){ struct ntsync_mutex_args mutex_args; __u32 owner, count, index; struct timespec timeout; int fd, ret, mutex;
clock_gettime(CLOCK_MONOTONIC, &timeout);
fd = open("/dev/ntsync", O_CLOEXEC | O_RDONLY); ASSERT_LE(0, fd);
mutex_args.owner = 123; mutex_args.count = 0; mutex = ioctl(fd, NTSYNC_IOC_CREATE_MUTEX, &mutex_args); EXPECT_EQ(-1, mutex); EXPECT_EQ(EINVAL, errno);
mutex_args.owner = 0; mutex_args.count = 2; mutex = ioctl(fd, NTSYNC_IOC_CREATE_MUTEX, &mutex_args); EXPECT_EQ(-1, mutex); EXPECT_EQ(EINVAL, errno);
mutex_args.owner = 123; mutex_args.count = 2; mutex = ioctl(fd, NTSYNC_IOC_CREATE_MUTEX, &mutex_args); EXPECT_LE(0, mutex); check_mutex_state(mutex, 2, 123);
ret = unlock_mutex(mutex, 0, &count); EXPECT_EQ(-1, ret); EXPECT_EQ(EINVAL, errno);
ret = unlock_mutex(mutex, 456, &count); EXPECT_EQ(-1, ret); EXPECT_EQ(EPERM, errno); check_mutex_state(mutex, 2, 123);
ret = unlock_mutex(mutex, 123, &count); EXPECT_EQ(0, ret); EXPECT_EQ(2, count); check_mutex_state(mutex, 1, 123);
ret = unlock_mutex(mutex, 123, &count); EXPECT_EQ(0, ret); EXPECT_EQ(1, count); check_mutex_state(mutex, 0, 0);
ret = unlock_mutex(mutex, 123, &count); EXPECT_EQ(-1, ret); EXPECT_EQ(EPERM, errno);
ret = wait_any(fd, 1, &mutex, 456, &index); EXPECT_EQ(0, ret); EXPECT_EQ(0, index); check_mutex_state(mutex, 1, 456);
ret = wait_any(fd, 1, &mutex, 456, &index); EXPECT_EQ(0, ret); EXPECT_EQ(0, index); check_mutex_state(mutex, 2, 456);
ret = unlock_mutex(mutex, 456, &count); EXPECT_EQ(0, ret); EXPECT_EQ(2, count); check_mutex_state(mutex, 1, 456);
ret = wait_any(fd, 1, &mutex, 123, &index); EXPECT_EQ(-1, ret); EXPECT_EQ(ETIMEDOUT, errno);
owner = 0; ret = ioctl(mutex, NTSYNC_IOC_MUTEX_KILL, &owner); EXPECT_EQ(-1, ret); EXPECT_EQ(EINVAL, errno);
owner = 123; ret = ioctl(mutex, NTSYNC_IOC_MUTEX_KILL, &owner); EXPECT_EQ(-1, ret); EXPECT_EQ(EPERM, errno); check_mutex_state(mutex, 1, 456);
owner = 456; ret = ioctl(mutex, NTSYNC_IOC_MUTEX_KILL, &owner); EXPECT_EQ(0, ret);
memset(&mutex_args, 0xcc, sizeof(mutex_args)); ret = ioctl(mutex, NTSYNC_IOC_MUTEX_READ, &mutex_args); EXPECT_EQ(-1, ret); EXPECT_EQ(EOWNERDEAD, errno); EXPECT_EQ(0, mutex_args.count); EXPECT_EQ(0, mutex_args.owner);
memset(&mutex_args, 0xcc, sizeof(mutex_args)); ret = ioctl(mutex, NTSYNC_IOC_MUTEX_READ, &mutex_args); EXPECT_EQ(-1, ret); EXPECT_EQ(EOWNERDEAD, errno); EXPECT_EQ(0, mutex_args.count); EXPECT_EQ(0, mutex_args.owner);
ret = wait_any(fd, 1, &mutex, 123, &index); EXPECT_EQ(-1, ret); EXPECT_EQ(EOWNERDEAD, errno); EXPECT_EQ(0, index); check_mutex_state(mutex, 1, 123);
owner = 123; ret = ioctl(mutex, NTSYNC_IOC_MUTEX_KILL, &owner); EXPECT_EQ(0, ret);
memset(&mutex_args, 0xcc, sizeof(mutex_args)); ret = ioctl(mutex, NTSYNC_IOC_MUTEX_READ, &mutex_args); EXPECT_EQ(-1, ret); EXPECT_EQ(EOWNERDEAD, errno); EXPECT_EQ(0, mutex_args.count); EXPECT_EQ(0, mutex_args.owner);
ret = wait_any(fd, 1, &mutex, 123, &index); EXPECT_EQ(-1, ret); EXPECT_EQ(EOWNERDEAD, errno); EXPECT_EQ(0, index); check_mutex_state(mutex, 1, 123);
close(mutex);
mutex_args.owner = 0; mutex_args.count = 0; mutex = ioctl(fd, NTSYNC_IOC_CREATE_MUTEX, &mutex_args); EXPECT_LE(0, mutex); check_mutex_state(mutex, 0, 0);
ret = wait_any(fd, 1, &mutex, 123, &index); EXPECT_EQ(0, ret); EXPECT_EQ(0, index); check_mutex_state(mutex, 1, 123);
close(mutex);
mutex_args.owner = 123; mutex_args.count = ~0u; mutex = ioctl(fd, NTSYNC_IOC_CREATE_MUTEX, &mutex_args); EXPECT_LE(0, mutex); check_mutex_state(mutex, ~0u, 123);
ret = wait_any(fd, 1, &mutex, 123, &index); EXPECT_EQ(-1, ret); EXPECT_EQ(ETIMEDOUT, errno);
close(mutex);
close(fd);}
TEST(manual_event_state){ struct ntsync_event_args event_args; __u32 index, signaled; int fd, event, ret;
fd = open("/dev/ntsync", O_CLOEXEC | O_RDONLY); ASSERT_LE(0, fd);
event_args.manual = 1; event_args.signaled = 0; event = ioctl(fd, NTSYNC_IOC_CREATE_EVENT, &event_args); EXPECT_LE(0, event); check_event_state(event, 0, 1);
signaled = 0xdeadbeef; ret = ioctl(event, NTSYNC_IOC_EVENT_SET, &signaled); EXPECT_EQ(0, ret); EXPECT_EQ(0, signaled); check_event_state(event, 1, 1);
ret = ioctl(event, NTSYNC_IOC_EVENT_SET, &signaled); EXPECT_EQ(0, ret); EXPECT_EQ(1, signaled); check_event_state(event, 1, 1);
ret = wait_any(fd, 1, &event, 123, &index); EXPECT_EQ(0, ret); EXPECT_EQ(0, index); check_event_state(event, 1, 1);
signaled = 0xdeadbeef; ret = ioctl(event, NTSYNC_IOC_EVENT_RESET, &signaled); EXPECT_EQ(0, ret); EXPECT_EQ(1, signaled); check_event_state(event, 0, 1);
ret = ioctl(event, NTSYNC_IOC_EVENT_RESET, &signaled); EXPECT_EQ(0, ret); EXPECT_EQ(0, signaled); check_event_state(event, 0, 1);
ret = wait_any(fd, 1, &event, 123, &index); EXPECT_EQ(-1, ret); EXPECT_EQ(ETIMEDOUT, errno);
ret = ioctl(event, NTSYNC_IOC_EVENT_SET, &signaled); EXPECT_EQ(0, ret); EXPECT_EQ(0, signaled);
ret = ioctl(event, NTSYNC_IOC_EVENT_PULSE, &signaled); EXPECT_EQ(0, ret); EXPECT_EQ(1, signaled); check_event_state(event, 0, 1);
ret = ioctl(event, NTSYNC_IOC_EVENT_PULSE, &signaled); EXPECT_EQ(0, ret); EXPECT_EQ(0, signaled); check_event_state(event, 0, 1);
close(event);
close(fd);}
TEST(auto_event_state){ struct ntsync_event_args event_args; __u32 index, signaled; int fd, event, ret;
fd = open("/dev/ntsync", O_CLOEXEC | O_RDONLY); ASSERT_LE(0, fd);
event_args.manual = 0; event_args.signaled = 1; event = ioctl(fd, NTSYNC_IOC_CREATE_EVENT, &event_args); EXPECT_LE(0, event);
check_event_state(event, 1, 0);
signaled = 0xdeadbeef; ret = ioctl(event, NTSYNC_IOC_EVENT_SET, &signaled); EXPECT_EQ(0, ret); EXPECT_EQ(1, signaled); check_event_state(event, 1, 0);
ret = wait_any(fd, 1, &event, 123, &index); EXPECT_EQ(0, ret); EXPECT_EQ(0, index); check_event_state(event, 0, 0);
signaled = 0xdeadbeef; ret = ioctl(event, NTSYNC_IOC_EVENT_RESET, &signaled); EXPECT_EQ(0, ret); EXPECT_EQ(0, signaled); check_event_state(event, 0, 0);
ret = wait_any(fd, 1, &event, 123, &index); EXPECT_EQ(-1, ret); EXPECT_EQ(ETIMEDOUT, errno);
ret = ioctl(event, NTSYNC_IOC_EVENT_SET, &signaled); EXPECT_EQ(0, ret); EXPECT_EQ(0, signaled);
ret = ioctl(event, NTSYNC_IOC_EVENT_PULSE, &signaled); EXPECT_EQ(0, ret); EXPECT_EQ(1, signaled); check_event_state(event, 0, 0);
ret = ioctl(event, NTSYNC_IOC_EVENT_PULSE, &signaled); EXPECT_EQ(0, ret); EXPECT_EQ(0, signaled); check_event_state(event, 0, 0);
close(event);
close(fd);}
TEST(test_wait_any){ int objs[NTSYNC_MAX_WAIT_COUNT + 1], fd, ret; struct ntsync_mutex_args mutex_args = {0}; struct ntsync_sem_args sem_args = {0}; __u32 owner, index, count, i; struct timespec timeout;
clock_gettime(CLOCK_MONOTONIC, &timeout);
fd = open("/dev/ntsync", O_CLOEXEC | O_RDONLY); ASSERT_LE(0, fd);
sem_args.count = 2; sem_args.max = 3; objs[0] = ioctl(fd, NTSYNC_IOC_CREATE_SEM, &sem_args); EXPECT_LE(0, objs[0]);
mutex_args.owner = 0; mutex_args.count = 0; objs[1] = ioctl(fd, NTSYNC_IOC_CREATE_MUTEX, &mutex_args); EXPECT_LE(0, objs[1]);
ret = wait_any(fd, 2, objs, 123, &index); EXPECT_EQ(0, ret); EXPECT_EQ(0, index); check_sem_state(objs[0], 1, 3); check_mutex_state(objs[1], 0, 0);
ret = wait_any(fd, 2, objs, 123, &index); EXPECT_EQ(0, ret); EXPECT_EQ(0, index); check_sem_state(objs[0], 0, 3); check_mutex_state(objs[1], 0, 0);
ret = wait_any(fd, 2, objs, 123, &index); EXPECT_EQ(0, ret); EXPECT_EQ(1, index); check_sem_state(objs[0], 0, 3); check_mutex_state(objs[1], 1, 123);
count = 1; ret = release_sem(objs[0], &count); EXPECT_EQ(0, ret); EXPECT_EQ(0, count);
ret = wait_any(fd, 2, objs, 123, &index); EXPECT_EQ(0, ret); EXPECT_EQ(0, index); check_sem_state(objs[0], 0, 3); check_mutex_state(objs[1], 1, 123);
ret = wait_any(fd, 2, objs, 123, &index); EXPECT_EQ(0, ret); EXPECT_EQ(1, index); check_sem_state(objs[0], 0, 3); check_mutex_state(objs[1], 2, 123);
ret = wait_any(fd, 2, objs, 456, &index); EXPECT_EQ(-1, ret); EXPECT_EQ(ETIMEDOUT, errno);
owner = 123; ret = ioctl(objs[1], NTSYNC_IOC_MUTEX_KILL, &owner); EXPECT_EQ(0, ret);
ret = wait_any(fd, 2, objs, 456, &index); EXPECT_EQ(-1, ret); EXPECT_EQ(EOWNERDEAD, errno); EXPECT_EQ(1, index);
ret = wait_any(fd, 2, objs, 456, &index); EXPECT_EQ(0, ret); EXPECT_EQ(1, index);
close(objs[1]);
/* test waiting on the same object twice */
count = 2; ret = release_sem(objs[0], &count); EXPECT_EQ(0, ret); EXPECT_EQ(0, count);
objs[1] = objs[0]; ret = wait_any(fd, 2, objs, 456, &index); EXPECT_EQ(0, ret); EXPECT_EQ(0, index); check_sem_state(objs[0], 1, 3);
ret = wait_any(fd, 0, NULL, 456, &index); EXPECT_EQ(-1, ret); EXPECT_EQ(ETIMEDOUT, errno);
for (i = 1; i < NTSYNC_MAX_WAIT_COUNT + 1; ++i) objs[i] = objs[0];
ret = wait_any(fd, NTSYNC_MAX_WAIT_COUNT, objs, 123, &index); EXPECT_EQ(0, ret); EXPECT_EQ(0, index);
ret = wait_any(fd, NTSYNC_MAX_WAIT_COUNT + 1, objs, 123, &index); EXPECT_EQ(-1, ret); EXPECT_EQ(EINVAL, errno);
ret = wait_any(fd, -1, objs, 123, &index); EXPECT_EQ(-1, ret); EXPECT_EQ(EINVAL, errno);
close(objs[0]);
close(fd);}
TEST(test_wait_all){ struct ntsync_event_args event_args = {0}; struct ntsync_mutex_args mutex_args = {0}; struct ntsync_sem_args sem_args = {0}; __u32 owner, index, count; int objs[2], fd, ret;
fd = open("/dev/ntsync", O_CLOEXEC | O_RDONLY); ASSERT_LE(0, fd);
sem_args.count = 2; sem_args.max = 3; objs[0] = ioctl(fd, NTSYNC_IOC_CREATE_SEM, &sem_args); EXPECT_LE(0, objs[0]);
mutex_args.owner = 0; mutex_args.count = 0; objs[1] = ioctl(fd, NTSYNC_IOC_CREATE_MUTEX, &mutex_args); EXPECT_LE(0, objs[1]);
ret = wait_all(fd, 2, objs, 123, &index); EXPECT_EQ(0, ret); EXPECT_EQ(0, index); check_sem_state(objs[0], 1, 3); check_mutex_state(objs[1], 1, 123);
ret = wait_all(fd, 2, objs, 456, &index); EXPECT_EQ(-1, ret); EXPECT_EQ(ETIMEDOUT, errno); check_sem_state(objs[0], 1, 3); check_mutex_state(objs[1], 1, 123);
ret = wait_all(fd, 2, objs, 123, &index); EXPECT_EQ(0, ret); EXPECT_EQ(0, index); check_sem_state(objs[0], 0, 3); check_mutex_state(objs[1], 2, 123);
ret = wait_all(fd, 2, objs, 123, &index); EXPECT_EQ(-1, ret); EXPECT_EQ(ETIMEDOUT, errno); check_sem_state(objs[0], 0, 3); check_mutex_state(objs[1], 2, 123);
count = 3; ret = release_sem(objs[0], &count); EXPECT_EQ(0, ret); EXPECT_EQ(0, count);
ret = wait_all(fd, 2, objs, 123, &index); EXPECT_EQ(0, ret); EXPECT_EQ(0, index); check_sem_state(objs[0], 2, 3); check_mutex_state(objs[1], 3, 123);
owner = 123; ret = ioctl(objs[1], NTSYNC_IOC_MUTEX_KILL, &owner); EXPECT_EQ(0, ret);
ret = wait_all(fd, 2, objs, 123, &index); EXPECT_EQ(-1, ret); EXPECT_EQ(EOWNERDEAD, errno); check_sem_state(objs[0], 1, 3); check_mutex_state(objs[1], 1, 123);
close(objs[1]);
event_args.manual = true; event_args.signaled = true; objs[1] = ioctl(fd, NTSYNC_IOC_CREATE_EVENT, &event_args); EXPECT_LE(0, objs[1]);
ret = wait_all(fd, 2, objs, 123, &index); EXPECT_EQ(0, ret); EXPECT_EQ(0, index); check_sem_state(objs[0], 0, 3); check_event_state(objs[1], 1, 1);
close(objs[1]);
/* test waiting on the same object twice */ objs[1] = objs[0]; ret = wait_all(fd, 2, objs, 123, &index); EXPECT_EQ(-1, ret); EXPECT_EQ(EINVAL, errno);
close(objs[0]);
close(fd);}
struct wake_args { int fd; int obj;};
struct wait_args { int fd; unsigned long request; struct ntsync_wait_args *args; int ret; int err;};
static void *wait_thread(void *arg){ struct wait_args *args = arg;
args->ret = ioctl(args->fd, args->request, args->args); args->err = errno; return NULL;}
static __u64 get_abs_timeout(unsigned int ms){ struct timespec timeout; clock_gettime(CLOCK_MONOTONIC, &timeout); return (timeout.tv_sec * 1000000000) + timeout.tv_nsec + (ms * 1000000);}
static int wait_for_thread(pthread_t thread, unsigned int ms){ struct timespec timeout;
clock_gettime(CLOCK_REALTIME, &timeout); timeout.tv_nsec += ms * 1000000; timeout.tv_sec += (timeout.tv_nsec / 1000000000); timeout.tv_nsec %= 1000000000; return pthread_timedjoin_np(thread, NULL, &timeout);}
TEST(wake_any){ struct ntsync_event_args event_args = {0}; struct ntsync_mutex_args mutex_args = {0}; struct ntsync_wait_args wait_args = {0}; struct ntsync_sem_args sem_args = {0}; struct wait_args thread_args; __u32 count, index, signaled; int objs[2], fd, ret; pthread_t thread;
fd = open("/dev/ntsync", O_CLOEXEC | O_RDONLY); ASSERT_LE(0, fd);
sem_args.count = 0; sem_args.max = 3; objs[0] = ioctl(fd, NTSYNC_IOC_CREATE_SEM, &sem_args); EXPECT_LE(0, objs[0]);
mutex_args.owner = 123; mutex_args.count = 1; objs[1] = ioctl(fd, NTSYNC_IOC_CREATE_MUTEX, &mutex_args); EXPECT_LE(0, objs[1]);
/* test waking the semaphore */
wait_args.timeout = get_abs_timeout(1000); wait_args.objs = (uintptr_t)objs; wait_args.count = 2; wait_args.owner = 456; wait_args.index = 0xdeadbeef; thread_args.fd = fd; thread_args.args = &wait_args; thread_args.request = NTSYNC_IOC_WAIT_ANY; ret = pthread_create(&thread, NULL, wait_thread, &thread_args); EXPECT_EQ(0, ret);
ret = wait_for_thread(thread, 100); EXPECT_EQ(ETIMEDOUT, ret);
count = 1; ret = release_sem(objs[0], &count); EXPECT_EQ(0, ret); EXPECT_EQ(0, count); check_sem_state(objs[0], 0, 3);
ret = wait_for_thread(thread, 100); EXPECT_EQ(0, ret); EXPECT_EQ(0, thread_args.ret); EXPECT_EQ(0, wait_args.index);
/* test waking the mutex */
/* first grab it again for owner 123 */ ret = wait_any(fd, 1, &objs[1], 123, &index); EXPECT_EQ(0, ret); EXPECT_EQ(0, index);
wait_args.timeout = get_abs_timeout(1000); wait_args.owner = 456; ret = pthread_create(&thread, NULL, wait_thread, &thread_args); EXPECT_EQ(0, ret);
ret = wait_for_thread(thread, 100); EXPECT_EQ(ETIMEDOUT, ret);
ret = unlock_mutex(objs[1], 123, &count); EXPECT_EQ(0, ret); EXPECT_EQ(2, count);
ret = pthread_tryjoin_np(thread, NULL); EXPECT_EQ(EBUSY, ret);
ret = unlock_mutex(objs[1], 123, &count); EXPECT_EQ(0, ret); EXPECT_EQ(1, mutex_args.count); check_mutex_state(objs[1], 1, 456);
ret = wait_for_thread(thread, 100); EXPECT_EQ(0, ret); EXPECT_EQ(0, thread_args.ret); EXPECT_EQ(1, wait_args.index);
close(objs[1]);
/* test waking events */
event_args.manual = false; event_args.signaled = false; objs[1] = ioctl(fd, NTSYNC_IOC_CREATE_EVENT, &event_args); EXPECT_LE(0, objs[1]);
wait_args.timeout = get_abs_timeout(1000); ret = pthread_create(&thread, NULL, wait_thread, &thread_args); EXPECT_EQ(0, ret);
ret = wait_for_thread(thread, 100); EXPECT_EQ(ETIMEDOUT, ret);
ret = ioctl(objs[1], NTSYNC_IOC_EVENT_SET, &signaled); EXPECT_EQ(0, ret); EXPECT_EQ(0, signaled); check_event_state(objs[1], 0, 0);
ret = wait_for_thread(thread, 100); EXPECT_EQ(0, ret); EXPECT_EQ(0, thread_args.ret); EXPECT_EQ(1, wait_args.index);
wait_args.timeout = get_abs_timeout(1000); ret = pthread_create(&thread, NULL, wait_thread, &thread_args); EXPECT_EQ(0, ret);
ret = wait_for_thread(thread, 100); EXPECT_EQ(ETIMEDOUT, ret);
ret = ioctl(objs[1], NTSYNC_IOC_EVENT_PULSE, &signaled); EXPECT_EQ(0, ret); EXPECT_EQ(0, signaled); check_event_state(objs[1], 0, 0);
ret = wait_for_thread(thread, 100); EXPECT_EQ(0, ret); EXPECT_EQ(0, thread_args.ret); EXPECT_EQ(1, wait_args.index);
close(objs[1]);
event_args.manual = true; event_args.signaled = false; objs[1] = ioctl(fd, NTSYNC_IOC_CREATE_EVENT, &event_args); EXPECT_LE(0, objs[1]);
wait_args.timeout = get_abs_timeout(1000); ret = pthread_create(&thread, NULL, wait_thread, &thread_args); EXPECT_EQ(0, ret);
ret = wait_for_thread(thread, 100); EXPECT_EQ(ETIMEDOUT, ret);
ret = ioctl(objs[1], NTSYNC_IOC_EVENT_SET, &signaled); EXPECT_EQ(0, ret); EXPECT_EQ(0, signaled); check_event_state(objs[1], 1, 1);
ret = wait_for_thread(thread, 100); EXPECT_EQ(0, ret); EXPECT_EQ(0, thread_args.ret); EXPECT_EQ(1, wait_args.index);
ret = ioctl(objs[1], NTSYNC_IOC_EVENT_RESET, &signaled); EXPECT_EQ(0, ret); EXPECT_EQ(1, signaled);
wait_args.timeout = get_abs_timeout(1000); ret = pthread_create(&thread, NULL, wait_thread, &thread_args); EXPECT_EQ(0, ret);
ret = wait_for_thread(thread, 100); EXPECT_EQ(ETIMEDOUT, ret);
ret = ioctl(objs[1], NTSYNC_IOC_EVENT_PULSE, &signaled); EXPECT_EQ(0, ret); EXPECT_EQ(0, signaled); check_event_state(objs[1], 0, 1);
ret = wait_for_thread(thread, 100); EXPECT_EQ(0, ret); EXPECT_EQ(0, thread_args.ret); EXPECT_EQ(1, wait_args.index);
/* delete an object while it's being waited on */
wait_args.timeout = get_abs_timeout(200); wait_args.owner = 123; ret = pthread_create(&thread, NULL, wait_thread, &thread_args); EXPECT_EQ(0, ret);
ret = wait_for_thread(thread, 100); EXPECT_EQ(ETIMEDOUT, ret);
close(objs[0]); close(objs[1]);
ret = wait_for_thread(thread, 200); EXPECT_EQ(0, ret); EXPECT_EQ(-1, thread_args.ret); EXPECT_EQ(ETIMEDOUT, thread_args.err);
close(fd);}
TEST(wake_all){ struct ntsync_event_args manual_event_args = {0}; struct ntsync_event_args auto_event_args = {0}; struct ntsync_mutex_args mutex_args = {0}; struct ntsync_wait_args wait_args = {0}; struct ntsync_sem_args sem_args = {0}; struct wait_args thread_args; __u32 count, index, signaled; int objs[4], fd, ret; pthread_t thread;
fd = open("/dev/ntsync", O_CLOEXEC | O_RDONLY); ASSERT_LE(0, fd);
sem_args.count = 0; sem_args.max = 3; objs[0] = ioctl(fd, NTSYNC_IOC_CREATE_SEM, &sem_args); EXPECT_LE(0, objs[0]);
mutex_args.owner = 123; mutex_args.count = 1; objs[1] = ioctl(fd, NTSYNC_IOC_CREATE_MUTEX, &mutex_args); EXPECT_LE(0, objs[1]);
manual_event_args.manual = true; manual_event_args.signaled = true; objs[2] = ioctl(fd, NTSYNC_IOC_CREATE_EVENT, &manual_event_args); EXPECT_LE(0, objs[2]);
auto_event_args.manual = false; auto_event_args.signaled = true; objs[3] = ioctl(fd, NTSYNC_IOC_CREATE_EVENT, &auto_event_args); EXPECT_LE(0, objs[3]);
wait_args.timeout = get_abs_timeout(1000); wait_args.objs = (uintptr_t)objs; wait_args.count = 4; wait_args.owner = 456; thread_args.fd = fd; thread_args.args = &wait_args; thread_args.request = NTSYNC_IOC_WAIT_ALL; ret = pthread_create(&thread, NULL, wait_thread, &thread_args); EXPECT_EQ(0, ret);
ret = wait_for_thread(thread, 100); EXPECT_EQ(ETIMEDOUT, ret);
count = 1; ret = release_sem(objs[0], &count); EXPECT_EQ(0, ret); EXPECT_EQ(0, count);
ret = pthread_tryjoin_np(thread, NULL); EXPECT_EQ(EBUSY, ret);
check_sem_state(objs[0], 1, 3);
ret = wait_any(fd, 1, &objs[0], 123, &index); EXPECT_EQ(0, ret); EXPECT_EQ(0, index);
ret = unlock_mutex(objs[1], 123, &count); EXPECT_EQ(0, ret); EXPECT_EQ(1, count);
ret = pthread_tryjoin_np(thread, NULL); EXPECT_EQ(EBUSY, ret);
check_mutex_state(objs[1], 0, 0);
ret = ioctl(objs[2], NTSYNC_IOC_EVENT_RESET, &signaled); EXPECT_EQ(0, ret); EXPECT_EQ(1, signaled);
count = 2; ret = release_sem(objs[0], &count); EXPECT_EQ(0, ret); EXPECT_EQ(0, count); check_sem_state(objs[0], 2, 3);
ret = ioctl(objs[3], NTSYNC_IOC_EVENT_RESET, &signaled); EXPECT_EQ(0, ret); EXPECT_EQ(1, signaled);
ret = ioctl(objs[2], NTSYNC_IOC_EVENT_SET, &signaled); EXPECT_EQ(0, ret); EXPECT_EQ(0, signaled);
ret = ioctl(objs[3], NTSYNC_IOC_EVENT_SET, &signaled); EXPECT_EQ(0, ret); EXPECT_EQ(0, signaled);
check_sem_state(objs[0], 1, 3); check_mutex_state(objs[1], 1, 456); check_event_state(objs[2], 1, 1); check_event_state(objs[3], 0, 0);
ret = wait_for_thread(thread, 100); EXPECT_EQ(0, ret); EXPECT_EQ(0, thread_args.ret);
/* delete an object while it's being waited on */
wait_args.timeout = get_abs_timeout(200); wait_args.owner = 123; ret = pthread_create(&thread, NULL, wait_thread, &thread_args); EXPECT_EQ(0, ret);
ret = wait_for_thread(thread, 100); EXPECT_EQ(ETIMEDOUT, ret);
close(objs[0]); close(objs[1]); close(objs[2]); close(objs[3]);
ret = wait_for_thread(thread, 200); EXPECT_EQ(0, ret); EXPECT_EQ(-1, thread_args.ret); EXPECT_EQ(ETIMEDOUT, thread_args.err);
close(fd);}
TEST(alert_any){ struct ntsync_event_args event_args = {0}; struct ntsync_wait_args wait_args = {0}; struct ntsync_sem_args sem_args = {0}; __u32 index, count, signaled; struct wait_args thread_args; int objs[2], event, fd, ret; pthread_t thread;
fd = open("/dev/ntsync", O_CLOEXEC | O_RDONLY); ASSERT_LE(0, fd);
sem_args.count = 0; sem_args.max = 2; objs[0] = ioctl(fd, NTSYNC_IOC_CREATE_SEM, &sem_args); EXPECT_LE(0, objs[0]);
sem_args.count = 1; sem_args.max = 2; objs[1] = ioctl(fd, NTSYNC_IOC_CREATE_SEM, &sem_args); EXPECT_LE(0, objs[1]);
event_args.manual = true; event_args.signaled = true; event = ioctl(fd, NTSYNC_IOC_CREATE_EVENT, &event_args); EXPECT_LE(0, event);
ret = wait_any_alert(fd, 0, NULL, 123, event, &index); EXPECT_EQ(0, ret); EXPECT_EQ(0, index);
ret = ioctl(event, NTSYNC_IOC_EVENT_RESET, &signaled); EXPECT_EQ(0, ret);
ret = wait_any_alert(fd, 0, NULL, 123, event, &index); EXPECT_EQ(-1, ret); EXPECT_EQ(ETIMEDOUT, errno);
ret = ioctl(event, NTSYNC_IOC_EVENT_SET, &signaled); EXPECT_EQ(0, ret);
ret = wait_any_alert(fd, 2, objs, 123, event, &index); EXPECT_EQ(0, ret); EXPECT_EQ(1, index);
ret = wait_any_alert(fd, 2, objs, 123, event, &index); EXPECT_EQ(0, ret); EXPECT_EQ(2, index);
/* test wakeup via alert */
ret = ioctl(event, NTSYNC_IOC_EVENT_RESET, &signaled); EXPECT_EQ(0, ret);
wait_args.timeout = get_abs_timeout(1000); wait_args.objs = (uintptr_t)objs; wait_args.count = 2; wait_args.owner = 123; wait_args.index = 0xdeadbeef; wait_args.alert = event; thread_args.fd = fd; thread_args.args = &wait_args; thread_args.request = NTSYNC_IOC_WAIT_ANY; ret = pthread_create(&thread, NULL, wait_thread, &thread_args); EXPECT_EQ(0, ret);
ret = wait_for_thread(thread, 100); EXPECT_EQ(ETIMEDOUT, ret);
ret = ioctl(event, NTSYNC_IOC_EVENT_SET, &signaled); EXPECT_EQ(0, ret);
ret = wait_for_thread(thread, 100); EXPECT_EQ(0, ret); EXPECT_EQ(0, thread_args.ret); EXPECT_EQ(2, wait_args.index);
close(event);
/* test with an auto-reset event */
event_args.manual = false; event_args.signaled = true; event = ioctl(fd, NTSYNC_IOC_CREATE_EVENT, &event_args); EXPECT_LE(0, event);
count = 1; ret = release_sem(objs[0], &count); EXPECT_EQ(0, ret);
ret = wait_any_alert(fd, 2, objs, 123, event, &index); EXPECT_EQ(0, ret); EXPECT_EQ(0, index);
ret = wait_any_alert(fd, 2, objs, 123, event, &index); EXPECT_EQ(0, ret); EXPECT_EQ(2, index);
ret = wait_any_alert(fd, 2, objs, 123, event, &index); EXPECT_EQ(-1, ret); EXPECT_EQ(ETIMEDOUT, errno);
close(event);
close(objs[0]); close(objs[1]);
close(fd);}
TEST(alert_all){ struct ntsync_event_args event_args = {0}; struct ntsync_wait_args wait_args = {0}; struct ntsync_sem_args sem_args = {0}; struct wait_args thread_args; __u32 index, count, signaled; int objs[2], event, fd, ret; pthread_t thread;
fd = open("/dev/ntsync", O_CLOEXEC | O_RDONLY); ASSERT_LE(0, fd);
sem_args.count = 2; sem_args.max = 2; objs[0] = ioctl(fd, NTSYNC_IOC_CREATE_SEM, &sem_args); EXPECT_LE(0, objs[0]);
sem_args.count = 1; sem_args.max = 2; objs[1] = ioctl(fd, NTSYNC_IOC_CREATE_SEM, &sem_args); EXPECT_LE(0, objs[1]);
event_args.manual = true; event_args.signaled = true; event = ioctl(fd, NTSYNC_IOC_CREATE_EVENT, &event_args); EXPECT_LE(0, event);
ret = wait_all_alert(fd, 2, objs, 123, event, &index); EXPECT_EQ(0, ret); EXPECT_EQ(0, index);
ret = wait_all_alert(fd, 2, objs, 123, event, &index); EXPECT_EQ(0, ret); EXPECT_EQ(2, index);
/* test wakeup via alert */
ret = ioctl(event, NTSYNC_IOC_EVENT_RESET, &signaled); EXPECT_EQ(0, ret);
wait_args.timeout = get_abs_timeout(1000); wait_args.objs = (uintptr_t)objs; wait_args.count = 2; wait_args.owner = 123; wait_args.index = 0xdeadbeef; wait_args.alert = event; thread_args.fd = fd; thread_args.args = &wait_args; thread_args.request = NTSYNC_IOC_WAIT_ALL; ret = pthread_create(&thread, NULL, wait_thread, &thread_args); EXPECT_EQ(0, ret);
ret = wait_for_thread(thread, 100); EXPECT_EQ(ETIMEDOUT, ret);
ret = ioctl(event, NTSYNC_IOC_EVENT_SET, &signaled); EXPECT_EQ(0, ret);
ret = wait_for_thread(thread, 100); EXPECT_EQ(0, ret); EXPECT_EQ(0, thread_args.ret); EXPECT_EQ(2, wait_args.index);
close(event);
/* test with an auto-reset event */
event_args.manual = false; event_args.signaled = true; event = ioctl(fd, NTSYNC_IOC_CREATE_EVENT, &event_args); EXPECT_LE(0, event);
count = 2; ret = release_sem(objs[1], &count); EXPECT_EQ(0, ret);
ret = wait_all_alert(fd, 2, objs, 123, event, &index); EXPECT_EQ(0, ret); EXPECT_EQ(0, index);
ret = wait_all_alert(fd, 2, objs, 123, event, &index); EXPECT_EQ(0, ret); EXPECT_EQ(2, index);
ret = wait_all_alert(fd, 2, objs, 123, event, &index); EXPECT_EQ(-1, ret); EXPECT_EQ(ETIMEDOUT, errno);
close(event);
close(objs[0]); close(objs[1]);
close(fd);}
#define STRESS_LOOPS 10000#define STRESS_THREADS 4
static unsigned int stress_counter;static int stress_device, stress_start_event, stress_mutex;
static void *stress_thread(void *arg){ struct ntsync_wait_args wait_args = {0}; __u32 index, count, i; int ret;
wait_args.timeout = UINT64_MAX; wait_args.count = 1; wait_args.objs = (uintptr_t)&stress_start_event; wait_args.owner = gettid(); wait_args.index = 0xdeadbeef;
ioctl(stress_device, NTSYNC_IOC_WAIT_ANY, &wait_args);
wait_args.objs = (uintptr_t)&stress_mutex;
for (i = 0; i < STRESS_LOOPS; ++i) { ioctl(stress_device, NTSYNC_IOC_WAIT_ANY, &wait_args);
++stress_counter;
unlock_mutex(stress_mutex, wait_args.owner, &count); }
return NULL;}
TEST(stress_wait){ struct ntsync_event_args event_args; struct ntsync_mutex_args mutex_args; pthread_t threads[STRESS_THREADS]; __u32 signaled, i; int ret;
stress_device = open("/dev/ntsync", O_CLOEXEC | O_RDONLY); ASSERT_LE(0, stress_device);
mutex_args.owner = 0; mutex_args.count = 0; stress_mutex = ioctl(stress_device, NTSYNC_IOC_CREATE_MUTEX, &mutex_args); EXPECT_LE(0, stress_mutex);
event_args.manual = 1; event_args.signaled = 0; stress_start_event = ioctl(stress_device, NTSYNC_IOC_CREATE_EVENT, &event_args); EXPECT_LE(0, stress_start_event);
for (i = 0; i < STRESS_THREADS; ++i) pthread_create(&threads[i], NULL, stress_thread, NULL);
ret = ioctl(stress_start_event, NTSYNC_IOC_EVENT_SET, &signaled); EXPECT_EQ(0, ret);
for (i = 0; i < STRESS_THREADS; ++i) { ret = pthread_join(threads[i], NULL); EXPECT_EQ(0, ret); }
EXPECT_EQ(STRESS_LOOPS * STRESS_THREADS, stress_counter);
close(stress_start_event); close(stress_mutex); close(stress_device);}
TEST(wait_args_validation){ struct ntsync_sem_args sem_args = { .count = 1, .max = 1 }; struct ntsync_wait_args wait_args = {0}; struct timespec timeout; int fd, fd2, sem, ret; __u32 index;
fd = open("/dev/ntsync", O_CLOEXEC | O_RDONLY); ASSERT_GE(fd, 0);
fd2 = open("/dev/ntsync", O_CLOEXEC | O_RDONLY); ASSERT_GE(fd2, 0);
sem = ioctl(fd, NTSYNC_IOC_CREATE_SEM, &sem_args); EXPECT_GE(sem, 0);
ret = wait_any(fd, 1, &sem, 0, &index); EXPECT_EQ(-1, ret); EXPECT_EQ(EINVAL, errno);
ret = wait_all(fd, 1, &sem, 0, &index); EXPECT_EQ(-1, ret); EXPECT_EQ(EINVAL, errno);
clock_gettime(CLOCK_MONOTONIC, &timeout); wait_args.timeout = timeout.tv_sec * 1000000000ULL + timeout.tv_nsec; wait_args.count = 0; wait_args.objs = 0; wait_args.owner = 123; wait_args.pad = 1; ret = ioctl(fd, NTSYNC_IOC_WAIT_ANY, &wait_args); EXPECT_EQ(-1, ret); EXPECT_EQ(EINVAL, errno);
ret = wait_any(fd2, 1, &sem, 123, &index); EXPECT_EQ(-1, ret); EXPECT_EQ(EINVAL, errno);
close(sem); close(fd2); close(fd);}
/* * Absolute MONOTONIC timeouts must honour the caller's time namespace. * With a negative monotonic offset, a 100 ms wait must still take ~100 ms * of namespace time (not return immediately against the host clock). */TEST(wait_any_monotonic_timens){ struct ntsync_sem_args sem_args = {0}; struct ntsync_wait_args wait_args = {0}; struct timespec start, end; char buf[64]; __u64 elapsed_ns; int fd, offset_fd, sem, ret, status, len; pid_t pid;
if (access("/proc/self/ns/time", F_OK)) SKIP(return, "Time namespaces are not supported");
fd = open("/dev/ntsync", O_CLOEXEC | O_RDONLY); if (fd < 0) SKIP(return, "/dev/ntsync is not available");
ret = unshare(CLONE_NEWTIME); if (ret) { close(fd); if (errno == EPERM) SKIP(return, "need CAP_SYS_ADMIN for CLONE_NEWTIME"); ASSERT_EQ(0, ret); }
len = snprintf(buf, sizeof(buf), "%d %d 0", CLOCK_MONOTONIC, -10); offset_fd = open("/proc/self/timens_offsets", O_WRONLY); ASSERT_LE(0, offset_fd); ASSERT_EQ(len, write(offset_fd, buf, len)); close(offset_fd);
pid = fork(); ASSERT_LE(0, pid); if (!pid) { int obj;
sem_args.count = 0; sem_args.max = 1; sem = ioctl(fd, NTSYNC_IOC_CREATE_SEM, &sem_args); if (sem < 0) _exit(1);
obj = sem; wait_args.timeout = get_abs_timeout(100); wait_args.objs = (uintptr_t)&obj; wait_args.count = 1; wait_args.owner = 123; wait_args.index = 0xdeadbeef;
if (clock_gettime(CLOCK_MONOTONIC, &start)) _exit(2); ret = ioctl(fd, NTSYNC_IOC_WAIT_ANY, &wait_args); if (clock_gettime(CLOCK_MONOTONIC, &end)) _exit(2);
if (ret != -1 || errno != ETIMEDOUT) _exit(3);
elapsed_ns = (end.tv_sec - start.tv_sec) * 1000000000ULL + (end.tv_nsec - start.tv_nsec); /* Without timens conversion this returns in ~0 ms. */ if (elapsed_ns < 50 * 1000000ULL) _exit(4); if (elapsed_ns > 1000 * 1000000ULL) _exit(5);
_exit(0); }
ASSERT_EQ(pid, waitpid(pid, &status, 0)); EXPECT_TRUE(WIFEXITED(status)); EXPECT_EQ(0, WEXITSTATUS(status));
close(fd);}
TEST_HARNESS_MAIN