int main(int ac, char **av) {
        int lc,num,i;                 /* loop counter */
        char *msg;              /* message returned from parse_opts */
	cpu_set_t mask;
	unsigned int len = sizeof(cpu_set_t);

        /* parse standard options */
        if ((msg = parse_opts(ac, av, (option_t *)NULL, NULL)) != (char *)NULL){
             tst_brkm(TBROK, cleanup, "OPTION PARSING ERROR - %s", msg);
             tst_exit();
           }

        setup();

	TEST(num=sysconf(_SC_NPROCESSORS_CONF));  //the number of processor(s)
        tst_resm(TINFO,"system has %d processor(s).", num);

        /* Check looping state if -i option given */
        for (lc = 0; TEST_LOOPING(lc); ++lc) {
                Tst_count = 0;
                for (testno = 0; testno < TST_TOTAL; ++testno) {
                     QUICK_TEST(sched_getaffinity(0, len, (cpu_set_t *)-1));
                     QUICK_TEST(sched_getaffinity(0, 0, &mask));
                     QUICK_TEST(sched_getaffinity(getpid() + 1, len, &mask));

		     CPU_ZERO(&mask); //clear
                     TEST(sched_getaffinity(0,len,&mask));     //call sched_getaffinity()
		     if(TEST_RETURN == -1) {
                 	   tst_resm(TFAIL|TTERRNO, "could not get cpu affinity");
			cleanup();
			tst_exit();
                     } else {
				tst_resm(TINFO,"cpusetsize is %d", len);
				tst_resm(TINFO,"mask.__bits[0] = %lu ",mask.__bits[0]);
				for(i=0;i<num;i++){    // check the processor
	                        	TEST(CPU_ISSET(i,&mask));
					if (TEST_RETURN != -1 ){
                                	tst_resm(TPASS,"sched_getaffinity() succeed ,this process %d is running processor: %d",getpid(), i);
					}
			        }
	                    }


                     }
		}
        cleanup();
	tst_exit();
}
static void do_test(void)
{
	int i;
	cpu_set_t *mask;
	int nrcpus = 1024;
	pid_t pid;
	unsigned len;

#if __GLIBC_PREREQ(2, 7)
realloc:
	mask = CPU_ALLOC(nrcpus);
#else
	mask = malloc(sizeof(cpu_set_t));
#endif
	if (mask == NULL)
		tst_brkm(TFAIL | TTERRNO, cleanup, "fail to get enough memory");
#if __GLIBC_PREREQ(2, 7)
	len = CPU_ALLOC_SIZE(nrcpus);
	CPU_ZERO_S(len, mask);
#else
	len = sizeof(cpu_set_t);
	CPU_ZERO(mask);
#endif
	/* positive test */
	TEST(sched_getaffinity(0, len, mask));
	if (TEST_RETURN == -1) {
		CPU_FREE(mask);
#if __GLIBC_PREREQ(2, 7)
		if (errno == EINVAL && nrcpus < (1024 << 8)) {
			nrcpus = nrcpus << 2;
			goto realloc;
		}
#else
		if (errno == EINVAL)
			tst_resm(TFAIL, "NR_CPUS > 1024, we'd better use a "
				 "newer glibc(>= 2.7)");
		else
#endif
			tst_resm(TFAIL | TTERRNO, "fail to get cpu affinity");
		cleanup();
	} else {
		tst_resm(TINFO, "cpusetsize is %d", len);
		tst_resm(TINFO, "mask.__bits[0] = %lu ", mask->__bits[0]);
		for (i = 0; i < num; i++) {
#if __GLIBC_PREREQ(2, 7)
			TEST(CPU_ISSET_S(i, len, mask));
#else
			TEST(CPU_ISSET(i, mask));
#endif
			if (TEST_RETURN != -1)
				tst_resm(TPASS, "sched_getaffinity() succeed, "
					 "this process %d is running "
					 "processor: %d", getpid(), i);
		}
	}

#if __GLIBC_PREREQ(2, 7)
	CPU_ZERO_S(len, mask);
#else
	CPU_ZERO(mask);
#endif
	/* negative tests */
	QUICK_TEST(sched_getaffinity(0, len, (cpu_set_t *) - 1));
	QUICK_TEST(sched_getaffinity(0, 0, mask));
	/*
	 * pid_t -> int -- the actual kernel limit is lower
	 * though, but this is a negative test, not a positive
	 * one.
	 *
	 * Push comes to shove, if the user doesn't have the
	 * ability to kill(3) processes (errno = EPERM), then
	 * set the pid to the highest possible represented
	 * value and cross your fingers in the hope that
	 * a) Linux somehow hasn't started allocating PIDs
	 * this high and b) the PID = INT_MAX isn't in fact
	 * running.
	 */
	for (pid = 2; pid < INT_MAX; pid++) {
		if (kill(pid, 0) == -1) {
			if (errno == ESRCH)
				break;
			else if (errno == EPERM)
				pid = INT_MAX - 1;
		}
	}
	QUICK_TEST(sched_getaffinity(pid, len, mask));
	CPU_FREE(mask);
}