示例#1
0
文件: mem.c 项目: liaoqingwei/ltp
static void gather_node_cpus(char *cpus, long nd)
{
	int ncpus = 0;
	int i;
	long online;
	char buf[BUFSIZ];
	char path[BUFSIZ], path1[BUFSIZ];

	while (path_exist(PATH_SYS_SYSTEM "/cpu/cpu%d", ncpus))
		ncpus++;

	for (i = 0; i < ncpus; i++) {
		snprintf(path, BUFSIZ,
			 PATH_SYS_SYSTEM "/node/node%ld/cpu%d", nd, i);
		if (path_exist(path)) {
			snprintf(path1, BUFSIZ, "%s/online", path);
			/*
			 * if there is no online knob, then the cpu cannot
			 * be taken offline
			 */
			if (path_exist(path1)) {
				SAFE_FILE_SCANF(cleanup, path1, "%ld", &online);
				if (online == 0)
					continue;
			}
			sprintf(buf, "%d,", i);
			strcat(cpus, buf);
		}
	}
	/* Remove the trailing comma. */
	cpus[strlen(cpus) - 1] = '\0';
}
示例#2
0
static int cpu_enable(cpu_set_t *cpu_set, size_t setsize, int enable)
{
	unsigned int cpu;
	int online, rc;
	int configured = -1;

	for (cpu = 0; cpu < setsize; cpu++) {
		if (!CPU_ISSET(cpu, cpu_set))
			continue;
		if (!path_exist(_PATH_SYS_CPU "/cpu%d", cpu)) {
			printf(_("CPU %d does not exist\n"), cpu);
			continue;
		}
		if (!path_exist(_PATH_SYS_CPU "/cpu%d/online", cpu)) {
			printf(_("CPU %d is not hot pluggable\n"), cpu);
			continue;
		}
		online = path_getnum(_PATH_SYS_CPU "/cpu%d/online", cpu);
		if ((online == 1) && (enable == 1)) {
			printf(_("CPU %d is already enabled\n"), cpu);
			continue;
		}
		if ((online == 0) && (enable == 0)) {
			printf(_("CPU %d is already disabled\n"), cpu);
			continue;
		}
		if (path_exist(_PATH_SYS_CPU "/cpu%d/configure", cpu))
			configured = path_getnum(_PATH_SYS_CPU "/cpu%d/configure", cpu);
		if (enable) {
			rc = path_writestr("1", _PATH_SYS_CPU "/cpu%d/online", cpu);
			if ((rc == -1) && (configured == 0))
				printf(_("CPU %d enable failed "
					 "(CPU is deconfigured)\n"), cpu);
			else if (rc == -1)
				printf(_("CPU %d enable failed (%m)\n"), cpu);
			else
				printf(_("CPU %d enabled\n"), cpu);
		} else {
			if (onlinecpus && num_online_cpus() == 1) {
				printf(_("CPU %d disable failed "
					 "(last enabled CPU)\n"), cpu);
				continue;
			}
			rc = path_writestr("0", _PATH_SYS_CPU "/cpu%d/online", cpu);
			if (rc == -1)
				printf(_("CPU %d disable failed (%m)\n"), cpu);
			else {
				printf(_("CPU %d disabled\n"), cpu);
				if (onlinecpus)
					CPU_CLR(cpu, onlinecpus);
			}
		}
	}
	return EXIT_SUCCESS;
}
示例#3
0
int ipc_sem_get_limits(struct ipc_limits *lim)
{
	FILE *f;
	int rc = 0;

	lim->semvmx = SEMVMX;

	f = path_fopen("r", 0, _PATH_PROC_IPC_SEM);
	if (f) {
		rc = fscanf(f, "%d\t%d\t%d\t%d",
		       &lim->semmsl, &lim->semmns, &lim->semopm, &lim->semmni);
		fclose(f);

	}

	if (rc == 4) {
		struct seminfo seminfo;
		union semun arg = { .array = (ushort *) &seminfo };

		if (semctl(0, 0, IPC_INFO, arg) < 0)
			return 1;
		lim->semmni = seminfo.semmni;
		lim->semmsl = seminfo.semmsl;
		lim->semmns = seminfo.semmns;
		lim->semopm = seminfo.semopm;
	}

	return 0;
}

int ipc_shm_get_limits(struct ipc_limits *lim)
{
	lim->shmmin = SHMMIN;

	if (path_exist(_PATH_PROC_IPC_SHMALL) &&
	    path_exist(_PATH_PROC_IPC_SHMMAX) &&
	    path_exist(_PATH_PROC_IPC_SHMMNI)) {

		lim->shmall = path_read_u64(_PATH_PROC_IPC_SHMALL);
		lim->shmmax = path_read_u64(_PATH_PROC_IPC_SHMMAX);
		lim->shmmni = path_read_u64(_PATH_PROC_IPC_SHMMNI);

	} else {
		struct shminfo shminfo;

		if (shmctl(0, IPC_INFO, (struct shmid_ds *) &shminfo) < 0)
			return 1;
		lim->shmmni = shminfo.shmmni;
		lim->shmall = shminfo.shmall;
	}

	return 0;
}
示例#4
0
文件: chcpu.c 项目: sebras/util-linux
/* returns:   0 = success
 *          < 0 = failure
 *          > 0 = partial success
 */
