/****** sgeobj/var/var_list_set_sharedlib_path() ******************************
* NAME
* var_list_set_sharedlib_path -- set shared lib path
*
* SYNOPSIS
* void var_list_set_sharedlib_path(lList **varl);
*
* FUNCTION
* Sets or replaces the shared lib path in the list of variables.
* The SGE shared lib path is always set to the beginning of the
* resulting shared lib path
* (security, see var_get_sharedlib_path_name())
*
* INPUTS
* lList **varl - list of nment variables
*
* SEE ALSO
* sgeobj/var/var_get_sharedlib_path_name()
* sgeobj/var/var_list_set_string()
* sgeobj/var/var_list_set_int()
* sgeobj/var/var_list_set_sge_u32()
******************************************************************************/
void var_list_set_sharedlib_path(lList **varl)
{
char *sharedlib_path;
char *sge_sharedlib_path;
const char *sge_root = sge_get_root_dir(0, NULL, 0, 1);
const char *sharedlib_path_name = var_get_sharedlib_path_name();
lListElem *sharedlib_elem = NULL;
DENTER(TOP_LAYER, "set_sharedlib_path");
/* this is the SGE sharedlib path */
sge_sharedlib_path = sge_malloc(strlen(sge_root) +
strlen("/lib/") + strlen(sge_get_arch()) + 1);
sprintf(sge_sharedlib_path, "%s/lib/%s", sge_root, sge_get_arch());
/* if already in environment: extend by SGE sharedlib path, else set */
sharedlib_elem = lGetElemStr(*varl, VA_variable, sharedlib_path_name);
if(sharedlib_elem != NULL) {
const char *old_value = lGetString(sharedlib_elem, VA_value);
if(old_value && strlen(old_value) > 0) {
DPRINTF(("sharedlib path %s already set:\n", sharedlib_path_name));
sharedlib_path = sge_malloc(strlen(old_value) + 1 +
strlen(sge_sharedlib_path) + 1);
strcpy(sharedlib_path, sge_sharedlib_path);
strcat(sharedlib_path, ":");
strcat(sharedlib_path, old_value);
lSetString(sharedlib_elem, VA_value, sharedlib_path);
sge_free(&sharedlib_path);
} else {
DPRINTF(("overwriting empty sharedlib path %s\n",
sharedlib_path_name));
lSetString(sharedlib_elem, VA_value, sge_sharedlib_path);
}
} else {
DPRINTF(("creating new sharedlib path %s\n", sharedlib_path_name));
sharedlib_elem = lAddElemStr(varl, VA_variable,
sharedlib_path_name, VA_Type);
lSetString(sharedlib_elem, VA_value, sge_sharedlib_path);
}
sge_free(&sge_sharedlib_path);
DEXIT;
}
/****** shepherd/qrsh/qlogin_starter() ****************************************
*
* NAME
* qlogin_starter -- short description
*
* SYNOPSIS
* #include "qlogin_starter.h"
* int qlogin_starter(const char *cwd, char *daemon);
*
* FUNCTION
* The function is called from shepherd to start a protocol daemon
* like telnetd, rshd or rlogind.
* The mechanism used to call these daemons is that of inetd:
* - a socket is created (server side, any free port is assigned
* by the operating system)
* - qlogin_starter waits for someone to connect to this socket
* - the socket file handles are redirected to stdin, stdout
* and stderr
* - the daemon process is started
* Additionally to the inetd mechanism, the port number and some
* other information is sent to the qrsh process that initiated
* (over qmaster, schedd, execd, shepherd) the qlogin_starter call.
*
* INPUTS
* cwd - the current working directory (the active_jobs directory)
* daemon - name and path of the daemon to start
*
* RESULT
* on success, the function will not return (it exec's)
* 4, if there is a problem with permissions
* 5, if a socket cannot be allocated
* 6, if a socket bind fails
* 7, if socket name (port) cannot be determined
* 8, if environment (to be passed to qrsh) cannot be read
* 9, if sending information to qrsh fails
* 10, if nobody connects to the socket within a one minute
* 11, if the acception of a connecting client fails
* 12, if the execution of the daemon fails
******************************************************************************/
int qlogin_starter(const char *cwd, char *daemon, char** env)
{
int ret;
int port;
int fd;
int maxfd;
int sockfd;
int on = 1;
int sso = 1;
int newsfd;
fd_set fds;
struct sockaddr_in serv_addr;
struct timeval timeout;
char buffer[2048];
char *args[20]; /* JG: TODO: should be dynamically allocated */
int argc = 0;
const char *sge_root = NULL;
const char *arch = NULL;
#if defined(IRIX65) || defined(INTERIX) || defined(DARWIN6) || defined(ALPHA5) || defined(HP1164)
int length;
int len;
#else
socklen_t length;
socklen_t len;
#endif
len = sizeof(serv_addr);
/* must be root because we must access /dev/something */
if( setgid(SGE_SUPERUSER_GID) ||
setuid(SGE_SUPERUSER_UID) ||
setegid(SGE_SUPERUSER_GID) ||
seteuid(SGE_SUPERUSER_UID)) {
shepherd_trace("cannot change uid/gid\n");
return 4;
}
shepherd_trace("uid = "uid_t_fmt", euid = "uid_t_fmt", gid = "gid_t_fmt
", egid = "gid_t_fmt, getuid(), geteuid(), getgid(), getegid());
/* socket stuff from here */
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd == -1) {
shepherd_trace("cannot open socket.");
return 5;
}
shepherd_trace("using sfd %d", sockfd);
setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (char *) &on, sizeof(on));
/* bind an address to any socket */
memset((char *) &serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_port = 0;
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = INADDR_ANY;
ret = bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr));
if (ret != 0) {
shepherd_trace("cannot bind socket: %s", strerror(errno));
shutdown(sockfd, 2);
close(sockfd);
return 6;
}
/* find out assigned port number and pass it to caller */
length = sizeof(serv_addr);
if (getsockname(sockfd,(struct sockaddr *) &serv_addr, &length) == -1) {
shepherd_trace("getting socket name failed: %s", strerror(errno));
shutdown(sockfd, 2);
close(sockfd);
return 7;
}
/* listen on socked - make connections be accepted */
if (listen(sockfd, 1) != 0) {
shepherd_trace("listen failed: %s", strerror(errno));
shutdown(sockfd, 2);
close(sockfd);
return 8;
}
/* send necessary info to qrsh: port + utilbin directory + active job
* directory
*/
port = ntohs(serv_addr.sin_port);
shepherd_trace("bound to port %d", port);
sge_root = sge_get_root_dir(0, NULL, 0, 1);
arch = sge_get_arch();
if (sge_root == NULL || arch == NULL) {
shepherd_trace("reading environment SGE_ROOT and ARC failed");
shutdown(sockfd, 2);
close(sockfd);
return 9;
}
snprintf(buffer, 2048, "0:%d:%s/utilbin/%s:%s:%s",
port, sge_root, arch, cwd, get_conf_val("host"));
if (write_to_qrsh(buffer) != 0) {
shepherd_trace("communication with qrsh failed");
shutdown(sockfd, 2);
close(sockfd);
return 10;
}
/* wait for connection */
shepherd_trace("waiting for connection.");
/* use a reasonable timeout (60 seconds) to prevent hanging here forever */
FD_ZERO(&fds);
FD_SET(sockfd, &fds);
timeout.tv_sec = 60;
timeout.tv_usec = 0;
if (select(sockfd+1, &fds, NULL, NULL, &timeout) < 1) {
shepherd_trace("nobody connected to the socket");
shutdown(sockfd, 2);
close(sockfd);
return 11;
}
/* accept connection */
newsfd = accept(sockfd, (struct sockaddr *)(&serv_addr), &len);
if (newsfd == -1) {
shepherd_trace("error when accepting socket conection");
shutdown(sockfd, 2);
close(sockfd);
return 12;
}
shepherd_trace("accepted connection on fd %d", newsfd);
/* now we have a connection and do no longer need the "well known" port
* free this resource.
*/
shutdown(sockfd, 2);
close(sockfd);
/* don't close on exec */
fcntl( newsfd, F_SETFD, 0 );
/* speed up ;-) */
setsockopt(newsfd, IPPROTO_TCP, TCP_NODELAY, (const char *) &sso, sizeof(int));
/* use this fd as stdin,out,err */
dup2( newsfd, 0 );
dup2( newsfd, 1 );
dup2( newsfd, 2 );
/* close all the rest */
#ifndef WIN32NATIVE
maxfd = sysconf(_SC_OPEN_MAX);
#else /* WIN32NATIVE */
maxfd = FD_SETSIZE;
/* detect maximal number of fds under NT/W2000 (env: Files)*/
#endif /* WIN32NATIVE */
/* we do not use any FD_SET call it is ok to use _SC_OPEN_MAX */
for (fd=3; fd<maxfd; fd++) {
close(fd);
}
shepherd_trace("daemon to start: |%s|", daemon);
/* split daemon commandline into single arguments */
/* JG: TODO: might contain quoted arguments containing spaces
* make function to split or use an already existing one
*/
args[argc++] = strtok(daemon, " ");
while ((args[argc++] = strtok(NULL, " ")) != NULL);
#if 0
{
int i = 0;
shepherd_trace("daemon commandline split to %d arguments", argc);
while (args[i] != NULL) {
shepherd_trace("daemon argv[%d] = |%s|", i, args[i]);
i++;
}
}
#endif
/* that it. */
execve(args[0], args, env);
/* oh oh, exec failed */
/* no way to tell anyone, becuase all FDs are closed */
/* last chance -> tell parent process */
shutdown(newsfd, 2);
close(newsfd);
return 13;
}
int main(int argc, char *argv[])
{
double avg[3];
int loads;
char *name = NULL;
#if defined(PLPA_LINUX) || defined(BINDING_SOLARIS)
dstring msocket = DSTRING_INIT;
dstring mcore = DSTRING_INIT;
dstring mtopology = DSTRING_INIT;
#endif
#ifdef SGE_LOADMEM
sge_mem_info_t mem_info;
#endif
#ifdef SGE_LOADCPU
double total = 0.0;
#endif
int i, pos = 0, print_as_int = 0, precision = 0, core_binding = 0;
char *m = "";
#ifndef WINDOWS
DENTER_MAIN(TOP_LAYER, "loadcheck");
#endif
#ifdef __SGE_COMPILE_WITH_GETTEXT__
/* init language output for gettext() , it will use the right language */
sge_init_language_func((gettext_func_type) gettext,
(setlocale_func_type) setlocale,
(bindtextdomain_func_type) bindtextdomain,
(textdomain_func_type) textdomain);
sge_init_language(NULL,NULL);
#endif /* __SGE_COMPILE_WITH_GETTEXT__ */
if (argc == 2 && !strcmp(argv[1], "-cb")) {
core_binding = 1;
} else {
for (i = 1; i < argc;) {
if (!strcmp(argv[i], "-int"))
print_as_int = 1;
else if (!strcmp(argv[i], "-loadval")) {
if (i + 1 < argc)
pos=i+1;
else
usage();
i++;
}
else
usage();
i++;
}
}
if (core_binding) {
check_core_binding();
#ifndef WINDOWS
DEXIT;
#endif
return 1;
} else if (print_as_int) {
m = "";
precision = 0;
}
else {
m = "M";
precision = 6;
}
if ((pos && !strcmp("arch", argv[pos])) || !pos) {
const char *arch = "";
#if defined(WINDOWS)
arch = "win32-x86";
#else
arch = sge_get_arch();
#endif
printf("arch %s\n", arch);
}
if ((pos && !strcmp("num_proc", argv[pos])) || !pos) {
int nprocs = 1;
#if defined(WINDOWS)
SYSTEM_INFO system_info;
char buf[100];
GetSystemInfo(&system_info);
nprocs = system_info.dwNumberOfProcessors;
sprintf(buf, "num_proc %d", nprocs);
fflush(stdout);
write(1, (const void*)buf, (unsigned int)strlen(buf));
write(1, (const void*)"\0x0a", (unsigned int)1);
#else
nprocs = sge_nprocs();
printf("num_proc %d\n", nprocs);
#endif
}
#if defined(PLPA_LINUX) || defined(BINDING_SOLARIS)
fill_socket_core_topology(&msocket, &mcore, &mtopology);
if ((pos && !strcmp("m_socket", argv[pos])) || !pos) {
printf("m_socket %s\n", sge_dstring_get_string(&msocket));
}
if ((pos && !strcmp("m_core", argv[pos])) || !pos) {
printf("m_core %s\n", sge_dstring_get_string(&mcore));
}
if ((pos && !strcmp("m_topology", argv[pos])) || !pos) {
printf("m_topology %s\n", sge_dstring_get_string(&mtopology));
}
#else
if ((pos && !strcmp("m_socket", argv[pos])) || !pos) {
printf("m_socket -\n");
}
if ((pos && !strcmp("m_core", argv[pos])) || !pos) {
printf("m_core -\n");
}
if ((pos && !strcmp("m_topology", argv[pos])) || !pos) {
printf("m_topology -\n");
}
#endif
#if defined(WINDOWS)
loads = 0;
avg[0] = avg[1] = avg[2] = 0;
#else
loads = sge_getloadavg(avg, 3);
#endif
if (loads>0 && ((pos && !strcmp("load_short", argv[pos])) || !pos))
printf("load_short %.2f\n", avg[0]);
if (loads>1 && ((pos && !strcmp("load_medium", argv[pos])) || !pos))
printf("load_medium %.2f\n", avg[1]);
if (loads>2 && ((pos && !strcmp("load_long", argv[pos])) || !pos))
printf("load_long %.2f\n", avg[2]);
if (pos)
name = argv[pos];
else
name = NULL;
#ifdef SGE_LOADMEM
/* memory load report */
memset(&mem_info, 0, sizeof(sge_mem_info_t));
if (sge_loadmem(&mem_info)) {
fprintf(stderr, "%s\n", MSG_SYSTEM_RETMEMORYINDICESFAILED);
#ifndef WINDOWS
DEXIT;
#endif
#if defined(PLPA_LINUX) || defined(BINDING_SOLARIS)
sge_dstring_free(&mcore);
sge_dstring_free(&msocket);
sge_dstring_free(&mtopology);
#endif
return 1;
}
print_mem_load(LOAD_ATTR_MEM_FREE, name, precision, mem_info.mem_free, m);
print_mem_load(LOAD_ATTR_SWAP_FREE, name, precision, mem_info.swap_free, m);
print_mem_load(LOAD_ATTR_VIRTUAL_FREE, name, precision, mem_info.mem_free + mem_info.swap_free, m);
print_mem_load(LOAD_ATTR_MEM_TOTAL, name, precision, mem_info.mem_total, m);
print_mem_load(LOAD_ATTR_SWAP_TOTAL, name, precision, mem_info.swap_total, m);
print_mem_load(LOAD_ATTR_VIRTUAL_TOTAL, name, precision, mem_info.mem_total + mem_info.swap_total, m);
print_mem_load(LOAD_ATTR_MEM_USED, name, precision, mem_info.mem_total - mem_info.mem_free, m);
print_mem_load(LOAD_ATTR_SWAP_USED, name, precision, mem_info.swap_total - mem_info.swap_free, m);
print_mem_load(LOAD_ATTR_VIRTUAL_USED, name, precision,(mem_info.mem_total + mem_info.swap_total) -
(mem_info.mem_free + mem_info.swap_free), m);
# ifdef IRIX
print_mem_load(LOAD_ATTR_SWAP_USED, name, precision, mem_info.swap_rsvd, m);
# endif
#endif /* SGE_LOADMEM */
#ifdef SGE_LOADCPU
loads = sge_getcpuload(&total);
sleep(1);
loads = sge_getcpuload(&total);
if (loads != -1) {
print_mem_load("cpu", name, 1, total, "%");
}
#endif /* SGE_LOADCPU */
#ifndef WINDOWS
DEXIT;
#endif
#if defined(PLPA_LINUX) || defined(BINDING_SOLARIS)
sge_dstring_free(&mcore);
sge_dstring_free(&msocket);
sge_dstring_free(&mtopology);
#endif
return 0;
}
