OpenSolaris_b135/cmd/dispadmin/dispadmin.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/* All Rights Reserved */
/*
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <limits.h>
#include <wait.h>
#include <zone.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/priocntl.h>
#include "dispadmin.h"
/*
* This file contains the code implementing the class independent part
* of the dispadmin command. Most of the functionality of the dispadmin
* command is provided by the class specific sub-commands, the code for
* which is elsewhere. The class independent part of the command is
* responsible for switching out to the appropriate class specific
* sub-command based on the user supplied class argument.
* Code in this file should never assume any knowledge of any specific
* scheduler class (other than the SYS class).
*/
#define BASENMSZ 16
#define BUFSZ (PATH_MAX + 80)
#define CLASSPATH "/usr/lib/class"
#define CONFIGPATH "/etc/dispadmin.conf"
#define CONFIGOWNER 0 /* uid 0 (root) */
#define CONFIGGROUP 1 /* gid 1 (other) */
#define CONFIGPERM (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH) /* 0644 */
#define TOKENNAME "DEFAULT_SCHEDULER"
extern char *basename();
static char usage[] =
"usage: dispadmin -l\n\
dispadmin -c class [class-specific options]\n\
dispadmin -d [class]\n";
static char basenm[BASENMSZ];
static char cmdpath[PATH_MAX];
static void print_classlist();
static void exec_cscmd(char *, char **);
static void set_scheduler(char *);
static void class_info(pcinfo_t *);
static void set_default_class();
int
main(int argc, char **argv)
{
extern char *optarg;
extern int optind, opterr;
int c;
int uflag, cflag, dflag, lflag, csoptsflag;
char *clname;
(void) strncpy(cmdpath, argv[0], PATH_MAX);
(void) strncpy(basenm, basename(argv[0]), BASENMSZ);
cflag = dflag = lflag = uflag = csoptsflag = 0;
opterr = 0;
while ((c = getopt(argc, argv, "c:dlu")) != -1) {
switch (c) {
case 'c':
cflag++;
clname = optarg;
break;
case 'd':
dflag++;
clname = argv[optind];
break;
case 'l':
lflag++;
break;
case 'u':
uflag++;
break;
case '?':
/*
* We assume for now that any option that
* getopt() doesn't recognize is intended for a
* class specific subcommand.
*/
csoptsflag++;
if (argv[optind] && argv[optind][0] != '-') {
/*
* Class specific option takes an
* argument which we skip over for now.
*/
optind++;
}
break;
default:
break;
}
}
if (lflag) {
if (uflag || cflag || dflag || csoptsflag)
fatalerr(usage);
print_classlist();
exit(0);
} else if (uflag) {
if (lflag || dflag || csoptsflag)
fatalerr(usage);
set_default_class();
} else if (cflag) {
if (lflag || dflag)
fatalerr(usage);
exec_cscmd(clname, argv);
} else if (dflag) {
if (cflag || lflag || csoptsflag)
fatalerr(usage);
set_scheduler(clname);
exit(0);
} else {
fatalerr(usage);
}
return (1);
}
/*
* Print the heading for the class list and execute the
* class specific sub-command with the -l option for each
* configured class.
*/
static void
print_classlist()
{
id_t cid;
int nclass;
pcinfo_t pcinfo;
if ((nclass = priocntl(0, 0, PC_GETCLINFO, NULL)) == -1)
fatalerr("%s: Can't get number of configured classes\n",
cmdpath);
(void) printf("CONFIGURED CLASSES\n==================\n\n");
(void) printf("SYS\t(System Class)\n");
(void) fflush(stdout);
for (cid = 1; cid < nclass; cid++) {
pcinfo.pc_cid = cid;
if (priocntl(0, 0, PC_GETCLINFO, (caddr_t)&pcinfo) == -1)
fatalerr("%s: Can't get class name (class ID = %d)\n",
cmdpath, cid);
class_info(&pcinfo);
}
}
/*
* Execute the appropriate class specific sub-command for the class
* specified by clname, passing it the arguments in subcmdargv.
*/
static void
exec_cscmd(char *clname, char **subcmdargv)
{
pcinfo_t pcinfo;
char subcmdpath[PATH_MAX];
/*
* Do a quick check to make sure clname is valid.
* We could just wait and see if the exec below
* succeeds but we wouldn't know much about the reason.
* This way we can give the user a more meaningful error
* message.
*/
(void) strncpy(pcinfo.pc_clname, clname, PC_CLNMSZ);
if (priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1)
fatalerr("%s: Invalid or unconfigured class %s\n", cmdpath,
clname);
(void) snprintf(subcmdpath, PATH_MAX, "%s/%s/%s%s", CLASSPATH,
clname, clname, basenm);
subcmdargv[0] = subcmdpath;
(void) execv(subcmdpath, subcmdargv);
fatalerr("%s: Can't execute %s sub-command\n", cmdpath, clname);
}
static void
class_info(pcinfo_t *pcinfo)
{
int pid;
char subcmdpath[PATH_MAX];
(void) snprintf(subcmdpath, PATH_MAX, "%s/%s/%s%s", CLASSPATH,
pcinfo->pc_clname, pcinfo->pc_clname, basenm);
if ((pid = fork()) == 0) {
(void) execl(subcmdpath, subcmdpath, "-l", (char *)0);
fatalerr("%s\n\tCan't execute %s specific subcommand\n",
pcinfo->pc_clname, pcinfo->pc_clname);
} else if (pid == (pid_t)-1) {
(void) fprintf(stderr,
"%s\nCan't execute %s specific subcommand)\n",
pcinfo->pc_clname, pcinfo->pc_clname);
} else {
(void) wait(NULL);
}
}
/*
* Return the current default scheduling class as specified in
* /etc/dispadmin.conf.
*/
static char *
read_default_file(FILE *fp)
{
char buf[BUFSZ];
int line;
for (line = 1; fgets(buf, BUFSZ, fp) != NULL; line++) {
char name[BUFSZ], value[BUFSZ];
int len;
if (buf[0] == '#' || buf[0] == '\n')
continue;
/* LINTED - unbounded string specifier */
if (sscanf(buf, " %[^=]=%s \n%n", name, value, &len) == 2 &&
name[0] != '\0' && value[0] != '\0' && len == strlen(buf)) {
if (strcmp(name, TOKENNAME) != 0)
fatalerr("\"%s\", line %d: invalid "
"token: %s\n", CONFIGPATH, line, name);
(void) fclose(fp);
return (strdup(value));
} else {
fatalerr("\"%s\", line %d: syntax error\n", CONFIGPATH,
line);
(void) fclose(fp);
}
}
if (line == 1)
fatalerr("%s: %s is empty\n", cmdpath, CONFIGPATH);
return (NULL);
}
/*
* Set the default scheduling class for the system.
* Update /etc/dispadmin.conf if necessary.
*/
static void
set_scheduler(char *clname)
{
pcinfo_t pcinfo;
FILE *fp;
int fd;
if (getzoneid() != GLOBAL_ZONEID)
fatalerr("%s: Operation not supported in non-global zones\n",
cmdpath);
if (clname == NULL) {
if ((fd = open(CONFIGPATH, O_RDONLY, CONFIGPERM)) == -1) {
if (errno == ENOENT)
fatalerr("%s: Default scheduling class "
"is not set\n", cmdpath);
else
fatalerr("%s: Failed to open %s (%s)\n",
cmdpath, CONFIGPATH, strerror(errno));
}
if ((fp = fdopen(fd, "r")) == NULL)
fatalerr("%s: Failed to open stream for %s (%s)\n",
cmdpath, CONFIGPATH, strerror(errno));
clname = read_default_file(fp);
(void) strncpy(pcinfo.pc_clname, clname, PC_CLNMSZ);
if (priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1)
fatalerr("\"%s\", scheduling class %s is not "
"available\n", CONFIGPATH, clname);
else
class_info(&pcinfo);
return;
}
/*
* Do a quick check to make sure clname is valid class name.
*/
(void) strncpy(pcinfo.pc_clname, clname, PC_CLNMSZ);
if (priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo) == -1)
fatalerr("%s: Invalid or unconfigured class %s\n", cmdpath,
clname);
if ((fd = open(CONFIGPATH, O_RDWR | O_CREAT, CONFIGPERM)) == -1)
fatalerr("%s: Failed to open %s (%s)\n", cmdpath, CONFIGPATH,
strerror(errno));
if ((fp = fdopen(fd, "w")) == NULL)
fatalerr("%s: Failed to open stream for %s\n", CONFIGPATH);
if (ftruncate(fd, (off_t)0) == -1)
fatalerr("%s: Failed to truncate %s\n", cmdpath, CONFIGPATH);
(void) fputs("#\n# /etc/dispadmin.conf\n#\n"
"# Do NOT edit this file by hand -- use dispadmin(1m) instead.\n"
"#\n", fp);
if ((fprintf(fp, "%s=%s\n", TOKENNAME, clname)) == -1)
fatalerr("%s: Failed to write to %s\n", cmdpath, CONFIGPATH);
if (fflush(fp) != 0)
(void) fprintf(stderr,
"%s: warning: failed to flush config file\n",
cmdpath);
if (fsync(fd) == -1)
(void) fprintf(stderr,
"%s: warning: failed to sync config file to disk\n",
cmdpath);
if (fchmod(fd, CONFIGPERM) == -1)
(void) fprintf(stderr,
"%s: warning: failed to reset config file mode\n",
cmdpath);
if (fchown(fd, CONFIGOWNER, CONFIGGROUP) == -1)
(void) fprintf(stderr,
"%s: warning: failed to reset config file owner\n",
cmdpath);
(void) fclose(fp);
if (priocntl(0, 0, PC_SETDFLCL, clname) == -1)
fatalerr("%s: failed to set default class %s in kernel: %s\n",
cmdpath, clname, strerror(errno));
}
static void
set_default_class()
{
char *clname;
FILE *fp;
int fd;
if ((fd = open(CONFIGPATH, O_RDONLY, CONFIGPERM)) == -1) {
/* silently succeed, there is nothing to do */
if (errno == ENOENT)
return;
else
fatalerr("%s: Failed to open %s (%s)\n",
cmdpath, CONFIGPATH, strerror(errno));
}
if ((fp = fdopen(fd, "r")) == NULL)
fatalerr("%s: Failed to open stream for %s (%s)\n",
cmdpath, CONFIGPATH, strerror(errno));
if ((clname = read_default_file(fp)) != NULL) {
if (priocntl(0, 0, PC_SETDFLCL, clname) == -1)
fatalerr("%s: failed to set default class %s in "
"kernel: %s\n", cmdpath, clname, strerror(errno));
}
}