static int cpu_configure(cpu_set_t *cpu_set, size_t setsize, int configure)
{
	unsigned int cpu;
	int rc, current;
	size_t fails = 0;

	for (cpu = 0; cpu < setsize; cpu++) {
		if (!CPU_ISSET(cpu, cpu_set))
			continue;
		if (!path_exist(_PATH_SYS_CPU "/cpu%d", cpu)) {
			warnx(_("CPU %u does not exist"), cpu);
			fails++;
			continue;
		}
		if (!path_exist(_PATH_SYS_CPU "/cpu%d/configure", cpu)) {
			warnx(_("CPU %u is not configurable"), cpu);
			fails++;
			continue;
		}
		current = path_read_s32(_PATH_SYS_CPU "/cpu%d/configure", cpu);
		if ((current == 1) && (configure == 1)) {
			printf(_("CPU %u is already configured\n"), cpu);
			continue;
		}
		if ((current == 0) && (configure == 0)) {
			printf(_("CPU %u is already deconfigured\n"), cpu);
			continue;
		}
		if ((current == 1) && (configure == 0) && onlinecpus &&
		    is_cpu_online(cpu)) {
			warnx(_("CPU %u deconfigure failed (CPU is enabled)"), cpu);
			fails++;
			continue;
		}
		if (configure) {
			rc = path_write_str("1", _PATH_SYS_CPU "/cpu%d/configure", cpu);
			if (rc == -1) {
				warn(_("CPU %u configure failed"), cpu);
				fails++;
			} else
				printf(_("CPU %u configured\n"), cpu);
		} else {
			rc = path_write_str("0", _PATH_SYS_CPU "/cpu%d/configure", cpu);
			if (rc == -1) {
				warn(_("CPU %u deconfigure failed"), cpu);
				fails++;
			} else
				printf(_("CPU %u deconfigured\n"), cpu);
		}
	}

	return fails == 0 ? 0 : fails == setsize ? -1 : 1;
}
示例#5
0
static int cpu_configure(cpu_set_t *cpu_set, size_t setsize, int configure)
{
	unsigned int cpu;
	int rc, current;

	for (cpu = 0; cpu < setsize; cpu++) {
		if (!CPU_ISSET(cpu, cpu_set))
			continue;
		if (!path_exist(_PATH_SYS_CPU "/cpu%d", cpu)) {
			printf(_("CPU %d does not exist\n"), cpu);
			continue;
		}
		if (!path_exist(_PATH_SYS_CPU "/cpu%d/configure", cpu)) {
			printf(_("CPU %d is not configurable\n"), cpu);
			continue;
		}
		current = path_getnum(_PATH_SYS_CPU "/cpu%d/configure", cpu);
		if ((current == 1) && (configure == 1)) {
			printf(_("CPU %d is already configured\n"), cpu);
			continue;
		}
		if ((current == 0) && (configure == 0)) {
			printf(_("CPU %d is already deconfigured\n"), cpu);
			continue;
		}
		if ((current == 1) && (configure == 0) && onlinecpus &&
		    is_cpu_online(cpu)) {
			printf(_("CPU %d deconfigure failed "
				 "(CPU is enabled)\n"), cpu);
			continue;
		}
		if (configure) {
			rc = path_writestr("1", _PATH_SYS_CPU "/cpu%d/configure", cpu);
			if (rc == -1)
				printf(_("CPU %d configure failed (%m)\n"), cpu);
			else
				printf(_("CPU %d configured\n"), cpu);
		} else {
			rc = path_writestr("0", _PATH_SYS_CPU "/cpu%d/configure", cpu);
			if (rc == -1)
				printf(_("CPU %d deconfigure failed (%m)\n"), cpu);
			else
				printf(_("CPU %d deconfigured\n"), cpu);
		}
	}
	return EXIT_SUCCESS;
}
示例#6
0
文件: mem.c 项目: Nan619/ltp-ddt
static void _gather_cpus(char *cpus, long nd)
{
	int ncpus = 0;
	int i;
	char buf[BUFSIZ];

	while (path_exist(PATH_SYS_SYSTEM "/cpu/cpu%d", ncpus))
		ncpus++;

	for (i = 0; i < ncpus; i++)
		if (path_exist(PATH_SYS_SYSTEM "/node/node%ld/cpu%d", nd, i)) {
			sprintf(buf, "%d,", i);
			strcat(cpus, buf);
		}
	/* Remove the trailing comma. */
	cpus[strlen(cpus) - 1] = '\0';
}
int path_exists(int *maze, int M, int N, int x1, int y1, int x2, int y2)
{

	if (x1 >= M || x1 < 0 || x2 >= M || x2 < 0 || y1 >= N || y1 < 0 || y2 >= N || y2 < 0)
		return 0;
	if (maze[x2*N + y2] == 0 || maze[x1*N + y1] == 0)
		return 0;
	return path_exist(maze, M, N, x1, y1, x2, y2);
}
示例#8
0
static int cpu_rescan(void)
{
	if (!path_exist(_PATH_SYS_CPU_RESCAN))
		errx(EXIT_FAILURE, _("This system does not support rescanning of CPUs"));
	if (path_writestr("1", _PATH_SYS_CPU_RESCAN) == -1)
		err(EXIT_FAILURE, _("Failed to trigger rescan of CPUs"));
	printf(_("Triggered rescan of CPUs\n"));
	return EXIT_SUCCESS;
}
示例#9
0
static long count_cpu(void)
{
	int ncpus = 0;

	while (path_exist(PATH_SYS_SYSTEM "/cpu/cpu%d", ncpus))
		ncpus++;

	return ncpus;
}
示例#10
0
文件: mem.c 项目: sconklin/ltp-tools
long count_numa(void)
{
	int nnodes = 0;

	while(path_exist(PATH_SYS_SYSTEM "/node/node%d", nnodes))
		nnodes++;

	return nnodes;
}
示例#11
0
int ipc_msg_get_limits(struct ipc_limits *lim)
{
	if (path_exist(_PATH_PROC_IPC_MSGMNI) &&
	    path_exist(_PATH_PROC_IPC_MSGMNB) &&
	    path_exist(_PATH_PROC_IPC_MSGMAX)) {

		lim->msgmni = path_read_s32(_PATH_PROC_IPC_MSGMNI);
		lim->msgmnb = path_read_s32(_PATH_PROC_IPC_MSGMNB);
		lim->msgmax = path_read_s32(_PATH_PROC_IPC_MSGMAX);
	} else {
		struct msginfo msginfo;

		if (msgctl(0, IPC_INFO, (struct msqid_ds *) &msginfo) < 0)
			return 1;
		lim->msgmni = msginfo.msgmni;
		lim->msgmnb = msginfo.msgmnb;
		lim->msgmax = msginfo.msgmax;
	}

	return 0;
}
/*
Find if there is a connecting path between two given points in the maze.
The maze is a matrix of order MxN, check if there exists a path between (x1,y1) and (x2,y2).
Two points are said to connected if there is a series of 1's non-diagonally.
Example:
Maze of order 4x4:

1	0	1	0
1	1	0	0
0	1	0	1
0	1	1	1

(x1,y1):(0,0)
(x2,y2):(2,3)

In this case, there exists a connected path:
1
1	1
	1		1
	1	1	1

Since there is a connected path, your function has to return 1.
If a path doesn't exist between two co-ordinates then return 0.
If the co-ordinates are invalid or size of the matrix is invalid then return 0.

Function Prototype :path_exists(int *maze, int rows, int columns, int x1, int y1, int x2, int y2) ;
Maze: Pointer to first element of an array .
rows : No of rows
columns : Columns
x1,x2,y1,y2: Co-ordinates

Hint : You can use path_exists as a wrapper function for your original recursive function which might take
more parameters .
*/
int path_exist(int *maze, int M, int N, int x1, int y1, int x2, int y2)
{
	int x, y, a = 0, b = 0, t, c = 0, d = 0;
	if (x1 == x2 && y1 == y2)
		return 1;
	t = maze[x1*N + y1];
	maze[x1*N + y1] = -1;
	if (x1 - 1 >= 0)
	if (maze[(x1 - 1)*N + y1] == 1)
		a = path_exist(maze, M, N, x1 - 1, y1, x2, y2);
	if (x1 + 1 < M)
	if (maze[(x1 + 1)*N + y1] == 1)
		b = path_exist(maze, M, N, x1 + 1, y1, x2, y2);
	if (y1 - 1 >= 0)
	if (maze[(x1)*N + y1 - 1] == 1)
		c = path_exist(maze, M, N, x1, y1 - 1, x2, y2);
	if (y1 + 1<N)
	if (maze[(x1)*N + y1 + 1] == 1)
		d = path_exist(maze, M, N, x1, y1 + 1, x2, y2);
	maze[x1*N + y1] = t;
	if (a == 1 || b == 1 || c == 1 || d == 1)
		return 1;
	return 0;
}
示例#13
0
//-------------------------------------------------------------------
// FileName::recursive_chmod_dir
//-------------------------------------------------------------------
void FileName::recursive_chmod_dir(mode_t mode) throw( Exception )
{
  if( !path_exist() )
  { // File doesn't exists
    String strErr = String::str_format(ERR_DIR_NOT_FOUND, PSZ(full_name()));
    throw FileNotFoundException(PSZ(strErr), "FileName::recursive_chmod_dir");
  }

  // Recursively change rights on sub-directories
  FileEnum dirEnum(full_name(), FileEnum::ENUM_DIR);
  while( dirEnum.find() )
    dirEnum.recursive_chmod_dir(mode);

  // Change mode to directory itself
  chmod(mode);
}
示例#14
0
static int cpu_set_dispatch(int mode)
{
	if (!path_exist(_PATH_SYS_CPU_DISPATCH))
		errx(EXIT_FAILURE, _("This system does not support setting "
				     "the dispatching mode of CPUs"));
	if (mode == 0) {
		if (path_writestr("0", _PATH_SYS_CPU_DISPATCH) == -1)
			err(EXIT_FAILURE, _("Failed to set horizontal dispatch mode"));
		printf(_("Successfully set horizontal dispatching mode\n"));
	} else {
		if (path_writestr("1", _PATH_SYS_CPU_DISPATCH) == -1)
			err(EXIT_FAILURE, _("Failed to set vertical dispatch mode"));
		printf(_("Successfully set vertical dispatching mode\n"));
	}
	return EXIT_SUCCESS;
}
示例#15
0
//-------------------------------------------------------------------
// FileName::recursive_chown
//-------------------------------------------------------------------
void FileName::recursive_chown(uid_t uid, gid_t gid) throw( Exception )
{
  if( !path_exist() )
  { // File doesn't exists
    String strErr = String::str_format(ERR_DIR_NOT_FOUND, PSZ(full_name()));
    throw FileNotFoundException(PSZ(strErr), "FileName::recursive_chmod");
  }

  // Recursively change rights on sub-directories
  FileEnum dirEnum(full_name(), FileEnum::ENUM_DIR);
  while( dirEnum.find() )
    dirEnum.recursive_chmod(uid, gid);

  // Change mode on files
  FileEnum fileEnum(full_name(), FileEnum::ENUM_FILE);
  while( fileEnum.find() )
    // Copy with metadata
    fileEnum.chown(uid, gid);

  // Change mode to directory itself
  chown(uid, gid);
}
示例#16
0
/* CORPO DELLE FUNZIONI */
int main(int argc, char *argv[])
{
	stack_t *input;
	item_t *comand;
	user_t *user = NULL;


	/* se non esiste la cartella base, la creiamo */
	if(path_exist(BASE) < 0){
		if(create_directory(BASE, 0777) < 0){
			perror("create_directory");
			exit(EXIT_FAILURE);
		}
	}
	/* leggiamo l'input da linea comando */
	input = read_input(argv, argc);
	if(input == NULL){
		perror("read_input");
		exit(EXIT_FAILURE);
	}
	/* ordiniamo le richieste */
	stack_sort(input);
	/* eseguimo tutte le richieste */
	while(input ->len > 0){
		/* estraiamo l'azione corrente */
		comand = stack_pop(input);
		if(comand == NULL){
			perror("stack_pop");
			exit(EXIT_FAILURE);
		}
		/* eseguiamo il comando */
		if(execute_comand(comand ->value, comand ->arg, &user) < 0){
			perror("execute_program");
			exit(EXIT_FAILURE);
		}
	}
	/* usciamo dal programma */
	exit(EXIT_SUCCESS);
}
示例#17
0
int
_linux_get_cpu_info( PAPI_hw_info_t * hwinfo )
{
  int tmp, retval = PAPI_OK;
	char maxargs[PAPI_HUGE_STR_LEN], *t, *s;
	float mhz = 0.0;
	FILE *f;

	if ( ( f = fopen( "/proc/cpuinfo", "r" ) ) == NULL ) {
		PAPIERROR( "fopen(/proc/cpuinfo) errno %d", errno );
		return PAPI_ESYS;
	}

	/* All of this information maybe overwritten by the substrate */

	/* MHZ */
	rewind( f );
	s = search_cpu_info( f, "clock", maxargs );
	if ( !s ) {
		rewind( f );
		s = search_cpu_info( f, "cpu MHz", maxargs );
	}
	if ( s )
		sscanf( s + 1, "%f", &mhz );
	hwinfo->mhz = mhz;
	hwinfo->clock_mhz = ( int ) mhz;

	/* Vendor Name and Vendor Code */
	rewind( f );
	s = search_cpu_info( f, "vendor_id", maxargs );
	if ( s && ( t = strchr( s + 2, '\n' ) ) ) {
		*t = '\0';
		strcpy( hwinfo->vendor_string, s + 2 );
	} else {
		rewind( f );
		s = search_cpu_info( f, "vendor", maxargs );
		if ( s && ( t = strchr( s + 2, '\n' ) ) ) {
			*t = '\0';
			strcpy( hwinfo->vendor_string, s + 2 );
		} else {
			rewind( f );
			s = search_cpu_info( f, "system type", maxargs );
			if ( s && ( t = strchr( s + 2, '\n' ) ) ) {
				*t = '\0';
				s = strtok( s + 2, " " );
				strcpy( hwinfo->vendor_string, s );
			} else {
				rewind( f );
				s = search_cpu_info( f, "platform", maxargs );
				if ( s && ( t = strchr( s + 2, '\n' ) ) ) {
					*t = '\0';
					s = strtok( s + 2, " " );
					if ( ( strcasecmp( s, "pSeries" ) == 0 ) ||
						 ( strcasecmp( s, "PowerMac" ) == 0 ) ) {
						strcpy( hwinfo->vendor_string, "IBM" );
					}
				 } else {
			            rewind( f );
			            s = search_cpu_info( f, "CPU implementer",
							 maxargs );
			            if ( s ) {
				       strcpy( hwinfo->vendor_string, "ARM" );
				    }
				}

				
			}
		}
	}
	if ( strlen( hwinfo->vendor_string ) )
		decode_vendor_string( hwinfo->vendor_string, &hwinfo->vendor );

	/* Revision */
	rewind( f );
	s = search_cpu_info( f, "stepping", maxargs );
	if ( s ) {
		sscanf( s + 1, "%d", &tmp );
		hwinfo->revision = ( float ) tmp;
		hwinfo->cpuid_stepping = tmp;
	} else {
		rewind( f );
		s = search_cpu_info( f, "revision", maxargs );
		if ( s ) {
			sscanf( s + 1, "%d", &tmp );
			hwinfo->revision = ( float ) tmp;
			hwinfo->cpuid_stepping = tmp;
		}
	}

	/* Model Name */
	rewind( f );
	s = search_cpu_info( f, "model name", maxargs );
	if ( s && ( t = strchr( s + 2, '\n' ) ) ) {
		*t = '\0';
		strcpy( hwinfo->model_string, s + 2 );
	} else {
		rewind( f );
		s = search_cpu_info( f, "family", maxargs );
		if ( s && ( t = strchr( s + 2, '\n' ) ) ) {
			*t = '\0';
			strcpy( hwinfo->model_string, s + 2 );
		} else {
			rewind( f );
			s = search_cpu_info( f, "cpu model", maxargs );
			if ( s && ( t = strchr( s + 2, '\n' ) ) ) {
				*t = '\0';
				strtok( s + 2, " " );
				s = strtok( NULL, " " );
				strcpy( hwinfo->model_string, s );
			} else {
				rewind( f );
				s = search_cpu_info( f, "cpu", maxargs );
				if ( s && ( t = strchr( s + 2, '\n' ) ) ) {
					*t = '\0';
					/* get just the first token */
					s = strtok( s + 2, " " );
					strcpy( hwinfo->model_string, s );
				}
			}
		}
	}

	/* Family */
	rewind( f );
	s = search_cpu_info( f, "family", maxargs );
	if ( s ) {
		sscanf( s + 1, "%d", &tmp );
		hwinfo->cpuid_family = tmp;
	} else {
		rewind( f );
		s = search_cpu_info( f, "cpu family", maxargs );
		if ( s ) {
			sscanf( s + 1, "%d", &tmp );
			hwinfo->cpuid_family = tmp;
		}
	}

	/* CPU Model */
	rewind( f );
	s = search_cpu_info( f, "model", maxargs );
	if ( s ) {
		sscanf( s + 1, "%d", &tmp );
		hwinfo->model = tmp;
		hwinfo->cpuid_model = tmp;
	}

	fclose( f );
	/* The following new members are set using the same methodology used in lscpu. */

	/* Total number of CPUs */
	/* The following line assumes totalcpus was initialized to zero! */
	while ( path_exist( _PATH_SYS_SYSTEM "/cpu/cpu%d", hwinfo->totalcpus ) )
		hwinfo->totalcpus++;

	/* Number of threads per core */
	if ( path_exist( _PATH_SYS_CPU0 "/topology/thread_siblings" ) )
		hwinfo->threads =
			path_sibling( _PATH_SYS_CPU0 "/topology/thread_siblings" );

	/* Number of cores per socket */
	if ( path_exist( _PATH_SYS_CPU0 "/topology/core_siblings" ) &&
		 hwinfo->threads > 0 )
		hwinfo->cores =
			path_sibling( _PATH_SYS_CPU0 "/topology/core_siblings" ) /
			hwinfo->threads;

	/* Number of sockets */
	if ( hwinfo->threads > 0 && hwinfo->cores > 0 )
		hwinfo->sockets = hwinfo->ncpu / hwinfo->cores / hwinfo->threads;

	/* Number of NUMA nodes */
	/* The following line assumes nnodes was initialized to zero! */
	while ( path_exist( _PATH_SYS_SYSTEM "/node/node%d", hwinfo->nnodes ) )
		hwinfo->nnodes++;

	/* Number of CPUs per node */
	hwinfo->ncpu =
		hwinfo->nnodes >
		1 ? hwinfo->totalcpus / hwinfo->nnodes : hwinfo->totalcpus;
#if 0
	int *nodecpu;
	/* cpumap data is not currently part of the _papi_hw_info struct */
        nodecpu = malloc( (unsigned int) hwinfo->nnodes * sizeof(int) );
	if ( nodecpu ) {
	   int i;
	   for ( i = 0; i < hwinfo->nnodes; ++i ) {
	       nodecpu[i] = path_sibling( 
                             _PATH_SYS_SYSTEM "/node/node%d/cpumap", i );
	   }
	} else {
		PAPIERROR( "malloc failed for variable not currently used" );
	}
#endif

	return retval;
}
示例#18
0
文件: chcpu.c 项目: sebras/util-linux
int main(int argc, char *argv[])
{
	cpu_set_t *cpu_set;
	size_t setsize;
	int cmd = -1;
	int c, rc;

	static const struct option longopts[] = {
		{ "configure",	required_argument, NULL, 'c' },
		{ "deconfigure",required_argument, NULL, 'g' },
		{ "disable",	required_argument, NULL, 'd' },
		{ "dispatch",	required_argument, NULL, 'p' },
		{ "enable",	required_argument, NULL, 'e' },
		{ "help",	no_argument,       NULL, 'h' },
		{ "rescan",	no_argument,       NULL, 'r' },
		{ "version",	no_argument,       NULL, 'V' },
		{ NULL,		0, NULL, 0 }
	};

	static const ul_excl_t excl[] = {       /* rows and cols in ASCII order */
		{ 'c','d','e','g','p' },
		{ 0 }
	};
	int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;

	setlocale(LC_ALL, "");
	bindtextdomain(PACKAGE, LOCALEDIR);
	textdomain(PACKAGE);
	atexit(close_stdout);

	maxcpus = get_max_number_of_cpus();
	if (maxcpus < 1)
		errx(EXIT_FAILURE, _("cannot determine NR_CPUS; aborting"));
	if (path_exist(_PATH_SYS_CPU_ONLINE))
		onlinecpus = path_read_cpulist(maxcpus, _PATH_SYS_CPU_ONLINE);
	setsize = CPU_ALLOC_SIZE(maxcpus);
	cpu_set = CPU_ALLOC(maxcpus);
	if (!cpu_set)
		err(EXIT_FAILURE, _("cpuset_alloc failed"));

	while ((c = getopt_long(argc, argv, "c:d:e:g:hp:rV", longopts, NULL)) != -1) {

		err_exclusive_options(c, longopts, excl, excl_st);

		switch (c) {
		case 'c':
			cmd = CMD_CPU_CONFIGURE;
			cpu_parse(argv[optind - 1], cpu_set, setsize);
			break;
		case 'd':
			cmd = CMD_CPU_DISABLE;
			cpu_parse(argv[optind - 1], cpu_set, setsize);
			break;
		case 'e':
			cmd = CMD_CPU_ENABLE;
			cpu_parse(argv[optind - 1], cpu_set, setsize);
			break;
		case 'g':
			cmd = CMD_CPU_DECONFIGURE;
			cpu_parse(argv[optind - 1], cpu_set, setsize);
			break;
		case 'h':
			usage(stdout);
		case 'p':
			if (strcmp("horizontal", argv[optind - 1]) == 0)
				cmd = CMD_CPU_DISPATCH_HORIZONTAL;
			else if (strcmp("vertical", argv[optind - 1]) == 0)
				cmd = CMD_CPU_DISPATCH_VERTICAL;
			else
				errx(EXIT_FAILURE, _("unsupported argument: %s"),
				     argv[optind -1 ]);
			break;
		case 'r':
			cmd = CMD_CPU_RESCAN;
			break;
		case 'V':
			printf(UTIL_LINUX_VERSION);
			return EXIT_SUCCESS;
		default:
			errtryhelp(EXIT_FAILURE);
		}
	}

	if ((argc == 1) || (argc != optind))
		usage(stderr);

	switch (cmd) {
	case CMD_CPU_ENABLE:
		rc = cpu_enable(cpu_set, maxcpus, 1);
		break;
	case CMD_CPU_DISABLE:
		rc = cpu_enable(cpu_set, maxcpus, 0);
		break;
	case CMD_CPU_CONFIGURE:
		rc = cpu_configure(cpu_set, maxcpus, 1);
		break;
	case CMD_CPU_DECONFIGURE:
		rc = cpu_configure(cpu_set, maxcpus, 0);
		break;
	case CMD_CPU_RESCAN:
		rc = cpu_rescan();
		break;
	case CMD_CPU_DISPATCH_HORIZONTAL:
		rc = cpu_set_dispatch(0);
		break;
	case CMD_CPU_DISPATCH_VERTICAL:
		rc = cpu_set_dispatch(1);
		break;
	default:
		rc = -EINVAL;
		break;
	}

	return rc == 0 ? EXIT_SUCCESS :
	        rc < 0 ? EXIT_FAILURE : CHCPU_EXIT_SOMEOK;
}
示例#19
0
文件: chcpu.c 项目: sebras/util-linux
/* returns:   0 = success
 *          < 0 = failure
 *          > 0 = partial success
 */
