void setup(void)
{
tst_sig(NOFORK, DEF_HANDLER, cleanup);
tst_tmpdir();
/* Initialize test dir and file names */
char *abs_path = tst_get_tmpdir();
int p = getpid();
sprintf(pathname, "fchmodattestdir%d", p);
sprintf(testfile, "fchmodattest%d.txt", p);
sprintf(testfile2, "%s/fchmodattest%d.txt", abs_path, p);
sprintf(testfile3, "fchmodattestdir%d/fchmodattest%d.txt", p, p);
free(abs_path);
SAFE_MKDIR(cleanup, pathname, 0700);
fds[0] = SAFE_OPEN(cleanup, pathname, O_DIRECTORY);
fds[1] = fds[4] = fds[0];
SAFE_OPEN(cleanup, testfile, O_CREAT | O_RDWR, 0600);
SAFE_OPEN(cleanup, testfile2, O_CREAT | O_RDWR, 0600);
fds[2] = SAFE_OPEN(cleanup, testfile3, O_CREAT | O_RDWR, 0600);
fds[3] = 100;
fds[5] = AT_FDCWD;
filenames[0] = filenames[2] = filenames[3] = filenames[4] = testfile;
filenames[1] = testfile2;
filenames[5] = testfile3;
TEST_PAUSE;
}
static void splice_test(void)
{
int pipes[2];
int ret;
fd_in = SAFE_OPEN(cleanup, TESTFILE1, O_RDONLY);
SAFE_PIPE(cleanup, pipes);
fd_out = SAFE_OPEN(cleanup, TESTFILE2, O_WRONLY | O_CREAT | O_TRUNC, 0666);
ret = splice(fd_in, NULL, pipes[1], NULL, TEST_BLOCK_SIZE, 0);
if (ret < 0)
tst_brkm(TBROK | TERRNO, cleanup, "splice(fd_in, pipe) failed");
ret = splice(pipes[0], NULL, fd_out, NULL, TEST_BLOCK_SIZE, 0);
if (ret < 0)
tst_brkm(TBROK | TERRNO, cleanup, "splice(pipe, fd_out) failed");
close(fd_in);
close(fd_out);
close(pipes[0]);
close(pipes[1]);
fd_out = 0;
fd_in = 0;
check_file();
}
static void verify_fcntl(int i)
{
fd1 = SAFE_OPEN(cleanup, "file", test_cases[i].fd1_flag);
fd2 = SAFE_OPEN(cleanup, "file", test_cases[i].fd2_flag);
TEST(fcntl(fd1, F_SETLEASE, F_WRLCK));
if (TEST_RETURN == 0) {
tst_resm(TFAIL, "fcntl(F_SETLEASE, F_WRLCK) "
"succeeded unexpectedly");
} else {
if (TEST_ERRNO == EBUSY || TEST_ERRNO == EAGAIN) {
tst_resm(TPASS | TTERRNO,
"fcntl(F_SETLEASE, F_WRLCK) "
"failed as expected");
} else {
tst_resm(TFAIL | TTERRNO,
"fcntl(F_SETLEASE, F_WRLCK) "
"failed unexpectedly, "
"expected errno is EBUSY or EAGAIN");
}
}
SAFE_CLOSE(cleanup, fd1);
fd1 = 0;
SAFE_CLOSE(cleanup, fd2);
fd2 = 0;
}
void setup(void)
{
tst_sig(NOFORK, DEF_HANDLER, cleanup);
tst_tmpdir();
char *abs_path = tst_get_tmpdir();
SAFE_ASPRINTF(cleanup, &testfile3, "%s/fstatattestfile3.txt", abs_path);
free(abs_path);
SAFE_MKDIR(cleanup, pathname, 0700);
fds[0] = SAFE_OPEN(cleanup, pathname, O_DIRECTORY);
fds[1] = fds[4] = fds[0];
SAFE_OPEN(cleanup, testfile, O_CREAT | O_RDWR, 0600);
SAFE_OPEN(cleanup, testfile2, O_CREAT | O_RDWR, 0600);
fds[2] = SAFE_OPEN(cleanup, testfile3, O_CREAT | O_RDWR, 0600);
fds[3] = 100;
fds[5] = AT_FDCWD;
filenames[0] = filenames[2] = filenames[3] = filenames[4] =
filenames[5] = testfile;
filenames[1] = testfile3;
TEST_PAUSE;
}
static void setup(void)
{
tst_sig(NOFORK, DEF_HANDLER, cleanup);
TEST_PAUSE;
tst_tmpdir();
fd2 = SAFE_OPEN(cleanup, ".", O_DIRECTORY);
SAFE_FILE_PRINTF(cleanup, "test_file", "A");
fd3 = SAFE_OPEN(cleanup, "test_file", O_RDWR);
#if !defined(UCLINUX)
outside_buf = SAFE_MMAP(cleanup, 0, 1, PROT_NONE,
MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
#endif
addr4 = SAFE_MEMALIGN(cleanup, getpagesize(), (4096 * 10));
addr5 = addr4 + 1;
fs_type = tst_fs_type(cleanup, ".");
if (fs_type != TST_TMPFS_MAGIC)
fd4 = SAFE_OPEN(cleanup, "test_file", O_RDWR | O_DIRECT);
}
void setup(void)
{
if ((tst_kvercmp(2, 6, 17)) < 0) {
tst_brkm(TCONF, cleanup, "This test can only run on kernels "
"that are 2.6.17 or higher");
}
TEST_PAUSE;
tst_sig(FORK, DEF_HANDLER, cleanup);
tst_tmpdir();
SAFE_FILE_PRINTF(cleanup, TEST_FILE, STR);
rdfd = SAFE_OPEN(cleanup, TEST_FILE, O_RDONLY);
wrfd = SAFE_OPEN(cleanup, TEST_FILE2,
O_WRONLY | O_CREAT, 0644);
appendfd = SAFE_OPEN(cleanup, TEST_FILE3,
O_RDWR | O_CREAT | O_APPEND, 0644);
SAFE_PIPE(cleanup, pipes);
SAFE_WRITE(cleanup, 1, pipes[1], STR, sizeof(STR) - 1);
}
static void setup(void)
{
char *tmpdir;
if (tst_kvercmp(2, 6, 16) < 0)
tst_brkm(TCONF, NULL, "This test needs kernel 2.6.16 or newer");
tst_sig(NOFORK, DEF_HANDLER, cleanup);
TEST_PAUSE;
tst_tmpdir();
/* Initialize test dir and file names */
tmpdir = tst_get_tmpdir();
sprintf(testfilepath, PATHNAME"/mknodattestfile%d", getpid());
sprintf(testfile, "mknodattestfile%d", getpid());
sprintf(testfile2, "mknodattestfile2%d", getpid());
sprintf(testfile3, "%s/mknodattestfile3%d", tmpdir, getpid());
free(tmpdir);
SAFE_MKDIR(cleanup, PATHNAME, 0700);
dir_fd = SAFE_OPEN(cleanup, PATHNAME, O_DIRECTORY);
fd = SAFE_OPEN(cleanup, testfile2, O_CREAT | O_RDWR, 0600);
}
static void setup(void)
{
fd[0] = SAFE_OPEN("testfile1", O_RDWR | O_CREAT, 0644);
fd[1] = SAFE_OPEN("testfile2", O_RDWR | O_CREAT, 0644);
SAFE_FSETXATTR(fd[1], SECURITY_KEY, VALUE, VALUE_SIZE, XATTR_CREATE);
}
static void setup(void)
{
fd1 = SAFE_OPEN("file1", O_RDWR | O_CREAT, 0644);
SAFE_FTRUNCATE(fd1, getpagesize());
fd2 = SAFE_OPEN("file2", O_WRONLY | O_CREAT, 0644);
fd4 = SAFE_OPEN(".", O_RDONLY);
SAFE_PIPE(fd5);
}
static void setup(void)
{
fd1 = SAFE_OPEN("file1", O_RDWR | O_CREAT, 0644);
SAFE_FTRUNCATE(fd1, getpagesize());
fd2 = SAFE_OPEN("file2", O_RDONLY | O_CREAT, 0644);
SAFE_PIPE(fd4);
wr_iovec3[0].iov_base = tst_get_bad_addr(NULL);
}
int main(int argc, char *argv[])
{
pid_t cpid2;
char path[BUFSIZ];
int lc;
int fd;
tst_parse_opts(argc, argv, NULL, NULL);
setup();
for (lc = 0; TEST_LOOPING(lc); lc++) {
tst_count = 0;
parentuid = geteuid();
parentgid = getegid();
cpid1 = ltp_clone_quick(CLONE_NEWUSER | SIGCHLD,
(void *)child_fn1, NULL);
if (cpid1 < 0)
tst_brkm(TBROK | TERRNO, cleanup,
"cpid1 clone failed");
cpid2 = ltp_clone_quick(CLONE_NEWUSER | SIGCHLD,
(void *)child_fn2, NULL);
if (cpid2 < 0)
tst_brkm(TBROK | TERRNO, cleanup,
"cpid2 clone failed");
if (setgroupstag == false) {
sprintf(path, "/proc/%d/setgroups", cpid1);
fd = SAFE_OPEN(cleanup, path, O_WRONLY, 0644);
SAFE_WRITE(cleanup, 1, fd, "deny", 4);
SAFE_CLOSE(cleanup, fd);
sprintf(path, "/proc/%d/setgroups", cpid2);
fd = SAFE_OPEN(cleanup, path, O_WRONLY, 0644);
SAFE_WRITE(cleanup, 1, fd, "deny", 4);
SAFE_CLOSE(cleanup, fd);
}
updatemap(cpid1, UID_MAP, CHILD1UID, parentuid, cleanup);
updatemap(cpid2, UID_MAP, CHILD2UID, parentuid, cleanup);
updatemap(cpid1, GID_MAP, CHILD1GID, parentuid, cleanup);
updatemap(cpid2, GID_MAP, CHILD2GID, parentuid, cleanup);
TST_SAFE_CHECKPOINT_WAKE_AND_WAIT(cleanup, 1);
tst_record_childstatus(cleanup, cpid1);
tst_record_childstatus(cleanup, cpid2);
}
cleanup();
tst_exit();
}
static void mylinkat_test(struct test_struct *desc)
{
int fd;
TEST(mylinkat
(*desc->oldfd, desc->oldfn, *desc->newfd, desc->newfn,
desc->flags));
if (TEST_ERRNO == desc->expected_errno) {
if (STD_FUNCTIONAL_TEST) {
if (TEST_RETURN == 0 && desc->referencefn1 != NULL) {
int tnum = rand(), vnum = ~tnum;
fd = SAFE_OPEN(cleanup, desc->referencefn1,
O_RDWR);
SAFE_WRITE(cleanup, 1, fd, &tnum, sizeof(tnum));
SAFE_CLOSE(cleanup, fd);
fd = SAFE_OPEN(cleanup, desc->referencefn2,
O_RDONLY);
SAFE_READ(cleanup, 1, fd, &vnum, sizeof(vnum));
SAFE_CLOSE(cleanup, fd);
if (tnum == vnum)
tst_resm(TPASS,
"linkat is functionality correct");
else {
tst_resm(TFAIL,
"The link file's content isn't "
"as same as the original file's "
"although linkat returned 0");
}
} else {
if (TEST_RETURN == 0)
tst_resm(TPASS,
"linkat succeeded as expected");
else
tst_resm(TPASS | TTERRNO,
"linkat failed as expected");
}
} else
tst_resm(TPASS, "Test passed");
} else {
if (TEST_RETURN == 0)
tst_resm(TFAIL, "linkat succeeded unexpectedly");
else
tst_resm(TFAIL | TTERRNO,
"linkat failed unexpectedly; expected %d - %s",
desc->expected_errno,
strerror(desc->expected_errno));
}
}
int main(int argc, char *argv[])
{
int status;
int lc;
int childpid;
int parentuid;
int parentgid;
char path[BUFSIZ];
char content[BUFSIZ];
int fd;
tst_parse_opts(argc, argv, NULL, NULL);
setup();
for (lc = 0; TEST_LOOPING(lc); lc++) {
tst_count = 0;
childpid = ltp_clone_quick(CLONE_NEWUSER | SIGCHLD,
(void *)child_fn1, NULL);
if (childpid < 0)
tst_brkm(TFAIL | TERRNO, cleanup, "clone failed");
parentuid = geteuid();
parentgid = getegid();
sprintf(path, "/proc/%d/uid_map", childpid);
sprintf(content, "100 %d 1", parentuid);
fd = SAFE_OPEN(cleanup, path, O_WRONLY, 0644);
SAFE_WRITE(cleanup, 1, fd, content, strlen(content));
SAFE_CLOSE(cleanup, fd);
sprintf(path, "/proc/%d/gid_map", childpid);
sprintf(content, "100 %d 1", parentgid);
fd = SAFE_OPEN(cleanup, path, O_WRONLY, 0644);
SAFE_WRITE(cleanup, 1, fd, content, strlen(content));
SAFE_CLOSE(cleanup, fd);
TST_SAFE_CHECKPOINT_WAKE(cleanup, 0);
if (waitpid(childpid, &status, 0) < 0)
tst_brkm(TBROK | TERRNO, cleanup, "waitpid failed");
if (WIFSIGNALED(status)) {
tst_resm(TFAIL, "child was killed with signal = %d",
WTERMSIG(status));
} else if (WIFEXITED(status) && WEXITSTATUS(status) != 0)
tst_resm(TFAIL, "child exited abnormally");
else
tst_resm(TPASS, "the uid and the gid are right inside "
"the container");
}
cleanup();
tst_exit();
}
static void setup(void)
{
tst_sig(NOFORK, DEF_HANDLER, cleanup);
TEST_PAUSE;
tst_tmpdir();
memset(buf, 0x42, sizeof(buf));
fd = SAFE_OPEN(cleanup, "data_file", O_WRONLY | O_CREAT, 0666);
SAFE_WRITE(cleanup, 1, fd, buf, sizeof(buf));
SAFE_CLOSE(cleanup, fd);
fd = SAFE_OPEN(cleanup, "data_file", O_RDONLY);
}
static void setup(void)
{
char cur_dir_path[512];
check_execveat();
SAFE_MKDIR(TESTDIR, 0777);
SAFE_CP(TEST_APP, TEST_REL_APP);
SAFE_GETCWD(cur_dir_path, sizeof(cur_dir_path));
sprintf(app_abs_path, "%s/%s", cur_dir_path, TEST_REL_APP);
fd1 = SAFE_OPEN(TESTDIR, O_DIRECTORY);
fd4 = SAFE_OPEN(TEST_REL_APP, O_PATH);
}
static void setup(void)
{
if ((tst_kvercmp(2, 6, 17)) < 0) {
tst_brkm(TCONF, cleanup, "This test can only run on "
"kernels that are 2.6.17 or higher");
}
tst_sig(NOFORK, DEF_HANDLER, cleanup);
TEST_PAUSE;
tst_tmpdir();
if (tst_fs_type(cleanup, ".") == TST_NFS_MAGIC) {
tst_brkm(TCONF, cleanup, "Cannot do splice() "
"on a file located on an NFS filesystem");
}
filefd = SAFE_OPEN(cleanup, TESTFILE,
O_WRONLY | O_CREAT, 0644);
SAFE_PIPE(cleanup, pipes);
ivc.iov_base = buffer;
ivc.iov_len = TEST_BLOCK_SIZE;
}
static void setup(void)
{
const char *fs_type;
tst_sig(FORK, DEF_HANDLER, cleanup);
tst_require_root();
tst_tmpdir();
fs_type = tst_dev_fs_type();
device = tst_acquire_device(cleanup);
if (!device)
tst_brkm(TCONF, cleanup, "Failed to obtain block device");
tst_mkfs(cleanup, device, fs_type, NULL);
memset(long_path, 'a', PATH_MAX + 1);
SAFE_MKDIR(cleanup, MNTPOINT, DIR_MODE);
if (mount(device, MNTPOINT, fs_type, 0, NULL))
tst_brkm(TBROK | TERRNO, cleanup, "mount() failed");
mount_flag = 1;
fd = SAFE_OPEN(cleanup, MNTPOINT "/file", O_CREAT | O_RDWR);
TEST_PAUSE;
}
static void setup(void)
{
tst_sig(NOFORK, DEF_HANDLER, cleanup);
TEST_PAUSE;
tst_tmpdir();
sprintf(fname, "tfile_%d", getpid());
fd = SAFE_OPEN(cleanup, fname, O_RDWR | O_CREAT, 0700);
SAFE_WRITE(cleanup, 1, fd, fname, 1);
/* close the file we have open */
SAFE_CLOSE(cleanup, fd);
if ((fd_notify = myfanotify_init(FAN_CLASS_NOTIF, O_RDONLY)) < 0) {
if (errno == ENOSYS) {
tst_brkm(TCONF, cleanup,
"fanotify is not configured in this kernel.");
} else {
tst_brkm(TBROK | TERRNO, cleanup,
"fanotify_init failed");
}
}
}
static void setup(void)
{
int fd;
tst_sig(NOFORK, DEF_HANDLER, cleanup);
TEST_PAUSE;
tst_tmpdir();
sprintf(fname, "fname_%d", getpid());
fd = SAFE_OPEN(cleanup, fname, O_RDWR | O_CREAT, 0644);
SAFE_CLOSE(cleanup, fd);
sprintf(sname, "symlink_%d", getpid());
SAFE_SYMLINK(cleanup, fname, sname);
sprintf(dir, "dir_%d", getpid());
SAFE_MKDIR(cleanup, dir, 0755);
if ((fd_notify = myfanotify_init(FAN_CLASS_NOTIF | FAN_NONBLOCK,
O_RDONLY)) < 0) {
if (errno == ENOSYS) {
tst_brkm(TCONF, cleanup,
"fanotify is not configured in this kernel.");
} else {
tst_brkm(TBROK | TERRNO, cleanup,
"fanotify_init failed");
}
}
}
static void do_open(char *file, int flag, char *flagstr)
{
int fd;
fd = SAFE_OPEN(cleanup, file, O_RDONLY | flag);
SAFE_CLOSE(cleanup, fd);
}
static void do_open(char *file, int flag)
{
int fd;
fd = SAFE_OPEN(file, O_RDONLY | flag);
SAFE_CLOSE(fd);
}
void dochild(void)
{
int fd;
struct flock flocks;
#ifdef UCLINUX
TST_CHECKPOINT_INIT(NULL);
#endif
fd = SAFE_OPEN(NULL, filename, O_RDWR);
tst_resm(TINFO, "Child locks file");
flocks.l_type = F_WRLCK;
flocks.l_whence = SEEK_CUR;
flocks.l_start = recstart;
flocks.l_len = reclen;
if (fcntl(fd, F_SETLKW, &flocks) < 0)
tst_brkm(TFAIL, NULL, "child fcntl failed");
TST_SAFE_CHECKPOINT_WAKE_AND_WAIT(NULL, 0);
tst_resm(TINFO, "Child unlocks file");
tst_exit();
}
static void setup(void)
{
tst_sig(NOFORK, DEF_HANDLER, cleanup);
TEST_PAUSE;
tst_tmpdir();
sprintf(fname, "tfile_%d", getpid());
fd = SAFE_OPEN(cleanup, fname, O_RDWR | O_CREAT, 0700);
SAFE_WRITE(cleanup, 1, fd, buf, BUF_SIZE);
SAFE_CLOSE(cleanup, fd);
fd_notify = syscall(__NR_inotify_init1, O_NONBLOCK);
if (fd_notify < 0) {
if (errno == ENOSYS) {
tst_brkm(TCONF, cleanup,
"inotify is not configured in this kernel.");
} else {
tst_brkm(TBROK | TERRNO, cleanup,
"inotify_init failed");
}
}
wd = myinotify_add_watch(fd_notify, fname, IN_ALL_EVENTS);
if (wd < 0) {
tst_brkm(TBROK | TERRNO, cleanup,
"inotify_add_watch (%d, %s, IN_ALL_EVENTS) failed",
fd_notify, fname);
};
SAFE_FILE_SCANF(cleanup, "/proc/sys/fs/inotify/max_queued_events",
"%d", &max_events);
}
static void setup(void)
{
int i, fd;
fd = SAFE_OPEN(TEST_FILE, O_RDWR | O_CREAT, 0664);
pagesize = getpagesize();
/* Writing 16 pages of random data into this file */
for (i = 0; i < (pagesize / 2); i++)
SAFE_WRITE(1, fd, STR, sizeof(STR) - 1);
SAFE_FSTAT(fd, &st);
file1 = SAFE_MMAP(0, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
file2 = SAFE_MMAP(0, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
file3 = SAFE_MMAP(0, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
shared_anon = SAFE_MMAP(0, MAP_SIZE, PROT_READ, MAP_SHARED |
MAP_ANONYMOUS, -1, 0);
nonalign = file1 + 100;
ptr_addr = SAFE_MALLOC(st.st_size);
tmp_addr = (void*)LTP_ALIGN((long)ptr_addr, pagesize);
/* unmap as last step to avoid subsequent mmap(s) pick same address */
SAFE_MUNMAP(file2 + st.st_size - pagesize, pagesize);
SAFE_CLOSE(fd);
tcases_filter();
}
static void run_targets(const char *dirname, char *cfile, pid_t tid)
{
int i, k, fd;
char subdir[PATH_MAX] = {0};
char *output_file;
char buf[11];
const char *const cmd_run[] = {cfile, NULL};
SAFE_ASPRINTF(&output_file, "%s/cmd.out", dirname);
/* run each binary */
for (i = 0; i < dirs_num; ++i) {
for (k = 0; k < file_num; ++k) {
snprintf(cfile, PATH_MAX, "%s%s/%d.%d.%d",
dirname, subdir, tid, i, k);
tst_run_cmd(cmd_run, output_file, NULL, 0);
fd = SAFE_OPEN(output_file, O_RDONLY);
SAFE_READ(1, fd, buf, 11);
if (strncmp(buf, "hello world", 11))
tst_brk(TFAIL, "command printed wrong message");
SAFE_CLOSE(fd);
}
strcat(subdir, "/dir");
}
free(output_file);
}
/*
* void
* setup() - performs all ONE TIME setup for this test.
* Create a temporary directory and change directory to it.
* Create a test file under temporary directory and close it
* Change the ownership of test file to that of "ltpuser1" user.
*/
void setup(void)
{
struct passwd *ltpuser; /* password struct for ltpuser1 */
struct group *ltpgroup; /* group struct for ltpuser1 */
int fd; /* file descriptor variable */
gid_t group1_gid; /* user and process group id's */
uid_t user1_uid;
tst_sig(FORK, DEF_HANDLER, cleanup);
TEST_PAUSE;
tst_require_root();
tst_tmpdir();
/* Get the uid of guest user - ltpuser1 */
if ((ltpuser = getpwnam(LTPUSER)) == NULL)
tst_brkm(TBROK, cleanup, "getpwnam failed");
user1_uid = ltpuser->pw_uid;
/* Get the group id of guest user - ltpuser1 */
if ((ltpgroup = getgrnam(LTPGRP)) == NULL)
tst_brkm(TBROK, cleanup, "getgrnam failed");
group1_gid = ltpgroup->gr_gid;
fd = SAFE_OPEN(cleanup, TESTFILE, O_RDWR | O_CREAT, FILE_MODE);
SAFE_CLOSE(cleanup, fd);
SAFE_CHOWN(cleanup, TESTFILE, user1_uid, group1_gid);
SAFE_SETGID(cleanup, group1_gid);
}
static void setup(void)
{
int ret;
SAFE_MKDIR(mntpoint, DIR_MODE);
SAFE_MOUNT(tst_device->dev, mntpoint, tst_device->fs_type, 0, NULL);
mount_flag = 1;
sprintf(fname, "%s/tfile_%d", mntpoint, getpid());
fd = SAFE_OPEN(fname, O_RDWR | O_CREAT, 0700);
ret = write(fd, fname, 1);
if (ret == -1) {
tst_brk(TBROK | TERRNO,
"write(%d, %s, 1) failed", fd, fname);
}
/* close the file we have open */
SAFE_CLOSE(fd);
fd_notify = myinotify_init();
if (fd_notify < 0) {
if (errno == ENOSYS)
tst_brk(TCONF,
"inotify is not configured in this kernel.");
else
tst_brk(TBROK | TERRNO,
"inotify_init failed");
}
tst_umount(mntpoint);
mount_flag = 0;
}
static void setup(void)
{
memset(buf, 0x61, CHUNK);
memset(initbuf, 0, CHUNK * 2);
fd = SAFE_OPEN("file", O_RDWR | O_CREAT, 0644);
}
static void test_hugemmap(void)
{
long page_sz = 0;
fildes = SAFE_OPEN(TEMPFILE, O_RDWR | O_CREAT, 0666);
beforetest = SAFE_READ_MEMINFO("HugePages_Free:");
page_sz = SAFE_READ_MEMINFO("Hugepagesize:") * 1024;
addr = mmap(NULL, page_sz, PROT_READ | PROT_WRITE,
MAP_SHARED, fildes, 0);
if (addr == MAP_FAILED) {
tst_res(TFAIL | TERRNO, "mmap() Failed on %s",
TEMPFILE);
} else {
tst_res(TPASS, "call succeeded");
/* force to allocate page and change HugePages_Free */
*(int *)addr = 0;
/* Make sure the number of free huge pages AFTER testing decreased */
aftertest = SAFE_READ_MEMINFO("HugePages_Free:");
hugepagesmapped = beforetest - aftertest;
if (hugepagesmapped < 1)
tst_res(TWARN, "Number of HUGEPAGES_FREE stayed the"
" same. Okay if multiple copies running due"
" to test collision.");
munmap(addr, page_sz);
}
close(fildes);
}
static void setup(void)
{
struct stat c_buf, l_buf;
if ((tst_kvercmp(2, 6, 16)) < 0)
tst_brkm(TCONF, NULL, "This test needs kernel 2.6.16 or newer");
tst_require_root(NULL);
tst_sig(NOFORK, DEF_HANDLER, cleanup);
TEST_PAUSE;
tst_tmpdir();
dirfd = SAFE_OPEN(cleanup, "./", O_DIRECTORY);
SAFE_TOUCH(cleanup, TESTFILE, 0600, NULL);
SAFE_SYMLINK(cleanup, TESTFILE, TESTFILE_LINK);
SAFE_STAT(cleanup, TESTFILE_LINK, &c_buf);
SAFE_LSTAT(cleanup, TESTFILE_LINK, &l_buf);
if (l_buf.st_uid == set_uid || l_buf.st_gid == set_gid) {
tst_brkm(TBROK | TERRNO, cleanup,
"link_uid(%d) == set_uid(%d) or link_gid(%d) == "
"set_gid(%d)", l_buf.st_uid, set_uid, l_buf.st_gid,
set_gid);
}
}
