/* * setup() - performs all the ONE TIME setup for this test. */ void setup(void) { key_t shmkey2; tst_require_root(); /* Switch to nobody user for correct error code collection */ ltpuser = getpwnam(nobody_uid); if (setuid(ltpuser->pw_uid) == -1) { tst_resm(TINFO, "setuid failed to " "to set the effective uid to %d", ltpuser->pw_uid); perror("setuid"); } tst_sig(NOFORK, DEF_HANDLER, cleanup); TEST_PAUSE; /* * Create a temporary directory and cd into it. * This helps to ensure that a unique msgkey is created. * See ../lib/libipc.c for more information. */ tst_tmpdir(); /* get an IPC resource key */ shmkey = getipckey(); /* create a shared memory segment without read or write permissions */ if ((shm_id_1 = shmget(shmkey, SHM_SIZE, IPC_CREAT | IPC_EXCL)) == -1) { tst_brkm(TBROK, cleanup, "couldn't create shared memory " "segment #1 in setup()"); } /* Get an new IPC resource key. */ shmkey2 = getipckey(); /* create a shared memory segment with read and write permissions */ if ((shm_id_2 = shmget(shmkey2, SHM_SIZE, IPC_CREAT | IPC_EXCL | SHM_RW)) == -1) { tst_brkm(TBROK, cleanup, "couldn't create shared memory " "segment #2 in setup()"); } }
static void setup(void) { 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); tst_tmpdir(); fs_type = tst_dev_fs_type(); device = tst_acquire_device(cleanup); if (!device) tst_brkm(TCONF, cleanup, "Failed to acquire device"); TEST_PAUSE; ltpuser = SAFE_GETPWNAM(cleanup, "nobody"); SAFE_TOUCH(cleanup, TEST_FILE, 0644, NULL); memset(nametoolong, 'a', PATH_MAX+1); SAFE_TOUCH(cleanup, TEST_EXIST, 0644, NULL); SAFE_SYMLINK(cleanup, TEST_ELOOP, "test_file_eloop2"); SAFE_SYMLINK(cleanup, "test_file_eloop2", TEST_ELOOP); SAFE_MKDIR(cleanup, "./tmp", DIR_MODE); SAFE_TOUCH(cleanup, TEST_EACCES, 0666, NULL); tst_mkfs(cleanup, device, fs_type, NULL); SAFE_MKDIR(cleanup, "mntpoint", DIR_MODE); if (mount(device, "mntpoint", fs_type, 0, NULL) < 0) { tst_brkm(TBROK | TERRNO, cleanup, "mount device:%s failed", device); } mount_flag = 1; max_hardlinks = tst_fs_fill_hardlinks(cleanup, "emlink_dir"); }
static void setup(void) { tst_require_root(NULL); uid = geteuid(); ncpus = tst_ncpus_max(); /* Current mask */ mask = CPU_ALLOC(ncpus); if (mask == NULL) tst_brkm(TBROK | TERRNO, cleanup, "CPU_ALLOC(%ld) failed", ncpus); mask_size = CPU_ALLOC_SIZE(ncpus); if (sched_getaffinity(0, mask_size, mask) < 0) tst_brkm(TBROK | TERRNO, cleanup, "sched_getaffinity() failed"); /* Mask with one more cpu than available on the system */ emask = CPU_ALLOC(ncpus + 1); if (emask == NULL) tst_brkm(TBROK | TERRNO, cleanup, "CPU_ALLOC(%ld) failed", ncpus + 1); emask_size = CPU_ALLOC_SIZE(ncpus + 1); CPU_ZERO_S(emask_size, emask); CPU_SET_S(ncpus, emask_size, emask); privileged_pid = tst_fork(); if (privileged_pid == 0) { pause(); exit(0); } else if (privileged_pid < 0) { tst_brkm(TBROK | TERRNO, cleanup, "fork() failed"); } /* Dropping the root privileges */ ltpuser = getpwnam(nobody_uid); if (ltpuser == NULL) tst_brkm(TBROK | TERRNO, cleanup, "getpwnam failed for user id %s", nobody_uid); SAFE_SETEUID(cleanup, ltpuser->pw_uid); /* this pid is not used by the OS */ free_pid = tst_get_unused_pid(cleanup); }
static void setup(void) { int i; struct passwd *ltpuser; const char *fs_type; tst_require_root(NULL); tst_sig(NOFORK, DEF_HANDLER, cleanup); tst_tmpdir(); fs_type = tst_dev_fs_type(); device = tst_acquire_device(cleanup); if (!device) tst_brkm(TCONF, cleanup, "Failed to acquire device"); tst_mkfs(cleanup, device, fs_type, NULL); TEST_PAUSE; /* mount a read-only file system for EROFS test */ SAFE_MKDIR(cleanup, MNT_POINT, DIR_MODE); if (mount(device, MNT_POINT, fs_type, MS_RDONLY, NULL) < 0) { tst_brkm(TBROK | TERRNO, cleanup, "mount device:%s failed", device); } mount_flag = 1; ltpuser = SAFE_GETPWNAM(cleanup, "nobody"); SAFE_SETEUID(cleanup, ltpuser->pw_uid); SAFE_MKDIR(cleanup, DIR_TEMP, DIR_TEMP_MODE); /* * NOTE: the ELOOP test is written based on that the consecutive * symlinks limits in kernel is hardwired to 40. */ SAFE_MKDIR(cleanup, "test_eloop", DIR_MODE); SAFE_SYMLINK(cleanup, "../test_eloop", "test_eloop/test_eloop"); for (i = 0; i < 43; i++) strcat(elooppathname, ELOPFILE); }
/* * 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 group ownership on testfile. */ void setup(void) { int fd; /* file handler for testfile */ TEST_PAUSE; tst_require_root(); tst_sig(FORK, DEF_HANDLER, cleanup); tst_tmpdir(); ltpuser = getpwnam(nobody_uid); if (ltpuser == NULL) tst_brkm(TBROK | TERRNO, NULL, "getpwnam(\"nobody\") failed"); if (setegid(ltpuser->pw_gid) == -1) tst_brkm(TBROK | TERRNO, NULL, "setegid(%d) failed", ltpuser->pw_gid); if (seteuid(ltpuser->pw_uid) == -1) tst_brkm(TBROK | TERRNO, NULL, "seteuid(%d) failed", ltpuser->pw_uid); /* Create a test file under temporary directory */ if ((fd = open(TESTFILE, O_RDWR | O_CREAT, FILE_MODE)) == -1) tst_brkm(TBROK | TERRNO, cleanup, "open(%s, O_RDWR|O_CREAT, %o) failed", TESTFILE, FILE_MODE); if (seteuid(0) == -1) tst_brkm(TBROK | TERRNO, cleanup, "seteuid(0) failed"); if (fchown(fd, -1, 0) < 0) tst_brkm(TBROK | TERRNO, cleanup, "fchown failed"); if (fchmod(fd, NEW_PERMS) < 0) tst_brkm(TBROK | TERRNO, cleanup, "fchmod failed"); if (seteuid(ltpuser->pw_uid) == -1) tst_brkm(TBROK | TERRNO, cleanup, "seteuid to nobody failed"); if (close(fd) == -1) tst_brkm(TBROK | TERRNO, cleanup, "closing %s failed", TESTFILE); }
int main(int ac, char **av) { int lc, i; char *msg; if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL) tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg); setup(); TEST_EXP_ENOS(exp_enos); /* * FIXME (garrcoop): this should really test out whether or not the * process's mappable address space is indeed accessible by the * current user, instead of needing to be run by root all the time. */ tst_require_root(NULL); for (lc = 0; TEST_LOOPING(lc); lc++) { Tst_count = 0; for (i = 0; i < TST_TOTAL; i++) { if (TC[i].setupfunc != NULL) TC[i].setupfunc(TC[i].len); TEST(mlock(*(TC[i].addr), TC[i].len)); /* I'm confused -- given the description above this * should fail as designed, but this application * */ if (TEST_RETURN == -1) tst_resm(TFAIL|TTERRNO, "mlock failed"); else tst_resm(TPASS, "mlock passed"); } } cleanup(); tst_exit(); }
/* * setup() - performs all ONE TIME setup for this test. */ void setup() { char *cur_dir = NULL; tst_require_root(NULL); ltpuser = getpwnam(nobody_uid); if (ltpuser == NULL) tst_brkm(TBROK | TERRNO, cleanup, "getpwnam failed"); if (seteuid(ltpuser->pw_uid) == -1) tst_brkm(TBROK | TERRNO, cleanup, "seteuid(%d) failed", ltpuser->pw_uid); tst_sig(NOFORK, DEF_HANDLER, cleanup); TEST_PAUSE; tst_tmpdir(); /* get the current directory for the first test */ if ((cur_dir = getcwd(cur_dir, 0)) == NULL) { tst_brkm(TBROK | TERRNO, cleanup, "getcwd failed"); } strncpy(good_dir, cur_dir, NSIZE); /* create a file that will be used in test #3 */ if ((fileHandle = creat("file1", MODE1)) == -1) { tst_brkm(TBROK, cleanup, "couldn't create a test file"); } #if !defined(UCLINUX) bad_addr = mmap(0, 1, PROT_NONE, MAP_PRIVATE_EXCEPT_UCLINUX | MAP_ANONYMOUS, 0, 0); if (bad_addr == MAP_FAILED) { tst_brkm(TBROK | TERRNO, cleanup, "mmap failed"); } TC[4].fname = bad_addr; #endif /* create a directory that will be used in test #6 */ if (mkdir("dir6", MODE2) == -1) { tst_brkm(TBROK, cleanup, "couldn't creat a test directory"); } }
static void setup(void) { int fd; unsigned int i; tst_require_root(NULL); for (i = 0; i < ARRAY_SIZE(cdrv); ++i) { fd = open(cdrv[i].file, O_RDWR); if (fd == -1) continue; id = i; close(fd); break; } if (id == -1) tst_brkm(TCONF, NULL, "overclock not supported"); tst_resm(TINFO, "found '%s' driver, sysfs knob '%s'", cdrv[id].name, cdrv[id].file); tst_sig(FORK, DEF_HANDLER, cleanup); SAFE_FILE_SCANF(NULL, cdrv[i].file, "%d", &boost_value); /* change cpu0 scaling governor */ SAFE_FILE_SCANF(NULL, governor, "%s", governor_name); SAFE_FILE_PRINTF(cleanup, governor, "%s", "performance"); /* use only cpu0 */ cpu_set_t set; CPU_ZERO(&set); CPU_SET(0, &set); if (sched_setaffinity(0, sizeof(cpu_set_t), &set) < 0) tst_brkm(TBROK | TERRNO, cleanup, "failed to set CPU0"); struct sched_param params; params.sched_priority = sched_get_priority_max(SCHED_FIFO); if (sched_setscheduler(getpid(), SCHED_FIFO, ¶ms)) { tst_resm(TWARN | TERRNO, "failed to set FIFO sched with max priority"); } }
/* * void * setup(void) - performs all ONE TIME setup for this test. * Exit the test program on receipt of unexpected signals. * Create a temporary directory and change directory to it. * Invoke iividual test setup functions according to the order * set in struct. definition. */ void setup(void) { int i; tst_sig(FORK, DEF_HANDLER, cleanup); test_home = get_current_dir_name(); tst_require_root(NULL); TEST_PAUSE; tst_tmpdir(); tst_mkfs(NULL, device, fstype, NULL); SAFE_MKDIR(cleanup, MNT_POINT, DIR_MODE); /* * mount a read-only file system for test EROFS */ if (mount(device, MNT_POINT, fstype, MS_RDONLY, NULL) < 0) { tst_brkm(TBROK | TERRNO, cleanup, "mount device:%s failed", device); } mount_flag = 1; bad_addr = mmap(0, 1, PROT_NONE, MAP_PRIVATE_EXCEPT_UCLINUX | MAP_ANONYMOUS, 0, 0); if (bad_addr == MAP_FAILED) tst_brkm(TBROK | TERRNO, cleanup, "mmap failed"); test_cases[3].pathname = bad_addr; for (i = 0; i < TST_TOTAL; i++) if (test_cases[i].setupfunc != NULL) test_cases[i].setupfunc(); /* * create two symbolic links who point to each other for * test ELOOP. */ SAFE_SYMLINK(cleanup, "test_file4", "test_file5"); SAFE_SYMLINK(cleanup, "test_file5", "test_file4"); }
/* * setup() - performs all the ONE TIME setup for this test. */ void setup(void) { key_t msgkey2; tst_require_root(NULL); tst_sig(NOFORK, DEF_HANDLER, cleanup); /* Set up the expected error numbers for -e option */ TEST_EXP_ENOS(exp_enos); TEST_PAUSE; /* Switch to nobody user for correct error code collection */ ltpuser = getpwnam(nobody_uid); if (setuid(ltpuser->pw_uid) == -1) tst_resm(TINFO, "setuid(%d) failed", ltpuser->pw_uid); /* * Create a temporary directory and cd into it. * This helps to ensure that a unique msgkey is created. * See ../lib/libipc.c for more information. */ tst_tmpdir(); msgkey = getipckey(); /* Get an new IPC resource key. */ msgkey2 = getipckey(); /* now we have a key, so let's create a message queue */ if ((msg_q_1 = msgget(msgkey, IPC_CREAT | IPC_EXCL)) == -1) { tst_brkm(TBROK | TERRNO, cleanup, "Can't create message queue #1"); } /* now let's create another message queue with read & write access */ if ((msg_q_2 = msgget(msgkey2, IPC_CREAT | IPC_EXCL | MSG_RD | MSG_WR)) == -1) { tst_brkm(TBROK | TERRNO, cleanup, "Can't create message queue #2"); } }
void setup() { int fd; tst_sig(NOFORK, DEF_HANDLER, cleanup); tst_require_root(NULL); ltpuser = getpwnam(nobody_uid); if (ltpuser == NULL) tst_brkm(TBROK|TERRNO, NULL, "getpwnam failed"); if (setuid(ltpuser->pw_uid) == -1) tst_brkm(TINFO|TERRNO, NULL, "setuid failed"); TEST_PAUSE; tst_tmpdir(); if (mkdir(TESTDIR, DIR_MODE) < 0) tst_brkm(TBROK|TERRNO, cleanup, "mkdir(%s, %#o) failed", TESTDIR, DIR_MODE); if (chmod(TESTDIR, DIR_MODE) < 0) tst_brkm(TBROK|TERRNO, cleanup, "chmod(%s, %#o) failed", TESTDIR, DIR_MODE); fd = open(TESTFILE, O_RDWR | O_CREAT, FILE_MODE); if (fd == -1) tst_brkm(TBROK|TERRNO, cleanup, "open(%s, O_RDWR|O_CREAT, %#o) failed", TESTFILE, FILE_MODE); if (close(fd) == -1) tst_brkm(TBROK|TERRNO, cleanup, "close(%s) failed", TESTFILE); if (chmod(TESTFILE, 0) < 0) tst_brkm(TBROK|TERRNO, cleanup, "chmod(%s, 0) failed", TESTFILE); }
static void setup(void) { int i; const char *fs_type; if (tst_kvercmp(2, 6, 16) < 0) { tst_brkm(TCONF, NULL, "This test can only run on kernels " "that are 2.6.16 and higher"); } tst_require_root(); tst_sig(NOFORK, DEF_HANDLER, cleanup); tst_tmpdir(); fs_type = tst_dev_fs_type(); device = tst_acquire_device(cleanup); if (!device) tst_brkm(TCONF, cleanup, "Failed to acquire device"); tst_mkfs(cleanup, device, fs_type, NULL, NULL); TEST_PAUSE; /* * mount a read-only file system for EROFS test */ SAFE_MKDIR(cleanup, MNT_POINT, DIR_MODE); SAFE_MOUNT(cleanup, device, MNT_POINT, fs_type, MS_RDONLY, NULL); mount_flag = 1; dir_fd = SAFE_OPEN(cleanup, MNT_POINT, O_DIRECTORY); /* * NOTE: the ELOOP test is written based on that the consecutive * symlinks limits in kernel is hardwired to 40. */ SAFE_MKDIR(cleanup, "test_eloop", DIR_MODE); SAFE_SYMLINK(cleanup, "../test_eloop", "test_eloop/test_eloop"); for (i = 0; i < 43; i++) strcat(elooppathname, ELOPFILE); }
static void setup(void) { int i; tst_require_root(NULL); tst_sig(FORK, DEF_HANDLER, cleanup); ltpuser = getpwnam(nobody_uid); if (ltpuser == NULL) tst_brkm(TBROK | TERRNO, NULL, "getpwnam failed"); if (setuid(ltpuser->pw_uid) == -1) tst_brkm(TINFO | TERRNO, NULL, "setuid failed"); TEST_PAUSE; tst_tmpdir(); for (i = 0; i < TST_TOTAL; i++) test_cases[i].setupfunc(); }
/* * setup() - performs all ONE TIME setup for this test */ void setup(void) { tst_require_root(); ltpuser = getpwnam(nobody_uid); UID16_CHECK(ltpuser->pw_uid, "setresuid", cleanup) tst_tmpdir(); sprintf(testfile, "setresuid04file%d.tst", getpid()); /* Create test file */ fd = SAFE_OPEN(cleanup, testfile, O_CREAT | O_RDWR, 0644); tst_sig(FORK, DEF_HANDLER, cleanup); TEST_PAUSE; }
/* * setup() - performs all ONE TIME setup for this test */ void setup(void) { tst_require_root(NULL); ltpuser = getpwnam(nobody_uid); tst_tmpdir(); sprintf(testfile, "setresuid04file%d.tst", getpid()); /* Create test file */ fd = open(testfile, O_CREAT | O_RDWR, 0644); if (fd < 0) tst_brkm(TBROK, cleanup, "cannot creat test file"); tst_sig(FORK, DEF_HANDLER, cleanup); TEST_PAUSE; }
void setup(void) { tst_require_root(); if (tst_kvercmp(2, 6, 32) < 0) tst_brkm(TCONF, NULL, "2.6.32 or greater kernel required"); if (access(PATH_KSM, F_OK) == -1) tst_brkm(TCONF, NULL, "KSM configuration is not enabled"); if (access(PATH_KSM "merge_across_nodes", F_OK) == 0) { SAFE_FILE_SCANF(NULL, PATH_KSM "merge_across_nodes", "%d", &merge_across_nodes); SAFE_FILE_PRINTF(NULL, PATH_KSM "merge_across_nodes", "1"); } mount_mem("memcg", "cgroup", "memory", MEMCG_PATH, MEMCG_PATH_NEW); tst_sig(FORK, DEF_HANDLER, NULL); TEST_PAUSE; }
/* setup() - performs all ONE TIME setup for this test */ void setup(void) { tst_require_root(); tst_sig(NOFORK, DEF_HANDLER, cleanup); /* Check if "nobody" user id exists */ if ((ltpuser = getpwnam(nobody_uid)) == NULL) { tst_brkm(TBROK, NULL, "\"nobody\" user id doesn't exist"); } /* * The value of IO_BITMAP_BITS (include/asm-i386/processor.h) changed * from kernel 2.6.8 to permit 16-bits (65536) ioperm * * Ricky Ng-Adam, [email protected] * */ test_cases = malloc(sizeof(struct test_cases_t) * 2); test_cases[0].num = NUM_BYTES; test_cases[0].turn_on = TURN_ON; test_cases[0].desc = "Invalid I/O address"; test_cases[0].exp_errno = EINVAL; test_cases[1].num = NUM_BYTES; test_cases[1].turn_on = TURN_ON; test_cases[1].desc = "Non super-user"; test_cases[1].exp_errno = EPERM; if ((tst_kvercmp(2, 6, 8) < 0) || (tst_kvercmp(2, 6, 9) == 0)) { /*try invalid ioperm on 1022, 1023, 1024 */ test_cases[0].from = (IO_BITMAP_BITS - NUM_BYTES) + 1; /*try get valid ioperm on 1021, 1022, 1023 */ test_cases[1].from = IO_BITMAP_BITS - NUM_BYTES; } else { /*try invalid ioperm on 65534, 65535, 65536 */ test_cases[0].from = (IO_BITMAP_BITS_16 - NUM_BYTES) + 1; /*try valid ioperm on 65533, 65534, 65535 */ test_cases[1].from = IO_BITMAP_BITS_16 - NUM_BYTES; } TEST_PAUSE; }
void setup(void) { long hpage_size; tst_require_root(); check_hugepage(); tst_sig(FORK, sighandler, cleanup); tst_tmpdir(); orig_hugepages = get_sys_tune("nr_hugepages"); set_sys_tune("nr_hugepages", hugepages, 1); hpage_size = read_meminfo("Hugepagesize:") * 1024; shm_size = hpage_size * hugepages / 2; update_shm_size(&shm_size); shmkey = getipckey(cleanup); TEST_PAUSE; }
static void setup(void) { tst_require_root(); tst_sig(FORK, DEF_HANDLER, NULL); ltpuser = getpwnam("nobody"); if (ltpuser == NULL) tst_brkm(TBROK, NULL, "getpwnam(\"nobody\") failed"); SAFE_SETGID(NULL, ltpuser->pw_gid); SAFE_SETUID(NULL, ltpuser->pw_uid); root = get_group_by_name("root"); ltpgroup = get_group_by_gid(ltpuser->pw_gid); bin = get_group_by_name("bin"); TEST_PAUSE; }
void setup(void) { int fd; tst_require_root(NULL); tst_sig(FORK, DEF_HANDLER, cleanup); TEST_PAUSE; fd = open(SYSFS_OVER, O_RDONLY); if (fd == -1) tst_brkm(TBROK|TERRNO, NULL, "open"); if (read(fd, &overcommit, 1) != 1) tst_brkm(TBROK|TERRNO, NULL, "read"); close(fd); mount_mem("cpuset", "cpuset", NULL, CPATH, CPATH_NEW); mount_mem("memcg", "cgroup", "memory", MEMCG_PATH, MEMCG_PATH_NEW); }
/* * setup() * performs all ONE TIME setup for this test */ void setup(void) { tst_require_root(NULL); tst_sig(NOFORK, DEF_HANDLER, cleanup); /* Check for nobody_uid user id */ if ((ltpuser = getpwnam("nobody")) == NULL) { tst_brkm(TBROK, NULL, "nobody user id doesn't exist"); } /* set the expected errnos... */ TEST_EXP_ENOS(exp_enos); /* Pause if that option was specified * TEST_PAUSE contains the code to fork the test with the -c option. */ TEST_PAUSE; }
void setup(void) { char *cur_dir = NULL; tst_require_root(NULL); tst_sig(FORK, DEF_HANDLER, cleanup); TEST_PAUSE; tst_tmpdir(); if ((cur_dir = getcwd(cur_dir, 0)) == NULL) tst_brkm(TBROK | TERRNO, cleanup, "getcwd failed"); sprintf(good_dir, "%s.%d", cur_dir, getpid()); ltpuser1 = my_getpwnam(user1name); }
void setup() { int fd; tst_sig(NOFORK, DEF_HANDLER, cleanup); tst_require_root(NULL); TEST_PAUSE; tst_tmpdir(); if ((fd = open(TESTFILE, O_RDWR | O_CREAT, FILE_MODE)) == -1) tst_brkm(TBROK | TERRNO, cleanup, "opening %s failed", TESTFILE); if (close(fd) == -1) tst_brkm(TBROK, cleanup, "closing %s failed", TESTFILE); }
static void setup(void) { tst_sig(FORK, DEF_HANDLER, cleanup); tst_require_root(NULL); tst_tmpdir(); switch ((fs_type = tst_fs_type(cleanup, "."))) { case TST_NFS_MAGIC: case TST_TMPFS_MAGIC: tst_brkm(TCONF, cleanup, "Cannot do swapon on a file on %s filesystem", tst_fs_type_name(fs_type)); break; } TEST_PAUSE; }
static void setup(void) { tst_require_root(); ltpuser = getpwnam("nobody"); if (ltpuser == NULL) tst_brkm(TBROK, NULL, "nobody must be a valid user."); tst_tmpdir(); sprintf(testfile, "setreuid07file%d.tst", getpid()); /* Create test file */ fd = SAFE_OPEN(cleanup, testfile, O_CREAT | O_RDWR, 0644); tst_sig(FORK, DEF_HANDLER, cleanup); TEST_PAUSE; }
void setup(void) { long hpage_size; char buf[BUFSIZ]; tst_require_root(NULL); tst_sig(NOFORK, DEF_HANDLER, cleanup); tst_tmpdir(); orig_hugepages = get_sys_tune("nr_hugepages"); set_sys_tune("nr_hugepages", hugepages, 1); hpage_size = read_meminfo("Hugepagesize:") * 1024; shm_size = hpage_size; read_file(PATH_SHMMNI, buf); orig_shmmni = SAFE_STRTOL(cleanup, buf, 0, LONG_MAX); snprintf(buf, BUFSIZ, "%ld", hugepages / 2); write_file(PATH_SHMMNI, buf); /* * Use a while loop to create the maximum number of memory segments. * If the loop exceeds MAXIDS, then break the test and cleanup. */ num_shms = 0; shm_id_1 = shmget(IPC_PRIVATE, shm_size, SHM_HUGETLB | IPC_CREAT | IPC_EXCL | SHM_RW); while (shm_id_1 != -1) { shm_id_arr[num_shms++] = shm_id_1; if (num_shms == MAXIDS) tst_brkm(TBROK, cleanup, "The maximum number of " "shared memory ID's has been reached. " "Please increase the MAXIDS value in " "the test."); shm_id_1 = shmget(IPC_PRIVATE, shm_size, SHM_HUGETLB | IPC_CREAT | IPC_EXCL | SHM_RW); } if (errno != ENOSPC) tst_brkm(TBROK | TERRNO, cleanup, "shmget #setup"); TEST_PAUSE; }
static void setup(void) { char path[PATH_MAX]; struct passwd *pwd; tst_require_root(); if (tst_get_path(TEST_APP, path, sizeof(path))) { tst_brkm(TBROK, NULL, "Couldn't found "TEST_APP" binary in $PATH"); } tst_tmpdir(); SAFE_CP(tst_rmdir, path, "."); SAFE_CHMOD(cleanup, TEST_APP, 0700); pwd = SAFE_GETPWNAM(tst_rmdir, USER_NAME); nobody_uid = pwd->pw_uid; }
/* * setup() - performs all ONE TIME setup for this test. */ void setup(void) { struct passwd *pw; tst_require_root(); pw = SAFE_GETPWNAM(NULL, "nobody"); nobody_uid = pw->pw_uid; pw = SAFE_GETPWNAM(NULL, "bin"); bin_uid = pw->pw_uid; tst_sig(FORK, DEF_HANDLER, cleanup); TEST_PAUSE; /* Create a temporary directory and make it current. */ tst_tmpdir(); umask(0); }
/* * void * setup() - performs all ONE TIME setup for this test. * Create a temporary directory and cd to it. * Create another test directory under temporary directory. */ void setup(void) { tst_sig(NOFORK, DEF_HANDLER, cleanup); tst_require_root(); ltpuser = getpwnam(nobody_uid); if (setuid(ltpuser->pw_uid) == -1) tst_resm(TINFO | TERRNO, "setuid(%u) failed", ltpuser->pw_uid); TEST_PAUSE; tst_tmpdir(); /* * Create a test directory under temporary directory with specified * mode permissios. */ SAFE_MKDIR(cleanup, TESTDIR, DIR_MODE); }
static void setup(void) { tst_sig(FORK, DEF_HANDLER, cleanup); tst_require_root(NULL); tst_mkfs(NULL, device, fstype, NULL); tst_tmpdir(); if (mkdir(mntpoint, DIR_MODE)) { tst_brkm(TBROK, cleanup, "mkdir(%s, %#o) failed; " "errno = %d: %s", mntpoint, DIR_MODE, errno, strerror(errno)); } TEST_EXP_ENOS(exp_enos); TEST_PAUSE; }