static int cpu_enable(cpu_set_t *cpu_set, size_t setsize, int enable)
{
	unsigned int cpu;
	int online, rc;
	int configured = -1;
	size_t fails = 0;

	for (cpu = 0; cpu < setsize; cpu++) {
		if (!CPU_ISSET(cpu, cpu_set))
			continue;
		if (!path_exist(_PATH_SYS_CPU "/cpu%d", cpu)) {
			warnx(_("CPU %u does not exist"), cpu);
			fails++;
			continue;
		}
		if (!path_exist(_PATH_SYS_CPU "/cpu%d/online", cpu)) {
			warnx(_("CPU %u is not hot pluggable"), cpu);
			fails++;
			continue;
		}
		online = path_read_s32(_PATH_SYS_CPU "/cpu%d/online", cpu);
		if ((online == 1) && (enable == 1)) {
			printf(_("CPU %u is already enabled\n"), cpu);
			continue;
		}
		if ((online == 0) && (enable == 0)) {
			printf(_("CPU %u is already disabled\n"), cpu);
			continue;
		}
		if (path_exist(_PATH_SYS_CPU "/cpu%d/configure", cpu))
			configured = path_read_s32(_PATH_SYS_CPU "/cpu%d/configure", cpu);
		if (enable) {
			rc = path_write_str("1", _PATH_SYS_CPU "/cpu%d/online", cpu);
			if ((rc == -1) && (configured == 0)) {
				warn(_("CPU %u enable failed (CPU is deconfigured)"), cpu);
				fails++;
			} else if (rc == -1) {
				warn(_("CPU %u enable failed"), cpu);
				fails++;
			} else
				printf(_("CPU %u enabled\n"), cpu);
		} else {
			if (onlinecpus && num_online_cpus() == 1) {
				warnx(_("CPU %u disable failed (last enabled CPU)"), cpu);
				fails++;
				continue;
			}
			rc = path_write_str("0", _PATH_SYS_CPU "/cpu%d/online", cpu);
			if (rc == -1) {
				warn(_("CPU %u disable failed"), cpu);
				fails++;
			} else {
				printf(_("CPU %u disabled\n"), cpu);
				if (onlinecpus)
					CPU_CLR(cpu, onlinecpus);
			}
		}
	}

	return fails == 0 ? 0 : fails == setsize ? -1 : 1;
}
示例#20
0
int
_linux_get_cpu_info( PAPI_hw_info_t *hwinfo, int *cpuinfo_mhz )
{
	int retval = PAPI_OK;
	unsigned int strSize;
	char maxargs[PAPI_HUGE_STR_LEN], *t, *s;
	float mhz = 0.0;
	FILE *f;
	char cpuinfo_filename[]="/proc/cpuinfo";

	if ( ( f = fopen( cpuinfo_filename, "r" ) ) == NULL ) {
		PAPIERROR( "fopen(/proc/cpuinfo) errno %d", errno );
		return PAPI_ESYS;
	}

	/* All of this information may be overwritten by the component */

	/***********************/
	/* Attempt to find MHz */
	/***********************/
	rewind( f );
	s = search_cpu_info( f, "clock", maxargs );
	if ( !s ) {
		rewind( f );
		s = search_cpu_info( f, "cpu MHz", maxargs );
	}
	if ( s ) {
		sscanf( s + 1, "%f", &mhz );
	}
	*cpuinfo_mhz = mhz;

	/*******************************/
	/* Vendor Name and Vendor Code */
	/*******************************/

	/* First try to read "vendor_id" field */
	/* Which is the most common field      */
	hwinfo->vendor_string[0]=0;
	rewind( f );
	s = search_cpu_info( f, "vendor_id", maxargs );
	strSize = sizeof(hwinfo->vendor_string);
	if ( s && ( t = strchr( s + 2, '\n' ) ) ) {
		*t = '\0';
		if (strlen(s+2) >= strSize-1) {
			s[strSize+1] = '\0';
		}
		strcpy( hwinfo->vendor_string, s + 2 );
	}

	/* If not found, try "vendor" which seems to be Itanium specific */
	if (!hwinfo->vendor_string[0]) {
		rewind( f );
		s = search_cpu_info( f, "vendor", maxargs );
		if ( s && ( t = strchr( s + 2, '\n' ) ) ) {
			*t = '\0';
			if (strlen(s+2) >= strSize-1) {
				s[strSize+1] = '\0';
			}
			strcpy( hwinfo->vendor_string, s + 2 );
		}
	}

	/* "system type" seems to be MIPS and Alpha */
	if (!hwinfo->vendor_string[0]) {
		rewind( f );
		s = search_cpu_info( f, "system type", maxargs );
		if ( s && ( t = strchr( s + 2, '\n' ) ) ) {
			*t = '\0';
			s = strtok( s + 2, " " );
			if (strlen(s) >= strSize-1) {
				s[strSize-1] = '\0';
			}
			strcpy( hwinfo->vendor_string, s );
		}
	}

	/* "platform" indicates Power */
	if (!hwinfo->vendor_string[0]) {

		rewind( f );
		s = search_cpu_info( f, "platform", maxargs );
		if ( s && ( t = strchr( s + 2, '\n' ) ) ) {
			*t = '\0';
			s = strtok( s + 2, " " );
			if ( ( strcasecmp( s, "pSeries" ) == 0 ) ||
				( strcasecmp( s, "PowerNV" ) == 0 ) ||
				( strcasecmp( s, "PowerMac" ) == 0 ) ) {
				strcpy( hwinfo->vendor_string, "IBM" );
			}
		}
	}

	/* "CPU implementer" indicates ARM */
	if (!hwinfo->vendor_string[0]) {

		rewind( f );
		s = search_cpu_info( f, "CPU implementer", maxargs );
		if ( s ) {
			strcpy( hwinfo->vendor_string, "ARM" );
		}
	}


	/* Decode the string to an implementer value */
	if ( strlen( hwinfo->vendor_string ) ) {
		decode_vendor_string( hwinfo->vendor_string, &hwinfo->vendor );
	}

	/**********************************************/
	/* Provide more stepping/model/family numbers */
	/**********************************************/

	if ((hwinfo->vendor==PAPI_VENDOR_INTEL) ||
		(hwinfo->vendor==PAPI_VENDOR_AMD)) {

		decode_cpuinfo_x86(f,hwinfo);
	}

	if (hwinfo->vendor==PAPI_VENDOR_IBM) {

		decode_cpuinfo_power(f,hwinfo);
	}

	if (hwinfo->vendor==PAPI_VENDOR_ARM) {

		decode_cpuinfo_arm(f,hwinfo);
	}




	/* The following members are set using the same methodology */
	/* used in lscpu.                                           */

	/* Total number of CPUs */
	/* The following line assumes totalcpus was initialized to zero! */
	while ( path_exist( _PATH_SYS_SYSTEM "/cpu/cpu%d", hwinfo->totalcpus ) )
		hwinfo->totalcpus++;

	/* Number of threads per core */
	if ( path_exist( _PATH_SYS_CPU0 "/topology/thread_siblings" ) )
		hwinfo->threads =
			path_sibling( _PATH_SYS_CPU0 "/topology/thread_siblings" );

	/* Number of cores per socket */
	if ( path_exist( _PATH_SYS_CPU0 "/topology/core_siblings" ) &&
		 hwinfo->threads > 0 )
		hwinfo->cores =
			path_sibling( _PATH_SYS_CPU0 "/topology/core_siblings" ) /
			hwinfo->threads;

	/* Number of NUMA nodes */
	/* The following line assumes nnodes was initialized to zero! */
	while ( path_exist( _PATH_SYS_SYSTEM "/node/node%d", hwinfo->nnodes ) )
		hwinfo->nnodes++;

	/* Number of CPUs per node */
	hwinfo->ncpu =
		hwinfo->nnodes >
		1 ? hwinfo->totalcpus / hwinfo->nnodes : hwinfo->totalcpus;

	/* Number of sockets */
	if ( hwinfo->threads > 0 && hwinfo->cores > 0 )
		hwinfo->sockets = hwinfo->totalcpus / hwinfo->cores / hwinfo->threads;

#if 0
	int *nodecpu;
	/* cpumap data is not currently part of the _papi_hw_info struct */
        nodecpu = malloc( (unsigned int) hwinfo->nnodes * sizeof(int) );
	if ( nodecpu ) {
	   int i;
	   for ( i = 0; i < hwinfo->nnodes; ++i ) {
	       nodecpu[i] = path_sibling( 
                             _PATH_SYS_SYSTEM "/node/node%d/cpumap", i );
	   }
	} else {
		PAPIERROR( "malloc failed for variable not currently used" );
	}
#endif


	/* Fixup missing Megahertz Value */
	/* This is missing from cpuinfo on ARM and MIPS */
     if (*cpuinfo_mhz < 1.0) {
	rewind( f );

	s = search_cpu_info( f, "BogoMIPS", maxargs );
	if ((!s) || (sscanf( s + 1, "%f", &mhz ) != 1)) {
	   INTDBG("Mhz detection failed. Please edit file %s at line %d.\n",
		     __FILE__,__LINE__);
	}

	if (hwinfo->vendor == PAPI_VENDOR_MIPS) {
	    /* MIPS has 2x clock multiplier */
	    *cpuinfo_mhz = 2*(((int)mhz)+1);

	    /* Also update version info on MIPS */
	    rewind( f );
	    s = search_cpu_info( f, "cpu model", maxargs );
	    s = strstr(s+1," V")+2;
	     strtok(s," ");
	    sscanf(s, "%f ", &hwinfo->revision );
	}
	else {
	    /* In general bogomips is proportional to number of CPUs */
	    if (hwinfo->totalcpus) {
	       if (mhz!=0) *cpuinfo_mhz = mhz / hwinfo->totalcpus;
	    }
	}
     }

    fclose( f );

    return retval;
}
示例#21
0
int main(int argc, char *argv[])
{
	cpu_set_t *cpu_set;
	size_t setsize;
	int cmd = -1;
	int c;

	enum {
		EXCL_NONE,
		EXCL_CONFIGURE,
		EXCL_DECONFIGURE,
		EXCL_DISABLE,
		EXCL_DISPATCH,
		EXCL_ENABLE
	};
	int excl_any = EXCL_NONE;

	static const struct option longopts[] = {
		{ "configure",	required_argument, 0, 'c' },
		{ "deconfigure",required_argument, 0, 'g' },
		{ "disable",	required_argument, 0, 'd' },
		{ "dispatch",	required_argument, 0, 'p' },
		{ "enable",	required_argument, 0, 'e' },
		{ "help",	no_argument,       0, 'h' },
		{ "rescan",	no_argument,       0, 'r' },
		{ "version",	no_argument,       0, 'V' },
		{ NULL,		0, 0, 0 }
	};

	setlocale(LC_ALL, "");
	bindtextdomain(PACKAGE, LOCALEDIR);
	textdomain(PACKAGE);
	atexit(close_stdout);

	maxcpus = get_max_number_of_cpus();
	if (maxcpus < 1)
		errx(EXIT_FAILURE, _("cannot determine NR_CPUS; aborting"));
	if (path_exist(_PATH_SYS_CPU_ONLINE))
		onlinecpus = path_cpulist(maxcpus, _PATH_SYS_CPU_ONLINE);
	setsize = CPU_ALLOC_SIZE(maxcpus);
	cpu_set = CPU_ALLOC(maxcpus);
	if (!cpu_set)
		err(EXIT_FAILURE, _("cpuset_alloc failed"));

	while ((c = getopt_long(argc, argv, "c:d:e:g:hp:rV", longopts, NULL)) != -1) {
		switch (c) {
		case 'c':
			exclusive_option(&excl_any, EXCL_CONFIGURE, EXCL_ERROR);
			cmd = CMD_CPU_CONFIGURE;
			cpu_parse(argv[optind - 1], cpu_set, setsize);
			break;
		case 'd':
			exclusive_option(&excl_any, EXCL_DISABLE, EXCL_ERROR);
			cmd = CMD_CPU_DISABLE;
			cpu_parse(argv[optind - 1], cpu_set, setsize);
			break;
		case 'e':
			exclusive_option(&excl_any, EXCL_ENABLE, EXCL_ERROR);
			cmd = CMD_CPU_ENABLE;
			cpu_parse(argv[optind - 1], cpu_set, setsize);
			break;
		case 'g':
			exclusive_option(&excl_any, EXCL_DECONFIGURE, EXCL_ERROR);
			cmd = CMD_CPU_DECONFIGURE;
			cpu_parse(argv[optind - 1], cpu_set, setsize);
			break;
		case 'h':
			usage(stdout);
		case 'p':
			exclusive_option(&excl_any, EXCL_DISPATCH, EXCL_ERROR);
			if (strcmp("horizontal", argv[optind - 1]) == 0)
				cmd = CMD_CPU_DISPATCH_HORIZONTAL;
			else if (strcmp("vertical", argv[optind - 1]) == 0)
				cmd = CMD_CPU_DISPATCH_VERTICAL;
			else
				errx(EXIT_FAILURE, _("unsupported argument: %s"),
				     argv[optind -1 ]);
			break;
		case 'r':
			cmd = CMD_CPU_RESCAN;
			break;
		case 'V':
			printf(_("%s from %s\n"), program_invocation_short_name,
			       PACKAGE_STRING);
			return EXIT_SUCCESS;
		default:
			usage(stderr);
		}
	}

	if ((argc == 1) || (argc != optind))
		usage(stderr);

	switch (cmd) {
	case CMD_CPU_ENABLE:
		return cpu_enable(cpu_set, maxcpus, 1);
	case CMD_CPU_DISABLE:
		return cpu_enable(cpu_set, maxcpus, 0);
	case CMD_CPU_CONFIGURE:
		return cpu_configure(cpu_set, maxcpus, 1);
	case CMD_CPU_DECONFIGURE:
		return cpu_configure(cpu_set, maxcpus, 0);
	case CMD_CPU_RESCAN:
		return cpu_rescan();
	case CMD_CPU_DISPATCH_HORIZONTAL:
		return cpu_set_dispatch(0);
	case CMD_CPU_DISPATCH_VERTICAL:
		return cpu_set_dispatch(1);
	}
	return EXIT_SUCCESS;
}