int
main (void)
{
char *username_p, *password_p, *encrypted_p, *ptr;
struct passwd *pwd_p;
struct spwd *spwd_p;
bool authOK;
size_t len;
long lnmax;
lnmax = sysconf (_SC_LOGIN_NAME_MAX);
if (lnmax == -1)
lnmax = 256;
username_p = alloca (lnmax);
if (username_p == NULL) {
perror ("alloca()");
return 1;
}
printf ("username: "******"fgets()");
return 1;
}
len = strlen (username_p);
if (username_p[len-1] == '\n')
username_p[len-1] = 0;
pwd_p = getpwnam (username_p);
if (pwd_p == NULL) {
printf ("couldn't get password record\n");
return 1;
}
spwd_p = getspnam (username_p);
if (spwd_p == NULL && errno == EACCES) {
printf ("no permission to read shadow password file\n");
return 1;
}
if (spwd_p != NULL)
pwd_p->pw_passwd = spwd_p->sp_pwdp;
password_p = getpass ("password: "******"crypt()");
return 1;
}
authOK = strcmp (encrypted_p, pwd_p->pw_passwd) == 0;
if (!authOK) {
printf ("incorrect password\n");
return 1;
}
printf ("successfully authenticated UID=%ld\n", (long)pwd_p->pw_uid);
return 0;
}
int clDevicesNum(void) {
cl_int status;
char pbuff[256];
cl_uint numDevices;
cl_uint numPlatforms;
int most_devices = -1;
cl_platform_id *platforms;
cl_platform_id platform = NULL;
unsigned int i, mdplatform = 0;
status = clGetPlatformIDs(0, NULL, &numPlatforms);
/* If this fails, assume no GPUs. */
if (status != CL_SUCCESS) {
applog(LOG_ERR, "Error %d: clGetPlatformsIDs failed (no OpenCL SDK installed?)", status);
return -1;
}
if (numPlatforms == 0) {
applog(LOG_ERR, "clGetPlatformsIDs returned no platforms (no OpenCL SDK installed?)");
return -1;
}
platforms = (cl_platform_id *)alloca(numPlatforms*sizeof(cl_platform_id));
status = clGetPlatformIDs(numPlatforms, platforms, NULL);
if (status != CL_SUCCESS) {
applog(LOG_ERR, "Error %d: Getting Platform Ids. (clGetPlatformsIDs)", status);
return -1;
}
for (i = 0; i < numPlatforms; i++) {
if (opt_platform_id >= 0 && (int)i != opt_platform_id)
continue;
status = clGetPlatformInfo( platforms[i], CL_PLATFORM_VENDOR, sizeof(pbuff), pbuff, NULL);
if (status != CL_SUCCESS) {
applog(LOG_ERR, "Error %d: Getting Platform Info. (clGetPlatformInfo)", status);
return -1;
}
platform = platforms[i];
applog(LOG_INFO, "CL Platform %d vendor: %s", i, pbuff);
status = clGetPlatformInfo(platform, CL_PLATFORM_NAME, sizeof(pbuff), pbuff, NULL);
if (status == CL_SUCCESS)
applog(LOG_INFO, "CL Platform %d name: %s", i, pbuff);
status = clGetPlatformInfo(platform, CL_PLATFORM_VERSION, sizeof(pbuff), pbuff, NULL);
if (status == CL_SUCCESS)
applog(LOG_INFO, "CL Platform %d version: %s", i, pbuff);
status = clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 0, NULL, &numDevices);
if (status != CL_SUCCESS) {
applog(LOG_INFO, "Error %d: Getting Device IDs (num)", status);
continue;
}
applog(LOG_INFO, "Platform %d devices: %d", i, numDevices);
if ((int)numDevices > most_devices) {
most_devices = numDevices;
mdplatform = i;
}
if (numDevices) {
unsigned int j;
cl_device_id *devices = (cl_device_id *)malloc(numDevices*sizeof(cl_device_id));
clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, numDevices, devices, NULL);
for (j = 0; j < numDevices; j++) {
clGetDeviceInfo(devices[j], CL_DEVICE_NAME, sizeof(pbuff), pbuff, NULL);
applog(LOG_INFO, "\t%i\t%s", j, pbuff);
}
free(devices);
}
}
if (opt_platform_id < 0)
opt_platform_id = mdplatform;;
return most_devices;
}
int mapping_inverse(vorbis_dsp_state *vd,vorbis_info_mapping *info){
vorbis_info *vi=vd->vi;
codec_setup_info *ci=(codec_setup_info *)vi->codec_setup;
int i,j;
long n=ci->blocksizes[vd->W];
ogg_int32_t **pcmbundle=
alloca(sizeof(*pcmbundle)*vi->channels);
int *zerobundle=
alloca(sizeof(*zerobundle)*vi->channels);
int *nonzero=
alloca(sizeof(*nonzero)*vi->channels);
ogg_int32_t **floormemo=
alloca(sizeof(*floormemo)*vi->channels);
/* recover the spectral envelope; store it in the PCM vector for now */
for(i=0;i<vi->channels;i++){
int submap=0;
int floorno;
if(info->submaps>1)
submap=info->chmuxlist[i];
floorno=info->submaplist[submap].floor;
if(ci->floor_type[floorno]){
/* floor 1 */
floormemo[i]=alloca(sizeof(*floormemo[i])*
floor1_memosize(ci->floor_param[floorno]));
floormemo[i]=floor1_inverse1(vd,ci->floor_param[floorno],floormemo[i]);
}else{
/* floor 0 */
floormemo[i]=alloca(sizeof(*floormemo[i])*
floor0_memosize(ci->floor_param[floorno]));
floormemo[i]=floor0_inverse1(vd,ci->floor_param[floorno],floormemo[i]);
}
if(floormemo[i])
nonzero[i]=1;
else
nonzero[i]=0;
memset(vd->work[i],0,sizeof(*vd->work[i])*n/2);
}
/* channel coupling can 'dirty' the nonzero listing */
for(i=0;i<info->coupling_steps;i++){
if(nonzero[info->coupling[i].mag] ||
nonzero[info->coupling[i].ang]){
nonzero[info->coupling[i].mag]=1;
nonzero[info->coupling[i].ang]=1;
}
}
/* recover the residue into our working vectors */
for(i=0;i<info->submaps;i++){
int ch_in_bundle=0;
for(j=0;j<vi->channels;j++){
if(!info->chmuxlist || info->chmuxlist[j]==i){
if(nonzero[j])
zerobundle[ch_in_bundle]=1;
else
zerobundle[ch_in_bundle]=0;
pcmbundle[ch_in_bundle++]=vd->work[j];
}
}
res_inverse(vd,ci->residue_param+info->submaplist[i].residue,
pcmbundle,zerobundle,ch_in_bundle);
}
//for(j=0;j<vi->channels;j++)
//_analysis_output("coupled",seq+j,vb->pcm[j],-8,n/2,0,0);
/* channel coupling */
for(i=info->coupling_steps-1;i>=0;i--){
ogg_int32_t *pcmM=vd->work[info->coupling[i].mag];
ogg_int32_t *pcmA=vd->work[info->coupling[i].ang];
for(j=0;j<n/2;j++){
ogg_int32_t mag=pcmM[j];
ogg_int32_t ang=pcmA[j];
if(mag>0)
if(ang>0){
pcmM[j]=mag;
pcmA[j]=mag-ang;
}else{
pcmA[j]=mag;
pcmM[j]=mag+ang;
}
else
if(ang>0){
pcmM[j]=mag;
pcmA[j]=mag+ang;
}else{
pcmA[j]=mag;
pcmM[j]=mag-ang;
}
}
}
//for(j=0;j<vi->channels;j++)
//_analysis_output("residue",seq+j,vb->pcm[j],-8,n/2,0,0);
/* compute and apply spectral envelope */
for(i=0;i<vi->channels;i++){
ogg_int32_t *pcm=vd->work[i];
int submap=0;
int floorno;
if(info->submaps>1)
submap=info->chmuxlist[i];
floorno=info->submaplist[submap].floor;
if(ci->floor_type[floorno]){
/* floor 1 */
floor1_inverse2(vd,ci->floor_param[floorno],floormemo[i],pcm);
}else{
/* floor 0 */
floor0_inverse2(vd,ci->floor_param[floorno],floormemo[i],pcm);
}
}
//for(j=0;j<vi->channels;j++)
//_analysis_output("mdct",seq+j,vb->pcm[j],-24,n/2,0,1);
/* transform the PCM data; takes PCM vector, vb; modifies PCM vector */
/* only MDCT right now.... */
for(i=0;i<vi->channels;i++)
mdct_backward(n,vd->work[i]);
//for(j=0;j<vi->channels;j++)
//_analysis_output("imdct",seq+j,vb->pcm[j],-24,n,0,0);
/* all done! */
return(0);
}
/* this could use elf_interpreter() from elfread.c */
int
proc_iterate_over_mappings (int (*func) (int, CORE_ADDR))
{
vaddr_t curseg, memptr;
pt_vseg_t pv;
int rv, cmperr;
sec_ptr interp_sec;
char *interp_content;
int interp_fd, funcstat;
unsigned int size;
char buf1[NBPG], buf2[NBPG];
/*
* The following is really vile. We can get the name of the
* shared library from the exec_bfd, and we can get a list of
* each virtual memory segment, but there is no simple way to
* find the mapped segment from the shared library (ala
* procfs's PIOCOPENMEM). As a pretty nasty kludge, we
* compare the virtual memory segment to the contents of the
* .interp file. If they match, we assume that we've got the
* right one.
*/
/*
* TODO: for attach, use XPT_OPENT to get the executable, in
* case we're attached without knowning the executable's
* filename.
*/
#ifdef VERBOSE_DEBUG
printf ("proc_iter\n");
#endif
interp_sec = bfd_get_section_by_name (exec_bfd, ".interp");
if (!interp_sec)
{
return 0;
}
size = bfd_section_size (exec_bfd, interp_sec);
interp_content = alloca (size);
if (0 == bfd_get_section_contents (exec_bfd, interp_sec,
interp_content, (file_ptr) 0, size))
{
return 0;
}
#ifdef VERBOSE_DEBUG
printf ("proc_iter: \"%s\"\n", interp_content);
#endif
interp_fd = open (interp_content, O_RDONLY, 0);
if (-1 == interp_fd)
{
return 0;
}
curseg = 0;
while (1)
{
rv = ptrace (PT_NEXT_VSEG, PIDGET (inferior_ptid), &pv, curseg);
#ifdef VERBOSE_DEBUG
printf ("PT_NEXT_VSEG: rv %d errno %d\n", rv, errno);
#endif
if (-1 == rv)
break;
if (0 == rv)
break;
#ifdef VERBOSE_DEBUG
printf ("pv.pv_start 0x%x pv_size 0x%x pv_prot 0x%x\n",
pv.pv_start, pv.pv_size, pv.pv_prot);
#endif
curseg = pv.pv_start + pv.pv_size;
rv = lseek (interp_fd, 0, SEEK_SET);
if (-1 == rv)
{
perror ("lseek");
close (interp_fd);
return 0;
}
for (memptr = pv.pv_start; memptr < pv.pv_start + pv.pv_size;
memptr += NBPG)
{
#ifdef VERBOSE_DEBUG
printf ("memptr 0x%x\n", memptr);
#endif
rv = read (interp_fd, buf1, NBPG);
if (-1 == rv)
{
perror ("read");
close (interp_fd);
return 0;
}
rv = ptrace (PT_RDATA_PAGE, PIDGET (inferior_ptid), buf2,
memptr);
if (-1 == rv)
{
perror ("ptrace");
close (interp_fd);
return 0;
}
cmperr = memcmp (buf1, buf2, NBPG);
if (cmperr)
break;
}
if (0 == cmperr)
{
/* this is it */
funcstat = (*func) (interp_fd, pv.pv_start);
break;
}
}
close (interp_fd);
return 0;
}
void
fork_inferior (char *exec_file_arg, char *allargs, char **env,
void (*traceme_fun) (void), void (*init_trace_fun) (int),
void (*pre_trace_fun) (void), char *shell_file_arg)
{
int pid;
char *shell_command;
static char default_shell_file[] = SHELL_FILE;
int len;
/* Set debug_fork then attach to the child while it sleeps, to debug. */
static int debug_fork = 0;
/* This is set to the result of setpgrp, which if vforked, will be visible
to you in the parent process. It's only used by humans for debugging. */
static int debug_setpgrp = 657473;
static char *shell_file;
static char *exec_file;
char **save_our_env;
int shell = 0;
static char **argv;
const char *inferior_io_terminal = get_inferior_io_terminal ();
/* If no exec file handed to us, get it from the exec-file command
-- with a good, common error message if none is specified. */
exec_file = exec_file_arg;
if (exec_file == 0)
exec_file = get_exec_file (1);
/* STARTUP_WITH_SHELL is defined in inferior.h. If 0,e we'll just
do a fork/exec, no shell, so don't bother figuring out what
shell. */
shell_file = shell_file_arg;
if (STARTUP_WITH_SHELL)
{
/* Figure out what shell to start up the user program under. */
if (shell_file == NULL)
shell_file = getenv ("SHELL");
if (shell_file == NULL)
shell_file = default_shell_file;
shell = 1;
}
/* Multiplying the length of exec_file by 4 is to account for the
fact that it may expand when quoted; it is a worst-case number
based on every character being '. */
len = 5 + 4 * strlen (exec_file) + 1 + strlen (allargs) + 1 + /*slop */ 12;
/* If desired, concat something onto the front of ALLARGS.
SHELL_COMMAND is the result. */
#ifdef SHELL_COMMAND_CONCAT
shell_command = (char *) alloca (strlen (SHELL_COMMAND_CONCAT) + len);
strcpy (shell_command, SHELL_COMMAND_CONCAT);
#else
shell_command = (char *) alloca (len);
shell_command[0] = '\0';
#endif
if (!shell)
{
/* We're going to call execvp. Create argument vector.
Calculate an upper bound on the length of the vector by
assuming that every other character is a separate
argument. */
int argc = (strlen (allargs) + 1) / 2 + 2;
argv = (char **) xmalloc (argc * sizeof (*argv));
argv[0] = exec_file;
breakup_args (allargs, &argv[1]);
}
else
{
/* We're going to call a shell. */
/* Now add exec_file, quoting as necessary. */
char *p;
int need_to_quote;
const int escape_bang = escape_bang_in_quoted_argument (shell_file);
strcat (shell_command, "exec ");
/* Quoting in this style is said to work with all shells. But
csh on IRIX 4.0.1 can't deal with it. So we only quote it if
we need to. */
p = exec_file;
while (1)
{
switch (*p)
{
case '\'':
case '!':
case '"':
case '(':
case ')':
case '$':
case '&':
case ';':
case '<':
case '>':
case ' ':
case '\n':
case '\t':
need_to_quote = 1;
goto end_scan;
case '\0':
need_to_quote = 0;
goto end_scan;
default:
break;
}
++p;
}
end_scan:
if (need_to_quote)
{
strcat (shell_command, "'");
for (p = exec_file; *p != '\0'; ++p)
{
if (*p == '\'')
strcat (shell_command, "'\\''");
else if (*p == '!' && escape_bang)
strcat (shell_command, "\\!");
else
strncat (shell_command, p, 1);
}
strcat (shell_command, "'");
}
else
strcat (shell_command, exec_file);
strcat (shell_command, " ");
strcat (shell_command, allargs);
}
/* On some systems an exec will fail if the executable is open. */
close_exec_file ();
/* Retain a copy of our environment variables, since the child will
replace the value of environ and if we're vforked, we have to
restore it. */
save_our_env = environ;
/* Tell the terminal handling subsystem what tty we plan to run on;
it will just record the information for later. */
new_tty_prefork (inferior_io_terminal);
/* It is generally good practice to flush any possible pending stdio
output prior to doing a fork, to avoid the possibility of both
the parent and child flushing the same data after the fork. */
gdb_flush (gdb_stdout);
gdb_flush (gdb_stderr);
/* If there's any initialization of the target layers that must
happen to prepare to handle the child we're about fork, do it
now... */
if (pre_trace_fun != NULL)
(*pre_trace_fun) ();
/* Create the child process. Since the child process is going to
exec(3) shortly afterwards, try to reduce the overhead by
calling vfork(2). However, if PRE_TRACE_FUN is non-null, it's
likely that this optimization won't work since there's too much
work to do between the vfork(2) and the exec(3). This is known
to be the case on ttrace(2)-based HP-UX, where some handshaking
between parent and child needs to happen between fork(2) and
exec(2). However, since the parent is suspended in the vforked
state, this doesn't work. Also note that the vfork(2) call might
actually be a call to fork(2) due to the fact that autoconf will
``#define vfork fork'' on certain platforms. */
if (pre_trace_fun || debug_fork)
pid = fork ();
else
pid = vfork ();
if (pid < 0)
perror_with_name (("vfork"));
if (pid == 0)
{
if (debug_fork)
sleep (debug_fork);
/* Run inferior in a separate process group. */
debug_setpgrp = gdb_setpgid ();
if (debug_setpgrp == -1)
perror ("setpgrp failed in child");
/* Ask the tty subsystem to switch to the one we specified
earlier (or to share the current terminal, if none was
specified). */
new_tty ();
/* Changing the signal handlers for the inferior after
a vfork can also change them for the superior, so we don't mess
with signals here. See comments in
initialize_signals for how we get the right signal handlers
for the inferior. */
/* "Trace me, Dr. Memory!" */
(*traceme_fun) ();
/* The call above set this process (the "child") as debuggable
by the original gdb process (the "parent"). Since processes
(unlike people) can have only one parent, if you are debugging
gdb itself (and your debugger is thus _already_ the
controller/parent for this child), code from here on out is
undebuggable. Indeed, you probably got an error message
saying "not parent". Sorry; you'll have to use print
statements! */
/* There is no execlpe call, so we have to set the environment
for our child in the global variable. If we've vforked, this
clobbers the parent, but environ is restored a few lines down
in the parent. By the way, yes we do need to look down the
path to find $SHELL. Rich Pixley says so, and I agree. */
environ = env;
/* If we decided above to start up with a shell, we exec the
shell, "-c" says to interpret the next arg as a shell command
to execute, and this command is "exec <target-program>
<args>". */
if (shell)
{
execlp (shell_file, shell_file, "-c", shell_command, (char *) 0);
/* If we get here, it's an error. */
fprintf_unfiltered (gdb_stderr, "Cannot exec %s: %s.\n", shell_file,
safe_strerror (errno));
gdb_flush (gdb_stderr);
_exit (0177);
}
else
{
/* Otherwise, we directly exec the target program with
execvp. */
int i;
char *errstring;
execvp (exec_file, argv);
/* If we get here, it's an error. */
errstring = safe_strerror (errno);
fprintf_unfiltered (gdb_stderr, "Cannot exec %s ", exec_file);
i = 1;
while (argv[i] != NULL)
{
if (i != 1)
fprintf_unfiltered (gdb_stderr, " ");
fprintf_unfiltered (gdb_stderr, "%s", argv[i]);
i++;
}
fprintf_unfiltered (gdb_stderr, ".\n");
#if 0
/* This extra info seems to be useless. */
fprintf_unfiltered (gdb_stderr, "Got error %s.\n", errstring);
#endif
gdb_flush (gdb_stderr);
_exit (0177);
}
}
/* Restore our environment in case a vforked child clob'd it. */
environ = save_our_env;
init_thread_list ();
/* Needed for wait_for_inferior stuff below. */
inferior_ptid = pid_to_ptid (pid);
/* Now that we have a child process, make it our target, and
initialize anything target-vector-specific that needs
initializing. */
(*init_trace_fun) (pid);
/* We are now in the child process of interest, having exec'd the
correct program, and are poised at the first instruction of the
new program. */
}
int main(int argc, char *argv[])
{
plan(4);
// 1. Create slab cache
srand(time(0));
const unsigned pattern = 0xdeadbeef;
slab_cache_t cache;
int ret = slab_cache_init(&cache, sizeof(int));
is_int(0, ret, "slab: created empty cache");
// 2. Couple alloc/free
bool valid_free = true;
for(int i = 0; i < 100; ++i) {
int* data = (int*)slab_cache_alloc(&cache);
*data = pattern;
slab_free(data);
if (*data == pattern)
valid_free = false;
}
// 5. Verify freed block
ok(valid_free, "slab: freed memory is correctly invalidated");
// 4. Reap memory
slab_t* slab = cache.slabs_free;
int free_count = 0;
while (slab) {
slab_t* next = slab->next;
if (slab_isempty(slab)) {
++free_count;
}
slab = next;
}
int reaped = slab_cache_reap(&cache);
is_int(reaped, free_count, "slab: cache reaping works");
// Stress cache
int alloc_count = 73521;
void** ptrs = alloca(alloc_count * sizeof(void*));
int ptrs_i = 0;
for(int i = 0; i < alloc_count; ++i) {
double roll = rand() / (double) RAND_MAX;
if ((ptrs_i == 0) || (roll < 0.6)) {
int id = ptrs_i++;
ptrs[id] = slab_cache_alloc(&cache);
if (ptrs[id] == 0) {
ptrs_i--;
} else {
int* data = (int*)ptrs[id];
*data = pattern;
}
} else {
slab_free(ptrs[--ptrs_i]);
}
}
// 5. Delete cache
slab_cache_destroy(&cache);
is_int(0, cache.bufsize, "slab: freed cache");
return 0;
}
/* This is where execution begins */
int STDCALL WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPSTR szCmdLine, int sw)
{
char *appname;
char *ptr;
int i;
FILE *fp;
char **argv;
int argc;
/*
* Direct Draw has a nasty bug where a file that is opened before
* Direct Draw is invoked, *stays* open until the system is rebooted.
* So we need to get Direct Draw loaded before we open any files.
*/
{
HANDLE h;
h = LoadLibrary("DDRAW.DLL");
if(h)
FreeLibrary(LoadLibrary("DDRAW.DLL"));
}
/* FIXME:
* fprintf needs to be remapped to a windows function, otherwise when
* executor dies the user has no idea why it just vanished.
*/
fp = freopen("stdout.txt", "w", stdout);
#if !defined(stdout)
if(!fp)
stdout = fopen("stdout.txt", "w");
#else
if(!fp)
*stdout = *fopen("stdout.txt", "w");
#endif
setbuf(stdout, 0);
fp = freopen("stderr.txt", "w", stderr);
#if !defined(stderr)
if(!fp)
stderr = fopen("stderr.txt", "w");
#else
if(!fp)
*stderr = *fopen("stderr.txt", "w");
#endif
setbuf(stderr, 0);
paramline_to_argcv(GetCommandLine(), &argc, &argv);
/* Get the class name from argv[0] */
/* Basename... */
if((ptr = strrchr(argv[0], '\\')) == NULL)
appname = argv[0];
else
appname = ptr + 1;
/* minus extension... */
if((ptr = strrchr(appname, '.')) == NULL)
i = strlen(appname);
else
i = (ptr - appname);
/* equals appname! */
ptr = (char *)alloca(i + 1);
strncpy(ptr, appname, i);
ptr[i] = '\0';
appname = ptr;
/* Load SDL dynamic link library */
if(SDL_Init(0) < 0)
{
fprintf(stderr, "WinMain() error: %s\n", SDL_GetError());
return (false);
}
atexit(SDL_Quit);
/* Create and register our class, then run main code */
if(SDL_RegisterApp(appname, CS_BYTEALIGNCLIENT, hInst) < 0)
{
fprintf(stderr, "WinMain() error: %s\n", SDL_GetError());
return (false);
}
SDL_main(argc, argv);
exit(0);
}
int
mono_sgen_thread_handshake (int signum)
{
SgenThreadInfo *cur_thread = mono_sgen_thread_info_current ();
mach_msg_type_number_t num_state;
thread_state_t state;
kern_return_t ret;
ucontext_t ctx;
mcontext_t mctx;
SgenThreadInfo *info;
gpointer stack_start;
int count = 0;
state = (thread_state_t) alloca (mono_mach_arch_get_thread_state_size ());
mctx = (mcontext_t) alloca (mono_mach_arch_get_mcontext_size ());
FOREACH_THREAD (info) {
if (info == cur_thread || mono_sgen_is_worker_thread (info->id))
continue;
if (signum == suspend_signal_num) {
ret = thread_suspend (info->mach_port);
if (ret != KERN_SUCCESS)
continue;
ret = mono_mach_arch_get_thread_state (info->mach_port, state, &num_state);
if (ret != KERN_SUCCESS)
continue;
mono_mach_arch_thread_state_to_mcontext (state, mctx);
ctx.uc_mcontext = mctx;
info->stopped_domain = mono_mach_arch_get_tls_value_from_thread ((pthread_t)info->id, mono_pthread_key_for_tls (mono_domain_get_tls_key ()));
info->stopped_ip = (gpointer) mono_mach_arch_get_ip (state);
stack_start = (char*) mono_mach_arch_get_sp (state) - REDZONE_SIZE;
/* If stack_start is not within the limits, then don't set it in info and we will be restarted. */
if (stack_start >= info->stack_start_limit && info->stack_start <= info->stack_end) {
info->stack_start = stack_start;
#ifdef USE_MONO_CTX
mono_sigctx_to_monoctx (&ctx, &info->ctx);
info->monoctx = &info->ctx;
#else
ARCH_COPY_SIGCTX_REGS (&info->regs, &ctx);
info->stopped_regs = &info->regs;
#endif
} else {
g_assert (!info->stack_start);
}
/* Notify the JIT */
if (mono_gc_get_gc_callbacks ()->thread_suspend_func)
mono_gc_get_gc_callbacks ()->thread_suspend_func (info->runtime_data, &ctx);
} else {
ret = thread_resume (info->mach_port);
if (ret != KERN_SUCCESS)
continue;
}
count ++;
} END_FOREACH_THREAD
return count;
}
int main(int argc, const char **argv)
{
#ifdef _WIN32
_setmode( _fileno( stdout ), _O_BINARY );
_setmode( _fileno( stdin ), _O_BINARY );
#endif
Owned<IProperties> globals = createProperties("dumpkey.ini", true);
for (int i = 1; i < argc; i++)
{
if (argv[i][0] == '-')
doOption(argv[i]);
else if (strchr(argv[i], '='))
globals->loadProp(argv[i]);
else
globals->setProp("keyfile", argv[i]);
}
try
{
StringBuffer logname("dumpkey.");
logname.append(GetCachedHostName()).append(".");
StringBuffer lf;
openLogFile(lf, logname.append("log").str());
Owned <IKeyIndex> index;
const char * keyName = globals->queryProp("keyfile");
if (keyName)
index.setown(createKeyIndex(keyName, 0, false, false));
else
usage();
Owned <IKeyCursor> cursor = index->getCursor(NULL);
size32_t key_size = index->keySize();
Owned<IFile> in = createIFile(keyName);
Owned<IFileIO> io = in->open(IFOread);
if (!io)
throw MakeStringException(999, "Failed to open file %s", keyName);
Owned<CKeyHdr> header = new CKeyHdr;
MemoryAttr block(sizeof(KeyHdr));
io->read(0, sizeof(KeyHdr), (void *)block.get());
header->load(*(KeyHdr*)block.get());
unsigned nodeSize = header->getNodeSize();
if (!optRaw)
{
printf("Key '%s'\nkeySize=%d NumParts=%x, Top=%d\n", keyName, key_size, index->numParts(), index->isTopLevelKey());
printf("File size = %"I64F"d, nodes = %"I64F"d\n", in->size(), in->size() / nodeSize - 1);
printf("rootoffset=%"I64F"d[%"I64F"d]\n", header->getRootFPos(), header->getRootFPos()/nodeSize);
}
char *buffer = (char*)alloca(key_size);
if (globals->hasProp("node"))
{
if (stricmp(globals->queryProp("node"), "all")==0)
{
}
else
{
int node = globals->getPropInt("node");
if (node != 0)
index->dumpNode(stdout, node * nodeSize, globals->getPropInt("recs", 0), optRaw);
}
}
else if (globals->hasProp("fpos"))
{
index->dumpNode(stdout, globals->getPropInt("fpos"), globals->getPropInt("recs", 0), optRaw);
}
else
{
bool backwards=false;
bool ok;
if (globals->hasProp("end"))
{
memset(buffer, 0, key_size);
strcpy(buffer, globals->queryProp("end"));
ok = cursor->ltEqual(buffer, buffer);
backwards = true;
}
else if (globals->hasProp("start"))
{
memset(buffer, 0, key_size);
strcpy(buffer, globals->queryProp("start"));
ok = cursor->gtEqual(buffer, buffer);
}
else
ok = cursor->first(buffer);
unsigned count = globals->getPropInt("recs", 1);
while (ok && count--)
{
offset_t pos = cursor->getFPos();
unsigned __int64 seq = cursor->getSequence();
size32_t size = cursor->getSize();
if (optRaw)
{
fwrite(buffer, 1, size, stdout);
}
else if (optHex)
{
for (unsigned i = 0; i < size; i++)
printf("%02x", ((unsigned char) buffer[i]) & 0xff);
printf(" :%"I64F"u:%012"I64F"x\n", seq, pos);
}
else
printf("%.*s :%"I64F"u:%012"I64F"x\n", size, buffer, seq, pos);
if (backwards)
ok = cursor->prev(buffer);
else
ok = cursor->next(buffer);
}
}
}
catch (IException *E)
{
StringBuffer msg;
E->errorMessage(msg);
E->Release();
fatal("%s", msg.str());
}
releaseAtoms();
ExitModuleObjects();
return 0;
}
/*
* Function: socket_connection
*
* Purpose: Opens the network connection with the mail host, without
* doing any sort of I/O with it or anything.
*
* Arguments:
* host The host to which to connect.
* flags Option flags.
*
* Return value: A file descriptor indicating the connection, or -1
* indicating failure, in which case an error has been copied
* into pop_error.
*/
static int
socket_connection (char *host, int flags)
{
#ifdef HAVE_GETADDRINFO
struct addrinfo *res, *it;
struct addrinfo hints;
int ret;
#else /* !HAVE_GETADDRINFO */
struct hostent *hostent;
#endif
struct servent *servent;
struct sockaddr_in addr;
char found_port = 0;
const char *service;
int sock;
char *realhost;
#ifdef KERBEROS
#ifdef KERBEROS5
krb5_error_code rem;
krb5_context kcontext = 0;
krb5_auth_context auth_context = 0;
krb5_ccache ccdef;
krb5_principal client, server;
krb5_error *err_ret;
register char *cp;
#else
KTEXT ticket;
MSG_DAT msg_data;
CREDENTIALS cred;
Key_schedule schedule;
int rem;
#endif /* KERBEROS5 */
#endif /* KERBEROS */
int try_count = 0;
int connect_ok;
#ifdef WINDOWSNT
{
WSADATA winsockData;
if (WSAStartup (0x101, &winsockData) == 0)
have_winsock = 1;
}
#endif
memset (&addr, 0, sizeof (addr));
addr.sin_family = AF_INET;
/** "kpop" service is never used: look for 20060515 to see why **/
#ifdef KERBEROS
service = (flags & POP_NO_KERBEROS) ? POP_SERVICE : KPOP_SERVICE;
#else
service = POP_SERVICE;
#endif
#ifdef HESIOD
if (! (flags & POP_NO_HESIOD))
{
servent = hes_getservbyname (service, "tcp");
if (servent)
{
addr.sin_port = servent->s_port;
found_port = 1;
}
}
#endif
if (! found_port)
{
servent = getservbyname (service, "tcp");
if (servent)
{
addr.sin_port = servent->s_port;
}
else
{
/** "kpop" service is never used: look for 20060515 to see why **/
#ifdef KERBEROS
addr.sin_port = htons ((flags & POP_NO_KERBEROS) ?
POP_PORT : KPOP_PORT);
#else
addr.sin_port = htons (POP_PORT);
#endif
}
}
#define POP_SOCKET_ERROR "Could not create socket for POP connection: "
sock = socket (PF_INET, SOCK_STREAM, 0);
if (sock < 0)
{
snprintf (pop_error, ERROR_MAX, "%s%s",
POP_SOCKET_ERROR, strerror (errno));
return (-1);
}
#ifdef HAVE_GETADDRINFO
memset (&hints, 0, sizeof (hints));
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = AI_CANONNAME;
hints.ai_family = AF_INET;
do
{
ret = getaddrinfo (host, service, &hints, &res);
try_count++;
if (ret != 0 && (ret != EAI_AGAIN || try_count == 5))
{
strcpy (pop_error, "Could not determine POP server's address");
return (-1);
}
} while (ret != 0);
for (it = res; it; it = it->ai_next)
if (it->ai_addrlen == sizeof addr)
{
struct sockaddr_in *in_a = (struct sockaddr_in *) it->ai_addr;
addr.sin_addr = in_a->sin_addr;
if (! connect (sock, (struct sockaddr *) &addr, sizeof addr))
break;
}
connect_ok = it != NULL;
if (connect_ok)
{
realhost = alloca (strlen (it->ai_canonname) + 1);
strcpy (realhost, it->ai_canonname);
}
freeaddrinfo (res);
#else /* !HAVE_GETADDRINFO */
do
{
hostent = gethostbyname (host);
try_count++;
if ((! hostent) && ((h_errno != TRY_AGAIN) || (try_count == 5)))
{
strcpy (pop_error, "Could not determine POP server's address");
return (-1);
}
} while (! hostent);
while (*hostent->h_addr_list)
{
memcpy (&addr.sin_addr, *hostent->h_addr_list, hostent->h_length);
if (! connect (sock, (struct sockaddr *) &addr, sizeof (addr)))
break;
hostent->h_addr_list++;
}
connect_ok = *hostent->h_addr_list != NULL;
if (! connect_ok)
{
realhost = alloca (strlen (hostent->h_name) + 1);
strcpy (realhost, hostent->h_name);
}
#endif /* !HAVE_GETADDRINFO */
#define CONNECT_ERROR "Could not connect to POP server: "
if (! connect_ok)
{
CLOSESOCKET (sock);
snprintf (pop_error, ERROR_MAX, "%s%s", CONNECT_ERROR, strerror (errno));
return (-1);
}
#ifdef KERBEROS
#define KRB_ERROR "Kerberos error connecting to POP server: "
if (! (flags & POP_NO_KERBEROS))
{
#ifdef KERBEROS5
if ((rem = krb5_init_context (&kcontext)))
{
krb5error:
if (auth_context)
krb5_auth_con_free (kcontext, auth_context);
if (kcontext)
krb5_free_context (kcontext);
snprintf (pop_error, ERROR_MAX, "%s%s",
KRB_ERROR, error_message (rem));
CLOSESOCKET (sock);
return (-1);
}
if ((rem = krb5_auth_con_init (kcontext, &auth_context)))
goto krb5error;
if (rem = krb5_cc_default (kcontext, &ccdef))
goto krb5error;
if (rem = krb5_cc_get_principal (kcontext, ccdef, &client))
goto krb5error;
for (cp = realhost; *cp; cp++)
{
if (isupper (*cp))
{
*cp = tolower (*cp);
}
}
if (rem = krb5_sname_to_principal (kcontext, realhost,
POP_SERVICE, FALSE, &server))
goto krb5error;
rem = krb5_sendauth (kcontext, &auth_context,
(krb5_pointer) &sock, "KPOPV1.0", client, server,
AP_OPTS_MUTUAL_REQUIRED,
0, /* no checksum */
0, /* no creds, use ccache instead */
ccdef,
&err_ret,
0, /* don't need subsession key */
0); /* don't need reply */
krb5_free_principal (kcontext, server);
if (rem)
{
int pop_error_len = snprintf (pop_error, ERROR_MAX, "%s%s",
KRB_ERROR, error_message (rem));
#if defined HAVE_KRB5_ERROR_TEXT
if (err_ret && err_ret->text.length)
{
int errlen = err_ret->text.length;
snprintf (pop_error + pop_error_len, ERROR_MAX - pop_error_len,
" [server says '.*%s']", errlen, err_ret->text.data);
}
#elif defined HAVE_KRB5_ERROR_E_TEXT
if (err_ret && err_ret->e_text && **err_ret->e_text)
snprintf (pop_error + pop_error_len, ERROR_MAX - pop_error_len,
" [server says '%s']", *err_ret->e_text);
#endif
if (err_ret)
krb5_free_error (kcontext, err_ret);
krb5_auth_con_free (kcontext, auth_context);
krb5_free_context (kcontext);
CLOSESOCKET (sock);
return (-1);
}
#else /* ! KERBEROS5 */
ticket = (KTEXT) malloc (sizeof (KTEXT_ST));
rem = krb_sendauth (0L, sock, ticket, "pop", realhost,
(char *) krb_realmofhost (realhost),
(unsigned long) 0, &msg_data, &cred, schedule,
(struct sockaddr_in *) 0,
(struct sockaddr_in *) 0,
"KPOPV0.1");
free ((char *) ticket);
if (rem != KSUCCESS)
{
snprintf (pop_error, ERROR_MAX, "%s%s", KRB_ERROR, krb_err_txt[rem]);
CLOSESOCKET (sock);
return (-1);
}
#endif /* KERBEROS5 */
}
#endif /* KERBEROS */
return (sock);
} /* socket_connection */
static void
gdbsim_open (char *args, int from_tty)
{
int len;
char *arg_buf;
char **argv;
if (remote_debug)
printf_filtered ("gdbsim_open: args \"%s\"\n", args ? args : "(null)");
/* Remove current simulator if one exists. Only do this if the simulator
has been opened because sim_close requires it.
This is important because the call to push_target below will cause
sim_close to be called if the simulator is already open, but push_target
is called after sim_open! We can't move the call to push_target before
the call to sim_open because sim_open may invoke `error'. */
if (gdbsim_desc != NULL)
unpush_target (&gdbsim_ops);
len = (7 + 1 /* gdbsim */
+ strlen (" -E little")
+ strlen (" --architecture=xxxxxxxxxx")
+ (args ? strlen (args) : 0)
+ 50) /* slack */ ;
arg_buf = (char *) alloca (len);
strcpy (arg_buf, "gdbsim"); /* 7 */
/* Specify the byte order for the target when it is explicitly
specified by the user (not auto detected). */
switch (selected_byte_order ())
{
case BFD_ENDIAN_BIG:
strcat (arg_buf, " -E big");
break;
case BFD_ENDIAN_LITTLE:
strcat (arg_buf, " -E little");
break;
case BFD_ENDIAN_UNKNOWN:
break;
}
/* Specify the architecture of the target when it has been
explicitly specified */
if (selected_architecture_name () != NULL)
{
strcat (arg_buf, " --architecture=");
strcat (arg_buf, selected_architecture_name ());
}
/* finally, any explicit args */
if (args)
{
strcat (arg_buf, " "); /* 1 */
strcat (arg_buf, args);
}
argv = buildargv (arg_buf);
if (argv == NULL)
error (_("Insufficient memory available to allocate simulator arg list."));
make_cleanup_freeargv (argv);
init_callbacks ();
gdbsim_desc = sim_open (SIM_OPEN_DEBUG, &gdb_callback, exec_bfd, argv);
if (gdbsim_desc == 0)
error (_("unable to create simulator instance"));
push_target (&gdbsim_ops);
printf_filtered ("Connected to the simulator.\n");
/* There's nothing running after "target sim" or "load"; not until
"run". */
inferior_ptid = null_ptid;
target_mark_exited (&gdbsim_ops);
}
static int
current_lock_owner (lock_info_type *owner, char *lfname)
{
int len, ret;
int local_owner = 0;
char *at, *dot, *colon;
char *lfinfo = 0;
int bufsize = 50;
/* Read arbitrarily-long contents of symlink. Similar code in
file-symlink-p in fileio.c. */
do
{
bufsize *= 2;
lfinfo = (char *) xrealloc (lfinfo, bufsize);
errno = 0;
len = readlink (lfname, lfinfo, bufsize);
#ifdef ERANGE
/* HP-UX reports ERANGE if the buffer is too small. */
if (len == -1 && errno == ERANGE)
len = bufsize;
#endif
}
while (len >= bufsize);
/* If nonexistent lock file, all is well; otherwise, got strange error. */
if (len == -1)
{
xfree (lfinfo);
return errno == ENOENT ? 0 : -1;
}
/* Link info exists, so `len' is its length. Null terminate. */
lfinfo[len] = 0;
/* Even if the caller doesn't want the owner info, we still have to
read it to determine return value, so allocate it. */
if (!owner)
{
owner = (lock_info_type *) alloca (sizeof (lock_info_type));
local_owner = 1;
}
/* Parse [email protected]:BOOT_TIME. If can't parse, return -1. */
/* The USER is everything before the last @. */
at = strrchr (lfinfo, '@');
dot = strrchr (lfinfo, '.');
if (!at || !dot)
{
xfree (lfinfo);
return -1;
}
len = at - lfinfo;
owner->user = (char *) xmalloc (len + 1);
strncpy (owner->user, lfinfo, len);
owner->user[len] = 0;
/* The PID is everything from the last `.' to the `:'. */
owner->pid = atoi (dot + 1);
colon = dot;
while (*colon && *colon != ':')
colon++;
/* After the `:', if there is one, comes the boot time. */
if (*colon == ':')
owner->boot_time = atoi (colon + 1);
else
owner->boot_time = 0;
/* The host is everything in between. */
len = dot - at - 1;
owner->host = (char *) xmalloc (len + 1);
strncpy (owner->host, at + 1, len);
owner->host[len] = 0;
/* We're done looking at the link info. */
xfree (lfinfo);
/* On current host? */
if (STRINGP (Fsystem_name ())
&& strcmp (owner->host, SSDATA (Fsystem_name ())) == 0)
{
if (owner->pid == getpid ())
ret = 2; /* We own it. */
else if (owner->pid > 0
&& (kill (owner->pid, 0) >= 0 || errno == EPERM)
&& (owner->boot_time == 0
|| within_one_second (owner->boot_time, get_boot_time ())))
ret = 1; /* An existing process on this machine owns it. */
/* The owner process is dead or has a strange pid (<=0), so try to
zap the lockfile. */
else if (unlink (lfname) < 0)
ret = -1;
else
ret = 0;
}
else
{ /* If we wanted to support the check for stale locks on remote machines,
here's where we'd do it. */
ret = 1;
}
/* Avoid garbage. */
if (local_owner || ret <= 0)
{
FREE_LOCK_INFO (*owner);
}
return ret;
}
RTDECL(int) RTDirReadEx(PRTDIR pDir, PRTDIRENTRYEX pDirEntry, size_t *pcbDirEntry, RTFSOBJATTRADD enmAdditionalAttribs, uint32_t fFlags)
{
/*
* Validate and digest input.
*/
if (!rtDirValidHandle(pDir))
return VERR_INVALID_PARAMETER;
AssertMsgReturn(VALID_PTR(pDirEntry), ("%p\n", pDirEntry), VERR_INVALID_POINTER);
AssertMsgReturn( enmAdditionalAttribs >= RTFSOBJATTRADD_NOTHING
&& enmAdditionalAttribs <= RTFSOBJATTRADD_LAST,
("Invalid enmAdditionalAttribs=%p\n", enmAdditionalAttribs),
VERR_INVALID_PARAMETER);
AssertMsgReturn(RTPATH_F_IS_VALID(fFlags, 0), ("%#x\n", fFlags), VERR_INVALID_PARAMETER);
size_t cbDirEntry = sizeof(*pDirEntry);
if (pcbDirEntry)
{
AssertMsgReturn(VALID_PTR(pcbDirEntry), ("%p\n", pcbDirEntry), VERR_INVALID_POINTER);
cbDirEntry = *pcbDirEntry;
AssertMsgReturn(cbDirEntry >= (unsigned)RT_OFFSETOF(RTDIRENTRYEX, szName[2]),
("Invalid *pcbDirEntry=%d (min %d)\n", *pcbDirEntry, RT_OFFSETOF(RTDIRENTRYEX, szName[2])),
VERR_INVALID_PARAMETER);
}
/*
* Fetch more data if necessary and/or convert the name.
*/
int rc = rtDirReadMore(pDir);
if (RT_SUCCESS(rc))
{
/*
* Check if we've got enough space to return the data.
*/
const char *pszName = pDir->pszName;
const size_t cchName = pDir->cchName;
const size_t cbRequired = RT_OFFSETOF(RTDIRENTRYEX, szName[1]) + cchName;
if (pcbDirEntry)
*pcbDirEntry = cbRequired;
if (cbRequired <= cbDirEntry)
{
/*
* Setup the returned data.
*/
pDirEntry->cwcShortName = 0;
pDirEntry->wszShortName[0] = 0;
pDirEntry->cbName = (uint16_t)cchName;
Assert(pDirEntry->cbName == cchName);
memcpy(pDirEntry->szName, pszName, cchName + 1);
/* get the info data */
size_t cch = cchName + pDir->cchPath + 1;
char *pszNamePath = (char *)alloca(cch);
if (pszNamePath)
{
memcpy(pszNamePath, pDir->pszPath, pDir->cchPath);
memcpy(pszNamePath + pDir->cchPath, pszName, cchName + 1);
rc = RTPathQueryInfoEx(pszNamePath, &pDirEntry->Info, enmAdditionalAttribs, fFlags);
}
else
rc = VERR_NO_MEMORY;
if (RT_FAILURE(rc))
{
#ifdef HAVE_DIRENT_D_TYPE
rtDirSetDummyInfo(&pDirEntry->Info, rtDirType(pDir->Data.d_type));
#else
rtDirSetDummyInfo(&pDirEntry->Info, RTDIRENTRYTYPE_UNKNOWN);
#endif
rc = VWRN_NO_DIRENT_INFO;
}
/* free cached data */
pDir->fDataUnread = false;
rtPathFreeIprt(pDir->pszName, pDir->Data.d_name);
pDir->pszName = NULL;
}
else
rc = VERR_BUFFER_OVERFLOW;
}
return rc;
}
bool ON_Mesh::CollapseEdge( int topei )
{
ON_Mesh& mesh = *this;
MESHEDGE me;
memset(&me,0,sizeof(me));
const ON_MeshTopology& top = mesh.Topology();
const int F_count = mesh.m_F.Count();
const int V_count = mesh.m_V.Count();
const int topv_count = top.m_topv.Count();
//const int tope_count = top.m_tope.Count();
if ( topei < 0 || topei >= top.m_tope.Count() )
{
return false;
}
const ON_MeshTopologyEdge& tope = top.m_tope[topei];
if ( tope.m_topf_count < 1
|| tope.m_topvi[0] == tope.m_topvi[1]
|| tope.m_topvi[0] < 0
|| tope.m_topvi[1] < 0
|| tope.m_topvi[0] >= topv_count
|| tope.m_topvi[1] >= topv_count )
{
return false;
}
const ON_MeshTopologyVertex& topv0 = top.m_topv[tope.m_topvi[0]];
const ON_MeshTopologyVertex& topv1 = top.m_topv[tope.m_topvi[1]];
if ( topv0.m_v_count < 1 || topv1.m_v_count < 1 )
{
return false;
}
if ( topv0.m_vi[0] < 0 || topv0.m_vi[0] >= V_count )
{
return false;
}
if ( topv1.m_vi[0] < 0 || topv1.m_vi[0] >= V_count )
{
return false;
}
// create a MESHEDGE for each face (usually one or two) that uses the edge
MESHEDGE* me_list = (MESHEDGE*)alloca(tope.m_topf_count*sizeof(me_list[0]));
int me_list_count = 0;
int efi;
for ( efi = 0; efi < tope.m_topf_count; efi++ )
{
int fi = tope.m_topfi[efi];
if ( fi < 0 || fi >= F_count )
continue;
const ON_MeshFace& f = mesh.m_F[fi];
if ( !f.IsValid(V_count) )
continue;
me.vi1 = f.vi[3];
me.topvi1 = top.m_topv_map[me.vi1];
int fvi;
for ( fvi = 0; fvi < 4; fvi++ )
{
me.vi0 = me.vi1;
me.topvi0 = me.topvi1;
me.vi1 = f.vi[fvi];
me.topvi1 = top.m_topv_map[me.vi1];
if ( me.vi0 != me.vi1 )
{
if ( (me.topvi0 == tope.m_topvi[0] && me.topvi1 == tope.m_topvi[1])
|| (me.topvi0 == tope.m_topvi[1] && me.topvi1 == tope.m_topvi[0]) )
{
if ( me.vi0 > me.vi1 )
{
int i = me.vi0; me.vi0 = me.vi1; me.vi1 = i;
i = me.topvi0; me.topvi0 = me.topvi1; me.topvi1 = i;
}
me_list[me_list_count++] = me;
break;
}
}
}
}
if (me_list_count<1)
{
return false;
}
// Sort me_list[] so edges using same vertices are adjacent
// to each other in the list. This is needed so that non-manifold
// crease edges will be properly collapsed.
qsort(me_list,me_list_count,sizeof(me_list[0]),(QSORTCMPFUNC)CompareMESHEDGE);
// create new vertex or vertices that edge will be
// collapsed to.
mesh.m_C.Destroy();
mesh.m_K.Destroy();
int mei;
bool bHasVertexNormals = mesh.HasVertexNormals();
bool bHasTextureCoordinates = mesh.HasTextureCoordinates();
bool bHasFaceNormals = mesh.HasFaceNormals();
if ( topv0.m_v_count == 1 || topv1.m_v_count == 1 )
{
// a single new vertex
ON_Line Vline(ON_origin,ON_origin);
ON_Line Tline(ON_origin,ON_origin);
ON_3dVector N0(0,0,0);
ON_3dVector N1(0,0,0);
ON_3dPoint P;
int vi, tvi, cnt;
int newvi = topv0.m_vi[0];
cnt = 0;
for ( tvi = 0; tvi < topv0.m_v_count; tvi++ )
{
vi = topv0.m_vi[tvi];
if ( vi < 0 || vi > V_count )
continue;
if ( vi < newvi )
newvi = vi;
cnt++;
P = mesh.m_V[vi];
Vline.from += P;
if ( bHasVertexNormals )
{
N0 += ON_3dVector(mesh.m_N[vi]);
}
if ( bHasTextureCoordinates )
{
P = mesh.m_T[vi];
Tline.from += P;
}
}
if (cnt > 1)
{
double s = 1.0/((double)cnt);
Vline.from.x *= s;
Vline.from.y *= s;
Vline.from.z *= s;
Tline.from.x *= s;
Tline.from.y *= s;
Tline.from.z *= s;
N0 = s*N0;
}
cnt = 0;
for ( tvi = 0; tvi < topv1.m_v_count; tvi++ )
{
vi = topv1.m_vi[tvi];
if ( vi < 0 || vi > V_count )
continue;
if ( vi < newvi )
newvi = vi;
cnt++;
P = mesh.m_V[vi];
Vline.to += P;
if ( bHasVertexNormals )
{
N1 += ON_3dVector(mesh.m_N[vi]);
}
if ( bHasTextureCoordinates )
{
P = mesh.m_T[vi];
Tline.to += P;
}
}
if (cnt > 1)
{
double s = 1.0/((double)cnt);
Vline.to.x *= s;
Vline.to.y *= s;
Vline.to.z *= s;
Tline.to.x *= s;
Tline.to.y *= s;
Tline.to.z *= s;
N1 = s*N1;
}
ON_3fPoint newV(Vline.PointAt(0.5));
ON_3fVector newN;
ON_2fPoint newT;
if ( bHasVertexNormals )
{
N0.Unitize();
N1.Unitize();
ON_3dVector N = N0+N1;
if ( !N.Unitize() )
{
N = (topv0.m_v_count == 1) ? mesh.m_N[topv0.m_vi[0]] :mesh.m_N[topv1.m_vi[0]];
}
newN = N;
}
if ( bHasTextureCoordinates )
{
newT = Tline.PointAt(0.5);
}
for ( mei = 0; mei < me_list_count; mei++ )
{
me_list[mei].newvi = newvi;
me_list[mei].newV = newV;
me_list[mei].newN = newN;
me_list[mei].newT = newT;
}
}
else
{
// collapsing a "crease" edge - attempt to preserve
// the crease.
memset(&me,0,sizeof(me));
me.vi0 = -1;
me.vi1 = -1;
for ( mei = 0; mei < me_list_count; mei++ )
{
if ( 0 == mei && CompareMESHEDGE(&me,me_list+mei) )
{
// cook up new vertex
me_list[mei].newvi = mesh.m_V.Count();
me = me_list[mei];
ON_Line line;
line.from = mesh.m_V[me.vi0];
line.to = mesh.m_V[me.vi1];
me.newV = line.PointAt(0.5);
if ( bHasVertexNormals )
{
ON_3dVector N0(mesh.m_N[me.vi0]);
ON_3dVector N1(mesh.m_N[me.vi1]);
ON_3dVector N = N0 + N1;
if ( !N.Unitize() )
N = N0;
me.newN = N;
}
if ( bHasTextureCoordinates )
{
line.from = mesh.m_T[me.vi0];
line.to = mesh.m_T[me.vi1];
me.newT = line.PointAt(0.5);
}
me.newvi = (me.vi0 < me.vi1) ? me.vi0 : me.vi1;
}
else
{
me_list[mei].newvi = me.newvi;
me_list[mei].newV = me.newV;
me_list[mei].newN = me.newN;
me_list[mei].newT = me.newT;
}
}
}
// We are done averaging old mesh values.
// Change values in mesh m_V[], m_N[] and m_T[] arrays.
for ( mei = 0; mei < me_list_count; mei++ )
{
mesh.m_V[me_list[mei].vi0] = me_list[mei].newV;
mesh.m_V[me_list[mei].vi1] = me_list[mei].newV;
if ( bHasVertexNormals )
{
mesh.m_N[me_list[mei].vi0] = me_list[mei].newN;
mesh.m_N[me_list[mei].vi1] = me_list[mei].newN;
}
if ( bHasTextureCoordinates )
{
mesh.m_T[me_list[mei].vi0] = me_list[mei].newT;
mesh.m_T[me_list[mei].vi1] = me_list[mei].newT;
}
}
// make a map of old to new
int old2new_map_count = 0;
NEWVI* old2new_map = (NEWVI*)alloca(2*me_list_count*sizeof(old2new_map[0]));
for ( mei = 0; mei < me_list_count; mei++ )
{
old2new_map[old2new_map_count].oldvi = me_list[mei].vi0;
old2new_map[old2new_map_count].newvi = me_list[mei].newvi;
old2new_map_count++;
old2new_map[old2new_map_count].oldvi = me_list[mei].vi1;
old2new_map[old2new_map_count].newvi = me_list[mei].newvi;
old2new_map_count++;
}
// sort old2new_map[] so we can use a fast bsearch() call
// to update faces.
qsort(old2new_map,old2new_map_count,sizeof(old2new_map[0]),(QSORTCMPFUNC)CompareNEWVI);
// count faces that use the vertices that are being changed
int bad_fi_count = 0;
int topv_end, vei, fi, fvi23, fvi;
NEWVI nvi;
for ( topv_end = 0; topv_end < 2; topv_end++ )
{
const ON_MeshTopologyVertex& topv = (topv_end) ? topv1 : topv0;
for ( vei = 0; vei < topv.m_tope_count; vei++ )
{
topei = topv.m_topei[vei];
if ( topei < 0 && topei >= top.m_tope.Count() )
continue;
bad_fi_count += top.m_tope[topei].m_topf_count;
}
}
int* bad_fi = (int*)alloca(bad_fi_count*sizeof(*bad_fi));
bad_fi_count = 0;
// Go through all the faces that use the vertices at the
// ends of the edge and update the vi[] values to use the
// new vertices.
for ( topv_end = 0; topv_end < 2; topv_end++ )
{
const ON_MeshTopologyVertex& topv = (topv_end) ? topv1 : topv0;
for ( vei = 0; vei < topv.m_tope_count; vei++ )
{
topei = topv.m_topei[vei];
if ( topei < 0 && topei >= top.m_tope.Count() )
continue;
const ON_MeshTopologyEdge& e = top.m_tope[topei];
for ( efi = 0; efi < e.m_topf_count; efi++ )
{
fi = e.m_topfi[efi];
if ( fi < 0 || fi >= F_count )
continue;
bool bChangedFace = false;
ON_MeshFace& f = mesh.m_F[fi];
for ( fvi = 0; fvi < 4; fvi++ )
{
nvi.oldvi = f.vi[fvi];
NEWVI* p = (NEWVI*)bsearch(&nvi,old2new_map,old2new_map_count,sizeof(old2new_map[0]),(QSORTCMPFUNC)CompareNEWVI);
if ( 0 != p && p->oldvi != p->newvi)
{
f.vi[fvi] = p->newvi;
bChangedFace = true;
}
}
if ( bChangedFace )
{
if ( !f.IsValid(V_count) )
{
if ( f.vi[3] == f.vi[0] )
{
f.vi[0] = f.vi[1];
f.vi[1] = f.vi[2];
f.vi[2] = f.vi[3];
}
else if ( f.vi[0] == f.vi[1] )
{
fvi23 = f.vi[0];
f.vi[0] = f.vi[2];
f.vi[1] = f.vi[3];
f.vi[2] = fvi23;
f.vi[3] = fvi23;
}
else if ( f.vi[1] == f.vi[2] )
{
fvi23 = f.vi[1];
f.vi[1] = f.vi[0];
f.vi[0] = f.vi[3];
f.vi[2] = fvi23;
f.vi[3] = fvi23;
}
if ( f.vi[0] == f.vi[1] || f.vi[1] == f.vi[2] || f.vi[2] == f.vi[0] || f.vi[2] != f.vi[3] )
{
bad_fi[bad_fi_count++] = fi;
}
}
if ( bHasFaceNormals )
{
// invalid faces are removed below
ON_3fVector a, b, n;
a = mesh.m_V[f.vi[2]] - mesh.m_V[f.vi[0]];
b = mesh.m_V[f.vi[3]] - mesh.m_V[f.vi[1]];
n = ON_CrossProduct( a, b );
n.Unitize();
mesh.m_FN[fi] = n;
}
}
}
}
}
if ( bad_fi_count > 0 )
{
// remove collapsed faces
qsort(bad_fi,bad_fi_count,sizeof(bad_fi[0]),CompareInt);
int bfi = 1;
int dest_fi = bad_fi[0];
for ( fi = dest_fi+1; fi < F_count && bfi < bad_fi_count; fi++ )
{
if ( fi == bad_fi[bfi] )
{
bfi++;
}
else
{
mesh.m_F[dest_fi++] = mesh.m_F[fi];
}
}
while (fi<F_count)
{
mesh.m_F[dest_fi++] = mesh.m_F[fi++];
}
mesh.m_F.SetCount(dest_fi);
if ( bHasFaceNormals )
{
bfi = 1;
dest_fi = bad_fi[0];
for ( fi = dest_fi+1; fi < F_count && bfi < bad_fi_count; fi++ )
{
if ( fi == bad_fi[bfi] )
{
bfi++;
}
else
{
mesh.m_FN[dest_fi++] = mesh.m_FN[fi];
}
}
while (fi<F_count)
{
mesh.m_FN[dest_fi++] = mesh.m_FN[fi++];
}
mesh.m_FN.SetCount(dest_fi);
}
}
mesh.Compact();
mesh.DestroyTopology();
mesh.DestroyPartition();
return true;
}
/*Traces the translator stack on the given underlying node until it
finds the first translator called `name` and returns the port
pointing to the translator sitting under this one.*/
error_t
trace_find
(mach_port_t underlying, const char *name, int flags, mach_port_t * port)
{
error_t err = 0;
/*Identity information about the current process */
uid_t *uids;
size_t nuids;
gid_t *gids;
size_t ngids;
/*The name and arguments of the translator being passed now */
char *argz = NULL;
size_t argz_len = 0;
/*The current working directory */
char *cwd = NULL;
/*The port to the directory containing the file pointed to by `underlying` */
file_t dir;
/*The unauthenticated version of `dir` */
file_t unauth_dir;
/*The control port of the current translator */
fsys_t fsys;
/*The port to the translator we are currently looking at */
mach_port_t node = underlying;
/*The port to the previous translator */
mach_port_t prev_node = MACH_PORT_NULL;
/*The retry name and retry type returned by fsys_getroot */
string_t retry_name;
retry_type retry;
/*Finalizes the execution of this function */
void finalize (void)
{
/*If there is a working directory, free it */
if (cwd)
free (cwd);
/*If the ports to the directory exist */
if (dir)
PORT_DEALLOC (dir);
} /*finalize */
/*Obtain the current working directory */
cwd = getcwd (NULL, 0);
if (!cwd)
{
LOG_MSG ("trace_find: Could not obtain cwd.");
return EINVAL;
}
LOG_MSG ("trace_find: cwd: '%s'", cwd);
/*Open a port to this directory */
dir = file_name_lookup (cwd, 0, 0);
if (!dir)
{
finalize ();
return ENOENT;
}
/*Try to get the number of effective UIDs */
nuids = geteuids (0, 0);
if (nuids < 0)
{
finalize ();
return EINVAL;
}
/*Allocate some memory for the UIDs on the stack */
uids = alloca (nuids * sizeof (uid_t));
/*Fetch the UIDs themselves */
nuids = geteuids (nuids, uids);
if (nuids < 0)
{
finalize ();
return EINVAL;
}
/*Try to get the number of effective GIDs */
ngids = getgroups (0, 0);
if (ngids < 0)
{
finalize ();
return EINVAL;
}
/*Allocate some memory for the GIDs on the stack */
gids = alloca (ngids * sizeof (gid_t));
/*Fetch the GIDs themselves */
ngids = getgroups (ngids, gids);
if (ngids < 0)
{
finalize ();
return EINVAL;
}
/*Obtain the unauthenticated version of `dir` */
err = io_restrict_auth (dir, &unauth_dir, 0, 0, 0, 0);
if (err)
{
finalize ();
return err;
}
char buf[256];
char *_buf = buf;
size_t len = 256;
io_read (node, &_buf, &len, 0, len);
LOG_MSG ("trace_find: Read from underlying: '%s'", buf);
/*Go up the translator stack */
for (; !err;)
{
/*retreive the name and options of the current translator */
err = file_get_fs_options (node, &argz, &argz_len);
if (err)
break;
LOG_MSG ("trace_find: Obtained translator '%s'", argz);
if (strcmp (argz, name) == 0)
{
LOG_MSG ("trace_find: Match. Stopping here.");
break;
}
/*try to fetch the control port for this translator */
err = file_get_translator_cntl (node, &fsys);
LOG_MSG ("trace_find: err = %d", (int) err);
if (err)
break;
LOG_MSG ("trace_find: Translator control port: %lu",
(unsigned long) fsys);
prev_node = node;
/*fetch the root of the translator */
err = fsys_getroot
(fsys, unauth_dir, MACH_MSG_TYPE_COPY_SEND,
uids, nuids, gids, ngids,
flags | O_NOTRANS, &retry, retry_name, &node);
LOG_MSG ("trace_find: fsys_getroot returned %d", (int) err);
LOG_MSG ("trace_find: Translator root: %lu", (unsigned long) node);
/*TODO: Remove this debug output. */
/*char buf[256];
char * _buf = buf;
size_t len = 256;
io_read(node, &_buf, &len, 0, len);
LOG_MSG("trace_find: Read: '%s'", buf); */
}
/*If the error occurred (most probably) because of the fact that we
have reached the top of the translator stack */
if ((err == EMACH_SEND_INVALID_DEST) || (err == ENXIO))
/*this is OK */
err = 0;
/*Return the port to read from */
*port = prev_node;
/*Return the result of operations */
finalize ();
return err;
} /*trace_find */
/* Function to display source in the source window. */
enum tui_status
tui_set_source_content(struct symtab *s, int line_no, int noerror)
{
enum tui_status ret = TUI_FAILURE;
if ((s != (struct symtab *)NULL) && (s->filename != (char *)NULL))
{
FILE *stream;
int i, desc, c, line_width, nlines;
char *src_line = (char *)0;
if ((ret = tui_alloc_source_buffer(TUI_SRC_WIN)) == TUI_SUCCESS)
{
line_width = (TUI_SRC_WIN->generic.width - 1);
/* Take hilite (window border) into account, when calculating
the number of lines */
nlines = ((line_no + (TUI_SRC_WIN->generic.height - 2)) - line_no);
desc = open_source_file(s);
if (desc < 0)
{
if (!noerror)
{
size_t namelen = (strlen(s->filename) + 100UL);
char *name = (char *)alloca(namelen);
snprintf(name, namelen, "%s:%d", s->filename, line_no);
print_sys_errmsg(name, errno);
}
ret = TUI_FAILURE;
}
else
{
if (s->line_charpos == 0)
find_source_lines(s, desc);
if ((line_no < 1) || (line_no > s->nlines))
{
close(desc);
printf_unfiltered("Line number %d out of range; %s has %d lines.\n",
line_no, s->filename, s->nlines);
}
else if (lseek(desc, s->line_charpos[line_no - 1], 0) < 0)
{
close(desc);
perror_with_name(s->filename);
}
else
{
int offset, cur_line_no, cur_line, cur_len, threshold;
struct tui_gen_win_info *locator = tui_locator_win_info_ptr();
struct tui_source_info *src = &TUI_SRC_WIN->detail.source_info;
size_t src_line_len = 1UL;
if (TUI_SRC_WIN->generic.title)
xfree(TUI_SRC_WIN->generic.title);
TUI_SRC_WIN->generic.title = xstrdup(s->filename);
if (src->filename)
xfree(src->filename);
src->filename = xstrdup(s->filename);
/* Determine the threshold for the length of the line
and the offset to start the display. */
offset = src->horizontal_offset;
threshold = ((line_width - 1) + offset);
stream = fdopen(desc, FOPEN_RT);
clearerr(stream);
cur_line = 0;
cur_line_no = src->start_line_or_addr.line_no = line_no;
if (offset > 0)
{
src_line_len = ((threshold + 1UL) * sizeof(char));
src_line = (char *)xmalloc(src_line_len);
}
while (cur_line < nlines)
{
struct tui_win_element *element =
((struct tui_win_element *)
TUI_SRC_WIN->generic.content[cur_line]);
/* get the first character in the line: */
c = fgetc(stream);
if (offset == 0)
{
src_line =
((struct tui_win_element *)
TUI_SRC_WIN->generic.content[cur_line])->which_element.source.line;
src_line_len = strlen(src_line);
}
/* Init the line with the line number: */
snprintf(src_line, src_line_len, "%-6d", cur_line_no);
cur_len = strlen(src_line);
i = (cur_len
- ((cur_len / tui_default_tab_len())
* tui_default_tab_len()));
while (i < tui_default_tab_len())
{
src_line[cur_len] = ' ';
i++;
cur_len++;
}
src_line[cur_len] = (char)0;
/* Set whether element is the execution point and
whether there is a break point on it. */
element->which_element.source.line_or_addr.line_no =
cur_line_no;
element->which_element.source.is_exec_point =
(strcmp(((struct tui_win_element *)
locator->content[0])->which_element.locator.file_name,
s->filename) == 0
&& cur_line_no == ((struct tui_win_element *)
locator->content[0])->which_element.locator.line_no);
if (c != EOF)
{
i = (strlen(src_line) - 1UL);
do {
if ((c != '\n') && (c != '\r')
&& (++i < threshold))
{
if ((c < 040) && (c != '\t'))
{
src_line[i++] = '^';
src_line[i] = (c + 0100);
}
else if (c == 0177)
{
src_line[i++] = '^';
src_line[i] = '?';
}
else
{ /* Store the charcter in the line
* buffer. If it is a tab, then
* translate to the correct number of
* chars so we do NOT overwrite our
* buffer. */
if (c == '\t')
{
int j;
int max_tab_len = tui_default_tab_len();
for (j = (i - ((i / max_tab_len) * max_tab_len));
((j < max_tab_len) &&
(i < threshold));
i++, j++)
src_line[i] = ' ';
i--;
}
else
src_line[i] = c;
}
src_line[i + 1] = 0;
}
else
{ /* If we have not reached EOL, then eat
* chars until we do: */
while ((c != EOF) && (c != '\n')
&& (c != '\r'))
c = fgetc(stream);
}
} while ((c != EOF) && (c != '\n') && (c != '\r')
&& (i < threshold)
&& (c = fgetc(stream)));
}
/* Now copy the line taking the offset into account */
if (strlen(src_line) > (size_t)offset)
strcpy(((struct tui_win_element *)
TUI_SRC_WIN->generic.content[cur_line])->which_element.source.line,
&src_line[offset]);
else
((struct tui_win_element *)
TUI_SRC_WIN->generic.content[cur_line])->which_element.source.line[0] = (char)0;
cur_line++;
cur_line_no++;
}
if (offset > 0)
xfree(src_line);
fclose(stream);
TUI_SRC_WIN->generic.content_size = nlines;
ret = TUI_SUCCESS;
}
}
}
}
return ret;
}
char* crypt_sha512_r(const char *key, const char *salt, size_t rounds,
char *buffer, int buflen)
{
uint8_t alt_result[64], temp_result[64];
sha4_context ctx, alt_ctx;
size_t salt_len, key_len, cnt;
char *cp, *copied_key, *copied_salt, *p_bytes, *s_bytes;
copied_key = NULL;
copied_salt = NULL;
salt_len = MIN(strcspn(salt, "$"), SALT_LEN_MAX);
key_len = strlen(key);
/* Prepare for the real work. */
sha4_starts(&ctx, 0);
/* Add the key string. */
sha4_update(&ctx, (unsigned char*)key, key_len);
/* The last part is the salt string. This must be at most 8
* characters and it ends at the first `$' character (for
* compatibility with existing implementations). */
sha4_update(&ctx, (unsigned char*)salt, salt_len);
/* Compute alternate SHA512 sum with input KEY, SALT, and KEY. The
* final result will be added to the first context. */
sha4_starts(&alt_ctx, 0);
/* Add key. */
sha4_update(&alt_ctx, (unsigned char*)key, key_len);
/* Add salt. */
sha4_update(&alt_ctx, (unsigned char*)salt, salt_len);
/* Add key again. */
sha4_update(&alt_ctx, (unsigned char*)key, key_len);
/* Now get result of this (64 bytes) and add it to the other context. */
sha4_finish(&alt_ctx, alt_result);
/* Add for any character in the key one byte of the alternate sum. */
for (cnt = key_len; cnt > 64; cnt -= 64)
sha4_update(&ctx, (unsigned char*)alt_result, 64);
sha4_update(&ctx, (unsigned char*)alt_result, cnt);
/* Take the binary representation of the length of the key and for
* every 1 add the alternate sum, for every 0 the key. */
for (cnt = key_len; cnt > 0; cnt >>= 1)
if ((cnt & 1) != 0)
sha4_update(&ctx, (unsigned char*)alt_result, 64);
else
sha4_update(&ctx, (unsigned char*)key, key_len);
/* Create intermediate result. */
sha4_finish(&ctx, alt_result);
/* Start computation of P byte sequence. */
sha4_starts(&alt_ctx, 0);
/* For every character in the password add the entire password. */
for (cnt = 0; cnt < key_len; ++cnt)
sha4_update(&alt_ctx, (unsigned char*)key, key_len);
/* Finish the digest. */
sha4_finish(&alt_ctx, temp_result);
/* Create byte sequence P. */
cp = p_bytes = alloca(key_len);
for (cnt = key_len; cnt >= 64; cnt -= 64)
{
memcpy(cp, temp_result, 64);
cp += 64;
}
memcpy(cp, temp_result, cnt);
/* Start computation of S byte sequence. */
sha4_starts(&alt_ctx, 0);
/* For every character in the password add the entire password. */
for (cnt = 0; cnt < 16 + alt_result[0]; ++cnt)
sha4_update(&alt_ctx, (unsigned char*)salt, salt_len);
/* Finish the digest. */
sha4_finish(&alt_ctx, temp_result);
/* Create byte sequence S. */
cp = s_bytes = alloca(salt_len);
for (cnt = salt_len; cnt >= 64; cnt -= 64)
{
memcpy(cp, temp_result, 64);
cp += 64;
}
memcpy(cp, temp_result, cnt);
/* Repeatedly run the collected hash value through SHA512 to burn CPU
* cycles. */
for (cnt = 0; cnt < rounds; ++cnt)
{
/* New context. */
sha4_starts(&ctx, 0);
/* Add key or last result. */
if ((cnt & 1) != 0)
sha4_update(&ctx, (unsigned char*)p_bytes, key_len);
else
sha4_update(&ctx, (unsigned char*)alt_result, 64);
/* Add salt for numbers not divisible by 3. */
if (cnt % 3 != 0)
sha4_update(&ctx, (unsigned char*)s_bytes, salt_len);
/* Add key for numbers not divisible by 7. */
if (cnt % 7 != 0)
sha4_update(&ctx, (unsigned char*)p_bytes, key_len);
/* Add key or last result. */
if ((cnt & 1) != 0)
sha4_update(&ctx, (unsigned char*)alt_result, 64);
else
sha4_update(&ctx, (unsigned char*)p_bytes, key_len);
/* Create intermediate result. */
sha4_finish(&ctx, alt_result);
}
cp = buffer;
b64_from_24bit(alt_result[0], alt_result[21], alt_result[42], 4,
&buflen, &cp);
b64_from_24bit(alt_result[22], alt_result[43], alt_result[1], 4,
&buflen, &cp);
b64_from_24bit(alt_result[44], alt_result[2], alt_result[23], 4,
&buflen, &cp);
b64_from_24bit(alt_result[3], alt_result[24], alt_result[45], 4,
&buflen, &cp);
b64_from_24bit(alt_result[25], alt_result[46], alt_result[4], 4,
&buflen, &cp);
b64_from_24bit(alt_result[47], alt_result[5], alt_result[26], 4,
&buflen, &cp);
b64_from_24bit(alt_result[6], alt_result[27], alt_result[48], 4,
&buflen, &cp);
b64_from_24bit(alt_result[28], alt_result[49], alt_result[7], 4,
&buflen, &cp);
b64_from_24bit(alt_result[50], alt_result[8], alt_result[29], 4,
&buflen, &cp);
b64_from_24bit(alt_result[9], alt_result[30], alt_result[51], 4,
&buflen, &cp);
b64_from_24bit(alt_result[31], alt_result[52], alt_result[10], 4,
&buflen, &cp);
b64_from_24bit(alt_result[53], alt_result[11], alt_result[32], 4,
&buflen, &cp);
b64_from_24bit(alt_result[12], alt_result[33], alt_result[54], 4,
&buflen, &cp);
b64_from_24bit(alt_result[34], alt_result[55], alt_result[13], 4,
&buflen, &cp);
b64_from_24bit(alt_result[56], alt_result[14], alt_result[35], 4,
&buflen, &cp);
b64_from_24bit(alt_result[15], alt_result[36], alt_result[57], 4,
&buflen, &cp);
b64_from_24bit(alt_result[37], alt_result[58], alt_result[16], 4,
&buflen, &cp);
b64_from_24bit(alt_result[59], alt_result[17], alt_result[38], 4,
&buflen, &cp);
b64_from_24bit(alt_result[18], alt_result[39], alt_result[60], 4,
&buflen, &cp);
b64_from_24bit(alt_result[40], alt_result[61], alt_result[19], 4,
&buflen, &cp);
b64_from_24bit(alt_result[62], alt_result[20], alt_result[41], 4,
&buflen, &cp);
b64_from_24bit(0, 0, alt_result[63], 2, &buflen, &cp);
if (buflen <= 0)
{
errno = ERANGE;
buffer = NULL;
}
else
*cp = '\0';
return buffer;
}
int
fchownat (int fd, const char *file, uid_t owner, gid_t group, int flag)
{
if (flag & ~AT_SYMLINK_NOFOLLOW)
{
__set_errno (EINVAL);
return -1;
}
char *buf = NULL;
if (fd != AT_FDCWD && file[0] != '/')
{
size_t filelen = strlen (file);
static const char procfd[] = "/proc/self/fd/%d/%s";
/* Buffer for the path name we are going to use. It consists of
- the string /proc/self/fd/
- the file descriptor number
- the file name provided.
The final NUL is included in the sizeof. A bit of overhead
due to the format elements compensates for possible negative
numbers. */
size_t buflen = sizeof (procfd) + sizeof (int) * 3 + filelen;
buf = alloca (buflen);
__snprintf (buf, buflen, procfd, fd, file);
file = buf;
}
int result;
INTERNAL_SYSCALL_DECL (err);
#if __ASSUME_LCHOWN_SYSCALL
if (flag & AT_SYMLINK_NOFOLLOW)
result = INTERNAL_SYSCALL (lchown, err, 3, file, owner, group);
else
result = INTERNAL_SYSCALL (chown, err, 3, file, owner, group);
#else
char link[PATH_MAX + 2];
char path[2 * PATH_MAX + 4];
int loopct;
size_t filelen;
static int libc_old_chown = 0 /* -1=old linux, 1=new linux, 0=unknown */;
if (libc_old_chown == 1)
{
if (flag & AT_SYMLINK_NOFOLLOW)
result = INTERNAL_SYSCALL (lchown, err, 3, __ptrvalue (file), owner,
group);
else
result = INTERNAL_SYSCALL (chown, err, 3, __ptrvalue (file), owner,
group);
goto out;
}
# ifdef __NR_lchown
if (flag & AT_SYMLINK_NOFOLLOW)
{
result = INTERNAL_SYSCALL (lchown, err, 3, __ptrvalue (file), owner,
group);
goto out;
}
if (libc_old_chown == 0)
{
result = INTERNAL_SYSCALL (chown, err, 3, __ptrvalue (file), owner,
group);
if (__builtin_expect (!INTERNAL_SYSCALL_ERROR_P (result, err), 1))
return result;
if (INTERNAL_SYSCALL_ERRNO (result, err) != ENOSYS)
{
libc_old_chown = 1;
goto fail;
}
libc_old_chown = -1;
}
# else
if (flag & AT_SYMLINK_NOFOLLOW)
{
result = INTERNAL_SYSCALL (chown, err, 3, __ptrvalue (file), owner,
group);
goto out;
}
# endif
result = __readlink (file, link, PATH_MAX + 1);
if (result == -1)
{
# ifdef __NR_lchown
result = INTERNAL_SYSCALL (lchown, err, 3, __ptrvalue (file), owner,
group);
# else
result = INTERNAL_SYSCALL (chown, err, 3, __ptrvalue (file), owner,
group);
# endif
goto out;
}
filelen = strlen (file) + 1;
if (filelen > sizeof (path))
{
errno = ENAMETOOLONG;
return -1;
}
memcpy (path, file, filelen);
/* 'The system has an arbitrary limit...' In practise, we'll hit
ENAMETOOLONG before this, usually. */
for (loopct = 0; loopct < 128; ++loopct)
{
size_t linklen;
if (result >= PATH_MAX + 1)
{
errno = ENAMETOOLONG;
return -1;
}
link[result] = 0; /* Null-terminate string, just-in-case. */
linklen = strlen (link) + 1;
if (link[0] == '/')
memcpy (path, link, linklen);
else
{
filelen = strlen (path);
while (filelen > 1 && path[filelen - 1] == '/')
--filelen;
while (filelen > 0 && path[filelen - 1] != '/')
--filelen;
if (filelen + linklen > sizeof (path))
{
errno = ENAMETOOLONG;
return -1;
}
memcpy (path + filelen, link, linklen);
}
result = __readlink (path, link, PATH_MAX + 1);
if (result == -1)
{
# ifdef __NR_lchown
result = INTERNAL_SYSCALL (lchown, err, 3, path, owner, group);
# else
result = INTERNAL_SYSCALL (chown, err, 3, path, owner, group);
# endif
goto out;
}
}
__set_errno (ELOOP);
return -1;
out:
#endif
if (__builtin_expect (INTERNAL_SYSCALL_ERROR_P (result, err), 0))
{
#if !__ASSUME_LCHOWN_SYSCALL
fail:
#endif
__atfct_seterrno (INTERNAL_SYSCALL_ERRNO (result, err), fd, buf);
result = -1;
}
return result;
}
void
test_writesame10_0blocks(void)
{
int ret;
unsigned char *buf = alloca(block_size);
CHECK_FOR_DATALOSS;
CHECK_FOR_SBC;
if (num_blocks >= 0x80000000) {
CU_PASS("LUN is too big for write-beyond-eol tests with WRITESAME10. Skipping test.\n");
return;
}
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test WRITESAME10 0-blocks at LBA==0 (WSNZ=%d)",
inq_bl->wsnz);
memset(buf, 0, block_size);
if (inq_bl->wsnz) {
ret = writesame10(sd, 0,
block_size, 0, 0, 0, 0, 0, buf,
EXPECT_INVALID_FIELD_IN_CDB);
logging(LOG_NORMAL, "[SKIPPED] WRITESAME16 does not support 0-blocks.");
CU_ASSERT_EQUAL(ret, 0);
return;
}
ret = writesame10(sd, 0,
block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
if (ret == -2) {
CU_PASS("[SKIPPED] Target does not support WRITESAME10. Skipping test");
return;
} else if (ret == -3) {
CU_PASS("[SKIPPED] Target does not support WRITESAME10 with NUMBER OF LOGICAL BLOCKS == 0");
} else if (ret == -4) {
CU_PASS("[SKIPPED] Number of WRITESAME10 logical blocks to be written exceeds MAXIMUM WRITE SAME LENGTH");
} else {
CU_ASSERT_EQUAL(ret, 0);
}
logging(LOG_VERBOSE, "Test WRITESAME10 0-blocks one block past end-of-LUN");
ret = writesame10(sd, num_blocks + 1,
block_size, 0, 0, 0, 0, 0, buf,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
logging(LOG_VERBOSE, "Test WRITESAME10 0-blocks at LBA==2^31");
ret = writesame10(sd, 0x80000000,
block_size, 0, 0, 0, 0, 0, buf,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
logging(LOG_VERBOSE, "Test WRITESAME10 0-blocks at LBA==-1");
ret = writesame10(sd, -1,
block_size, 0, 0, 0, 0, 0, buf,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
}
EAPI void
e_alert_show(int sig)
{
char *args[4];
pid_t pid;
#define E_ALERT_EXE "/enlightenment/utils/enlightenment_alert"
args[0] = alloca(strlen(e_prefix_lib_get()) + strlen(E_ALERT_EXE) + 1);
strcpy(args[0], e_prefix_lib_get());
strcat(args[0], E_ALERT_EXE);
args[1] = alloca(10);
snprintf(args[1], 10, "%d", sig);
args[2] = alloca(21);
snprintf(args[2], 21, "%lu", (long unsigned int)getpid());
args[3] = alloca(21);
snprintf(args[3], 21, "%lu", e_alert_composite_win);
pid = fork();
if (pid < -1)
goto restart_e;
if (pid == 0)
{
/* The child process */
execvp(args[0], args);
}
else
{
/* The parent process */
pid_t ret;
int status = 0;
do
{
ret = waitpid(pid, &status, 0);
if (errno == ECHILD)
break ;
}
while (ret != pid);
if (status == 0)
goto restart_e;
if (!WIFEXITED(status))
goto restart_e;
if (WEXITSTATUS(status) == 1)
goto restart_e;
exit(-11);
}
restart_e:
if (getenv("E_START_MTRACK"))
e_util_env_set("MTRACK", "track");
ecore_app_restart();
}
static int AMXAPI amx_DGramIdle(AMX *amx, int AMXAPI Exec(AMX *, cell *, int))
{
char message[BUFLEN], source[SRC_BUFSIZE];
cell amx_addr_msg, amx_addr_src;
int len, chars;
int err=0;
assert(idxReceiveString >= 0 || idxReceivePacket >= 0);
if (PrevIdle != NULL)
PrevIdle(amx, Exec);
/* set up listener (first call only) */
if (!dgramBound) {
if (dgramPort==0)
dgramPort=AMX_DGRAMPORT; /* use default port if none was set */
if (udp_Listen(dgramPort)==-1)
return AMX_ERR_GENERAL;
dgramBound=1;
} /* if */
if (udp_IsPacket()) {
len=udp_Receive(message, sizeof message / sizeof message[0], source);
amx_PushString(amx,&amx_addr_src,NULL,source,1,0);
/* check the presence of a byte order mark: if it is absent, the received
* packet is no string; also check the packet size against string length
*/
if ((message[0]!='\xef' || message[1]!='\xbb' || message[2]!='\xbf'
|| len!=(int)strlen(message)+1 || idxReceiveString<0) && idxReceivePacket>=0)
{
/* receive as "packet" */
amx_Push(amx,len);
amx_PushArray(amx,&amx_addr_msg,NULL,(cell*)message,len);
err=Exec(amx,NULL,idxReceivePacket);
} else {
const char *msg=message;
if (msg[0]=='\xef' && msg[1]=='\xbb' && msg[2]=='\xbf')
msg+=3; /* skip BOM */
/* optionally convert from UTF-8 to a wide string */
if (amx_UTF8Check(msg,&chars)==AMX_ERR_NONE) {
cell *array=alloca((chars+1)*sizeof(cell));
cell *ptr=array;
if (array!=NULL) {
while (err==AMX_ERR_NONE && *msg!='\0')
amx_UTF8Get(msg,&msg,ptr++);
*ptr=0; /* zero-terminate */
amx_PushArray(amx,&amx_addr_msg,NULL,array,chars+1);
} /* if */
} else {
amx_PushString(amx,&amx_addr_msg,NULL,msg,1,0);
} /* if */
err=Exec(amx,NULL,idxReceiveString);
} /* if */
while (err==AMX_ERR_SLEEP)
err=Exec(amx,NULL,AMX_EXEC_CONT);
amx_Release(amx,amx_addr_msg);
amx_Release(amx,amx_addr_src);
} /* if */
return err;
}
/* Start a new process.
PROGRAM is a path to the program to execute.
ARGS is a standard NULL-terminated array of arguments,
to be passed to the inferior as ``argv''.
Returns the new PID on success, -1 on failure. Registers the new
process with the process list. */
static int
win32_create_inferior (char *program, char **program_args)
{
#ifndef USE_WIN32API
char real_path[PATH_MAX];
char *orig_path, *new_path, *path_ptr;
#endif
BOOL ret;
DWORD flags;
char *args;
int argslen;
int argc;
PROCESS_INFORMATION pi;
DWORD err;
/* win32_wait needs to know we're not attaching. */
attaching = 0;
if (!program)
error ("No executable specified, specify executable to debug.\n");
flags = DEBUG_PROCESS | DEBUG_ONLY_THIS_PROCESS;
#ifndef USE_WIN32API
orig_path = NULL;
path_ptr = getenv ("PATH");
if (path_ptr)
{
int size = cygwin_conv_path_list (CCP_POSIX_TO_WIN_A, path_ptr, NULL, 0);
orig_path = alloca (strlen (path_ptr) + 1);
new_path = alloca (size);
strcpy (orig_path, path_ptr);
cygwin_conv_path_list (CCP_POSIX_TO_WIN_A, path_ptr, new_path, size);
setenv ("PATH", new_path, 1);
}
cygwin_conv_path (CCP_POSIX_TO_WIN_A, program, real_path, PATH_MAX);
program = real_path;
#endif
argslen = 1;
for (argc = 1; program_args[argc]; argc++)
argslen += strlen (program_args[argc]) + 1;
args = alloca (argslen);
args[0] = '\0';
for (argc = 1; program_args[argc]; argc++)
{
/* FIXME: Can we do better about quoting? How does Cygwin
handle this? */
strcat (args, " ");
strcat (args, program_args[argc]);
}
OUTMSG2 (("Command line is \"%s\"\n", args));
#ifdef CREATE_NEW_PROCESS_GROUP
flags |= CREATE_NEW_PROCESS_GROUP;
#endif
ret = create_process (program, args, flags, &pi);
err = GetLastError ();
if (!ret && err == ERROR_FILE_NOT_FOUND)
{
char *exename = alloca (strlen (program) + 5);
strcat (strcpy (exename, program), ".exe");
ret = create_process (exename, args, flags, &pi);
err = GetLastError ();
}
#ifndef USE_WIN32API
if (orig_path)
setenv ("PATH", orig_path, 1);
#endif
if (!ret)
{
error ("Error creating process \"%s%s\", (error %d): %s\n",
program, args, (int) err, strwinerror (err));
}
else
{
OUTMSG2 (("Process created: %s\n", (char *) args));
}
#ifndef _WIN32_WCE
/* On Windows CE this handle can't be closed. The OS reuses
it in the debug events, while the 9x/NT versions of Windows
probably use a DuplicateHandle'd one. */
CloseHandle (pi.hThread);
#endif
do_initial_child_stuff (pi.hProcess, pi.dwProcessId, 0);
return current_process_id;
}
_clState *initCl(unsigned int gpu, char *name, size_t nameSize, algorithm_t *algorithm)
{
_clState *clState = (_clState *)calloc(1, sizeof(_clState));
struct cgpu_info *cgpu = &gpus[gpu];
cl_platform_id platform = NULL;
char pbuff[256];
build_kernel_data *build_data = (build_kernel_data *) alloca(sizeof(struct _build_kernel_data));
cl_uint preferred_vwidth;
cl_device_id *devices;
cl_uint numDevices;
cl_int status;
if (!get_opencl_platform(opt_platform_id, &platform)) {
return NULL;
}
numDevices = clDevicesNum();
if (numDevices <= 0 ) return NULL;
devices = (cl_device_id *)alloca(numDevices*sizeof(cl_device_id));
/* Now, get the device list data */
status = clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, numDevices, devices, NULL);
if (status != CL_SUCCESS) {
applog(LOG_ERR, "Error %d: Getting Device IDs (list)", status);
return NULL;
}
applog(LOG_INFO, "List of devices:");
unsigned int i;
for (i = 0; i < numDevices; i++) {
status = clGetDeviceInfo(devices[i], CL_DEVICE_NAME, sizeof(pbuff), pbuff, NULL);
if (status != CL_SUCCESS) {
applog(LOG_ERR, "Error %d: Getting Device Info", status);
return NULL;
}
applog(LOG_INFO, "\t%i\t%s", i, pbuff);
if (i == gpu) {
applog(LOG_INFO, "Selected %i: %s", gpu, pbuff);
strncpy(name, pbuff, nameSize);
}
}
if (gpu >= numDevices) {
applog(LOG_ERR, "Invalid GPU %i", gpu);
return NULL;
}
status = create_opencl_context(&clState->context, &platform);
if (status != CL_SUCCESS) {
applog(LOG_ERR, "Error %d: Creating Context. (clCreateContextFromType)", status);
return NULL;
}
status = create_opencl_command_queue(&clState->commandQueue, &clState->context, &devices[gpu], cgpu->algorithm.cq_properties);
if (status != CL_SUCCESS) {
applog(LOG_ERR, "Error %d: Creating Command Queue. (clCreateCommandQueue)", status);
return NULL;
}
clState->hasBitAlign = get_opencl_bit_align_support(&devices[gpu]);
status = clGetDeviceInfo(devices[gpu], CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT, sizeof(cl_uint), (void *)&preferred_vwidth, NULL);
if (status != CL_SUCCESS) {
applog(LOG_ERR, "Error %d: Failed to clGetDeviceInfo when trying to get CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT", status);
return NULL;
}
applog(LOG_DEBUG, "Preferred vector width reported %d", preferred_vwidth);
status = clGetDeviceInfo(devices[gpu], CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof(size_t), (void *)&clState->max_work_size, NULL);
if (status != CL_SUCCESS) {
applog(LOG_ERR, "Error %d: Failed to clGetDeviceInfo when trying to get CL_DEVICE_MAX_WORK_GROUP_SIZE", status);
return NULL;
}
applog(LOG_DEBUG, "Max work group size reported %d", (int)(clState->max_work_size));
size_t compute_units = 0;
status = clGetDeviceInfo(devices[gpu], CL_DEVICE_MAX_COMPUTE_UNITS, sizeof(size_t), (void *)&compute_units, NULL);
if (status != CL_SUCCESS) {
applog(LOG_ERR, "Error %d: Failed to clGetDeviceInfo when trying to get CL_DEVICE_MAX_COMPUTE_UNITS", status);
return NULL;
}
// AMD architechture got 64 compute shaders per compute unit.
// Source: http://www.amd.com/us/Documents/GCN_Architecture_whitepaper.pdf
clState->compute_shaders = compute_units * 64;
applog(LOG_DEBUG, "Max shaders calculated %d", (int)(clState->compute_shaders));
status = clGetDeviceInfo(devices[gpu], CL_DEVICE_MAX_MEM_ALLOC_SIZE , sizeof(cl_ulong), (void *)&cgpu->max_alloc, NULL);
if (status != CL_SUCCESS) {
applog(LOG_ERR, "Error %d: Failed to clGetDeviceInfo when trying to get CL_DEVICE_MAX_MEM_ALLOC_SIZE", status);
return NULL;
}
applog(LOG_DEBUG, "Max mem alloc size is %lu", (long unsigned int)(cgpu->max_alloc));
/* Create binary filename based on parameters passed to opencl
* compiler to ensure we only load a binary that matches what
* would have otherwise created. The filename is:
* name + g + lg + lookup_gap + tc + thread_concurrency + nf + nfactor + w + work_size + l + sizeof(long) + .bin
*/
char filename[255];
char strbuf[32];
sprintf(strbuf, "%s.cl", (!empty_string(cgpu->algorithm.kernelfile) ? cgpu->algorithm.kernelfile : cgpu->algorithm.name));
strcpy(filename, strbuf);
applog(LOG_DEBUG, "Using source file %s", filename);
/* For some reason 2 vectors is still better even if the card says
* otherwise, and many cards lie about their max so use 256 as max
* unless explicitly set on the command line. Tahiti prefers 1 */
if (strstr(name, "Tahiti"))
preferred_vwidth = 1;
else if (preferred_vwidth > 2)
preferred_vwidth = 2;
/* All available kernels only support vector 1 */
cgpu->vwidth = 1;
/* Vectors are hard-set to 1 above. */
if (likely(cgpu->vwidth))
clState->vwidth = cgpu->vwidth;
else {
clState->vwidth = preferred_vwidth;
cgpu->vwidth = preferred_vwidth;
}
clState->goffset = true;
if (cgpu->work_size && cgpu->work_size <= clState->max_work_size)
clState->wsize = cgpu->work_size;
else
clState->wsize = 256;
if (!cgpu->opt_lg) {
applog(LOG_DEBUG, "GPU %d: selecting lookup gap of 2", gpu);
cgpu->lookup_gap = 2;
} else
cgpu->lookup_gap = cgpu->opt_lg;
if ((strcmp(cgpu->algorithm.name, "zuikkis") == 0) && (cgpu->lookup_gap != 2)) {
applog(LOG_WARNING, "Kernel zuikkis only supports lookup-gap = 2 (currently %d), forcing.", cgpu->lookup_gap);
cgpu->lookup_gap = 2;
}
if ((strcmp(cgpu->algorithm.name, "bufius") == 0) && ((cgpu->lookup_gap != 2) && (cgpu->lookup_gap != 4) && (cgpu->lookup_gap != 8))) {
applog(LOG_WARNING, "Kernel bufius only supports lookup-gap of 2, 4 or 8 (currently %d), forcing to 2", cgpu->lookup_gap);
cgpu->lookup_gap = 2;
}
// neoscrypt calculates TC differently
if (!safe_cmp(cgpu->algorithm.name, "neoscrypt")) {
int max_int = ((cgpu->dynamic) ? MAX_INTENSITY : cgpu->intensity);
size_t glob_thread_count = 1UL << max_int;
// if TC is entered by user, use that value... otherwise use default
cgpu->thread_concurrency = ((cgpu->opt_tc) ? cgpu->opt_tc : ((glob_thread_count < cgpu->work_size) ? cgpu->work_size : glob_thread_count));
// if TC * scratchbuf size is too big for memory... reduce to max
if (((uint64_t)cgpu->thread_concurrency * NEOSCRYPT_SCRATCHBUF_SIZE) >(uint64_t)cgpu->max_alloc) {
/* Selected intensity will not run on this GPU. Not enough memory.
* Adapt the memory setting. */
glob_thread_count = cgpu->max_alloc / NEOSCRYPT_SCRATCHBUF_SIZE;
/* Find highest significant bit in glob_thread_count, which gives
* the intensity. */
while (max_int && ((1U << max_int) & glob_thread_count) == 0) {
--max_int;
}
/* Check if max_intensity is >0. */
if (max_int < MIN_INTENSITY) {
applog(LOG_ERR, "GPU %d: Max intensity is below minimum.", gpu);
max_int = MIN_INTENSITY;
}
cgpu->intensity = max_int;
cgpu->thread_concurrency = 1U << max_int;
}
applog(LOG_DEBUG, "GPU %d: computing max. global thread count to %u", gpu, (unsigned)(cgpu->thread_concurrency));
}
else if (!cgpu->opt_tc) {
unsigned int sixtyfours;
sixtyfours = cgpu->max_alloc / 131072 / 64 / (algorithm->n/1024) - 1;
cgpu->thread_concurrency = sixtyfours * 64;
if (cgpu->shaders && cgpu->thread_concurrency > cgpu->shaders) {
cgpu->thread_concurrency -= cgpu->thread_concurrency % cgpu->shaders;
if (cgpu->thread_concurrency > cgpu->shaders * 5) {
cgpu->thread_concurrency = cgpu->shaders * 5;
}
}
applog(LOG_DEBUG, "GPU %d: selecting thread concurrency of %d", gpu, (int)(cgpu->thread_concurrency));
}
else {
cgpu->thread_concurrency = cgpu->opt_tc;
}
cl_uint slot, cpnd;
slot = cpnd = 0;
build_data->context = clState->context;
build_data->device = &devices[gpu];
// Build information
strcpy(build_data->source_filename, filename);
strcpy(build_data->platform, name);
strcpy(build_data->sgminer_path, sgminer_path);
if (opt_kernel_path && *opt_kernel_path) {
build_data->kernel_path = opt_kernel_path;
}
else {
build_data->kernel_path = NULL;
}
build_data->work_size = clState->wsize;
build_data->has_bit_align = clState->hasBitAlign;
build_data->opencl_version = get_opencl_version(devices[gpu]);
build_data->patch_bfi = needs_bfi_patch(build_data);
strcpy(build_data->binary_filename, (!empty_string(cgpu->algorithm.kernelfile) ? cgpu->algorithm.kernelfile : cgpu->algorithm.name));
strcat(build_data->binary_filename, name);
if (clState->goffset)
strcat(build_data->binary_filename, "g");
set_base_compiler_options(build_data);
if (algorithm->set_compile_options)
algorithm->set_compile_options(build_data, cgpu, algorithm);
strcat(build_data->binary_filename, ".bin");
applog(LOG_DEBUG, "Using binary file %s", build_data->binary_filename);
// Load program from file or build it if it doesn't exist
if (!(clState->program = load_opencl_binary_kernel(build_data))) {
applog(LOG_NOTICE, "Building binary %s", build_data->binary_filename);
if (!(clState->program = build_opencl_kernel(build_data, filename)))
return NULL;
if (save_opencl_kernel(build_data, clState->program)) {
/* Program needs to be rebuilt, because the binary was patched */
if (build_data->patch_bfi) {
clReleaseProgram(clState->program);
clState->program = load_opencl_binary_kernel(build_data);
}
} else {
if (build_data->patch_bfi)
quit(1, "Could not save kernel to file, but it is necessary to apply BFI patch");
}
}
// Load kernels
applog(LOG_NOTICE, "Initialising kernel %s with%s bitalign, %spatched BFI, nfactor %d, n %d",
filename, clState->hasBitAlign ? "" : "out", build_data->patch_bfi ? "" : "un",
algorithm->nfactor, algorithm->n);
/* get a kernel object handle for a kernel with the given name */
clState->kernel = clCreateKernel(clState->program, "search", &status);
if (status != CL_SUCCESS) {
applog(LOG_ERR, "Error %d: Creating Kernel from program. (clCreateKernel)", status);
return NULL;
}
clState->n_extra_kernels = algorithm->n_extra_kernels;
if (clState->n_extra_kernels > 0) {
unsigned int i;
char kernel_name[9]; // max: search99 + 0x0
clState->extra_kernels = (cl_kernel *)malloc(sizeof(cl_kernel) * clState->n_extra_kernels);
for (i = 0; i < clState->n_extra_kernels; i++) {
snprintf(kernel_name, 9, "%s%d", "search", i + 1);
clState->extra_kernels[i] = clCreateKernel(clState->program, kernel_name, &status);
if (status != CL_SUCCESS) {
applog(LOG_ERR, "Error %d: Creating ExtraKernel #%d from program. (clCreateKernel)", status, i);
return NULL;
}
}
}
size_t bufsize;
size_t readbufsize = 128;
if (algorithm->rw_buffer_size < 0) {
// calc buffer size for neoscrypt
if (!safe_cmp(algorithm->name, "neoscrypt")) {
/* The scratch/pad-buffer needs 32kBytes memory per thread. */
bufsize = NEOSCRYPT_SCRATCHBUF_SIZE * cgpu->thread_concurrency;
/* This is the input buffer. For neoscrypt this is guaranteed to be
* 80 bytes only. */
readbufsize = 80;
applog(LOG_DEBUG, "Neoscrypt buffer sizes: %lu RW, %lu R", (unsigned long)bufsize, (unsigned long)readbufsize);
// scrypt/n-scrypt
}
else {
size_t ipt = (algorithm->n / cgpu->lookup_gap + (algorithm->n % cgpu->lookup_gap > 0));
bufsize = 128 * ipt * cgpu->thread_concurrency;
applog(LOG_DEBUG, "Scrypt buffer sizes: %lu RW, %lu R", (unsigned long)bufsize, (unsigned long)readbufsize);
}
}
else {
bufsize = (size_t)algorithm->rw_buffer_size;
applog(LOG_DEBUG, "Buffer sizes: %lu RW, %lu R", (unsigned long)bufsize, (unsigned long)readbufsize);
}
clState->padbuffer8 = NULL;
if (bufsize > 0) {
applog(LOG_DEBUG, "Creating read/write buffer sized %lu", (unsigned long)bufsize);
/* Use the max alloc value which has been rounded to a power of
* 2 greater >= required amount earlier */
if (bufsize > cgpu->max_alloc) {
applog(LOG_WARNING, "Maximum buffer memory device %d supports says %lu",
gpu, (unsigned long)(cgpu->max_alloc));
applog(LOG_WARNING, "Your settings come to %lu", (unsigned long)bufsize);
}
/* This buffer is weird and might work to some degree even if
* the create buffer call has apparently failed, so check if we
* get anything back before we call it a failure. */
clState->padbuffer8 = clCreateBuffer(clState->context, CL_MEM_READ_WRITE, bufsize, NULL, &status);
if (status != CL_SUCCESS && !clState->padbuffer8) {
applog(LOG_ERR, "Error %d: clCreateBuffer (padbuffer8), decrease TC or increase LG", status);
return NULL;
}
}
applog(LOG_DEBUG, "Using read buffer sized %lu", (unsigned long)readbufsize);
clState->CLbuffer0 = clCreateBuffer(clState->context, CL_MEM_READ_ONLY, readbufsize, NULL, &status);
if (status != CL_SUCCESS) {
applog(LOG_ERR, "Error %d: clCreateBuffer (CLbuffer0)", status);
return NULL;
}
applog(LOG_DEBUG, "Using output buffer sized %lu", BUFFERSIZE);
clState->outputBuffer = clCreateBuffer(clState->context, CL_MEM_WRITE_ONLY, BUFFERSIZE, NULL, &status);
if (status != CL_SUCCESS) {
applog(LOG_ERR, "Error %d: clCreateBuffer (outputBuffer)", status);
return NULL;
}
return clState;
}
int find_file_on_path(
char *dest,
int destlen,
const char *searchpath,
struct replace_table *repls,
int replslen)
{
int done = 0;
char *path, file[MAXFILENAME];
path = alloca(strlen(searchpath)+1);
strcpy(path, searchpath);
while (!done)
{
int res;
char *t;
/* find end of first filename */
t = strchr(path, ':');
if (t)
*t = 0;
else
done = 1;
/* do macro replace */
res = macro_expand_string(
file,
sizeof(file),
path,
repls,
replslen,
'%');
/* check the file access */
if (res != -1)
{
/* printf("DEBUG: trying file %s\n", file); */
if (access(file, R_OK) == 0)
{
struct stat st;
/* we hit one, check if it's a directory */
stat(file, &st);
if (!S_ISDIR(st.st_mode))
{
if (strlen(file) >= destlen)
{
/* buffer isn't big enough */
return -1;
}
else
{
/* it's big enough. hurrah! */
strcpy(dest, file);
return 0;
}
}
}
}
/* line up for next try */
path = t+1;
}
return -1;
}
_clState *initCl(unsigned int gpu, char *name, size_t nameSize)
{
_clState *clState = calloc(1, sizeof(_clState));
bool patchbfi = false, prog_built = false;
struct cgpu_info *cgpu = &gpus[gpu];
cl_platform_id platform = NULL;
char pbuff[256], vbuff[255];
cl_platform_id* platforms;
cl_uint preferred_vwidth;
cl_device_id *devices;
cl_uint numPlatforms;
cl_uint numDevices;
cl_int status;
status = clGetPlatformIDs(0, NULL, &numPlatforms);
if (status != CL_SUCCESS) {
applog(LOG_ERR, "Error %d: Getting Platforms. (clGetPlatformsIDs)", status);
return NULL;
}
platforms = (cl_platform_id *)alloca(numPlatforms*sizeof(cl_platform_id));
status = clGetPlatformIDs(numPlatforms, platforms, NULL);
if (status != CL_SUCCESS) {
applog(LOG_ERR, "Error %d: Getting Platform Ids. (clGetPlatformsIDs)", status);
return NULL;
}
if (opt_platform_id >= (int)numPlatforms) {
applog(LOG_ERR, "Specified platform that does not exist");
return NULL;
}
status = clGetPlatformInfo(platforms[opt_platform_id], CL_PLATFORM_VENDOR, sizeof(pbuff), pbuff, NULL);
if (status != CL_SUCCESS) {
applog(LOG_ERR, "Error %d: Getting Platform Info. (clGetPlatformInfo)", status);
return NULL;
}
platform = platforms[opt_platform_id];
if (platform == NULL) {
perror("NULL platform found!\n");
return NULL;
}
applog(LOG_INFO, "CL Platform vendor: %s", pbuff);
status = clGetPlatformInfo(platform, CL_PLATFORM_NAME, sizeof(pbuff), pbuff, NULL);
if (status == CL_SUCCESS)
applog(LOG_INFO, "CL Platform name: %s", pbuff);
status = clGetPlatformInfo(platform, CL_PLATFORM_VERSION, sizeof(vbuff), vbuff, NULL);
if (status == CL_SUCCESS)
applog(LOG_INFO, "CL Platform version: %s", vbuff);
status = clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 0, NULL, &numDevices);
if (status != CL_SUCCESS) {
applog(LOG_ERR, "Error %d: Getting Device IDs (num)", status);
return NULL;
}
if (numDevices > 0 ) {
devices = (cl_device_id *)malloc(numDevices*sizeof(cl_device_id));
/* Now, get the device list data */
status = clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, numDevices, devices, NULL);
if (status != CL_SUCCESS) {
applog(LOG_ERR, "Error %d: Getting Device IDs (list)", status);
return NULL;
}
applog(LOG_INFO, "List of devices:");
unsigned int i;
for (i = 0; i < numDevices; i++) {
status = clGetDeviceInfo(devices[i], CL_DEVICE_NAME, sizeof(pbuff), pbuff, NULL);
if (status != CL_SUCCESS) {
applog(LOG_ERR, "Error %d: Getting Device Info", status);
return NULL;
}
applog(LOG_INFO, "\t%i\t%s", i, pbuff);
}
if (gpu < numDevices) {
status = clGetDeviceInfo(devices[gpu], CL_DEVICE_NAME, sizeof(pbuff), pbuff, NULL);
if (status != CL_SUCCESS) {
applog(LOG_ERR, "Error %d: Getting Device Info", status);
return NULL;
}
applog(LOG_INFO, "Selected %i: %s", gpu, pbuff);
strncpy(name, pbuff, nameSize);
} else {
applog(LOG_ERR, "Invalid GPU %i", gpu);
return NULL;
}
} else return NULL;
cl_context_properties cps[3] = { CL_CONTEXT_PLATFORM, (cl_context_properties)platform, 0 };
clState->context = clCreateContextFromType(cps, CL_DEVICE_TYPE_GPU, NULL, NULL, &status);
if (status != CL_SUCCESS) {
applog(LOG_ERR, "Error %d: Creating Context. (clCreateContextFromType)", status);
return NULL;
}
/////////////////////////////////////////////////////////////////
// Create an OpenCL command queue
/////////////////////////////////////////////////////////////////
clState->commandQueue = clCreateCommandQueue(clState->context, devices[gpu],
CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, &status);
if (status != CL_SUCCESS) /* Try again without OOE enable */
clState->commandQueue = clCreateCommandQueue(clState->context, devices[gpu], 0 , &status);
if (status != CL_SUCCESS) {
applog(LOG_ERR, "Error %d: Creating Command Queue. (clCreateCommandQueue)", status);
return NULL;
}
/* Check for BFI INT support. Hopefully people don't mix devices with
* and without it! */
char * extensions = malloc(1024);
const char * camo = "cl_amd_media_ops";
char *find;
status = clGetDeviceInfo(devices[gpu], CL_DEVICE_EXTENSIONS, 1024, (void *)extensions, NULL);
if (status != CL_SUCCESS) {
applog(LOG_ERR, "Error %d: Failed to clGetDeviceInfo when trying to get CL_DEVICE_EXTENSIONS", status);
return NULL;
}
find = strstr(extensions, camo);
if (find)
clState->hasBitAlign = true;
/* Check for OpenCL >= 1.0 support, needed for global offset parameter usage. */
char * devoclver = malloc(1024);
const char * ocl10 = "OpenCL 1.0";
const char * ocl11 = "OpenCL 1.1";
status = clGetDeviceInfo(devices[gpu], CL_DEVICE_VERSION, 1024, (void *)devoclver, NULL);
if (status != CL_SUCCESS) {
applog(LOG_ERR, "Error %d: Failed to clGetDeviceInfo when trying to get CL_DEVICE_VERSION", status);
return NULL;
}
find = strstr(devoclver, ocl10);
if (!find) {
clState->hasOpenCL11plus = true;
find = strstr(devoclver, ocl11);
if (!find)
clState->hasOpenCL12plus = true;
}
status = clGetDeviceInfo(devices[gpu], CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT, sizeof(cl_uint), (void *)&preferred_vwidth, NULL);
if (status != CL_SUCCESS) {
applog(LOG_ERR, "Error %d: Failed to clGetDeviceInfo when trying to get CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT", status);
return NULL;
}
applog(LOG_DEBUG, "Preferred vector width reported %d", preferred_vwidth);
status = clGetDeviceInfo(devices[gpu], CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof(size_t), (void *)&clState->max_work_size, NULL);
if (status != CL_SUCCESS) {
applog(LOG_ERR, "Error %d: Failed to clGetDeviceInfo when trying to get CL_DEVICE_MAX_WORK_GROUP_SIZE", status);
return NULL;
}
applog(LOG_DEBUG, "Max work group size reported %d", (int)(clState->max_work_size));
status = clGetDeviceInfo(devices[gpu], CL_DEVICE_MAX_MEM_ALLOC_SIZE , sizeof(cl_ulong), (void *)&cgpu->max_alloc, NULL);
if (status != CL_SUCCESS) {
applog(LOG_ERR, "Error %d: Failed to clGetDeviceInfo when trying to get CL_DEVICE_MAX_MEM_ALLOC_SIZE", status);
return NULL;
}
applog(LOG_DEBUG, "Max mem alloc size is %lu", (long unsigned int)(cgpu->max_alloc));
/* Create binary filename based on parameters passed to opencl
* compiler to ensure we only load a binary that matches what would
* have otherwise created. The filename is:
* name + kernelname +/- g(offset) + v + vectors + w + work_size + l + sizeof(long) + .bin
* For scrypt the filename is:
* name + kernelname + g + lg + lookup_gap + tc + thread_concurrency + w + work_size + l + sizeof(long) + .bin
*/
char binaryfilename[255];
char filename[255];
char numbuf[16];
if (cgpu->kernel == KL_NONE) {
if (opt_scrypt) {
applog(LOG_INFO, "Selecting scrypt kernel");
clState->chosen_kernel = KL_SCRYPT;
} else if (opt_blake256) {
applog(LOG_INFO, "Selecting blake256 kernel");
clState->chosen_kernel = KL_BLAKE256;
} else if (!strstr(name, "Tahiti") &&
/* Detect all 2.6 SDKs not with Tahiti and use diablo kernel */
(strstr(vbuff, "844.4") || // Linux 64 bit ATI 2.6 SDK
strstr(vbuff, "851.4") || // Windows 64 bit ""
strstr(vbuff, "831.4") ||
strstr(vbuff, "898.1") || // 12.2 driver SDK
strstr(vbuff, "923.1") || // 12.4
strstr(vbuff, "938.2") || // SDK 2.7
strstr(vbuff, "1113.2"))) {// SDK 2.8
applog(LOG_INFO, "Selecting diablo kernel");
clState->chosen_kernel = KL_DIABLO;
/* Detect all 7970s, older ATI and NVIDIA and use poclbm */
} else if (strstr(name, "Tahiti") || !clState->hasBitAlign) {
applog(LOG_INFO, "Selecting poclbm kernel");
clState->chosen_kernel = KL_POCLBM;
/* Use phatk for the rest R5xxx R6xxx */
} else {
applog(LOG_INFO, "Selecting phatk kernel");
clState->chosen_kernel = KL_PHATK;
}
cgpu->kernel = clState->chosen_kernel;
} else {
clState->chosen_kernel = cgpu->kernel;
if (clState->chosen_kernel == KL_PHATK &&
(strstr(vbuff, "844.4") || strstr(vbuff, "851.4") ||
strstr(vbuff, "831.4") || strstr(vbuff, "898.1") ||
strstr(vbuff, "923.1") || strstr(vbuff, "938.2") ||
strstr(vbuff, "1113.2"))) {
applog(LOG_WARNING, "WARNING: You have selected the phatk kernel.");
applog(LOG_WARNING, "You are running SDK 2.6+ which performs poorly with this kernel.");
applog(LOG_WARNING, "Downgrade your SDK and delete any .bin files before starting again.");
applog(LOG_WARNING, "Or allow cgminer to automatically choose a more suitable kernel.");
}
}
/* For some reason 2 vectors is still better even if the card says
* otherwise, and many cards lie about their max so use 256 as max
* unless explicitly set on the command line. Tahiti prefers 1 */
if (strstr(name, "Tahiti"))
preferred_vwidth = 1;
else if (preferred_vwidth > 2)
preferred_vwidth = 2;
switch (clState->chosen_kernel) {
case KL_POCLBM:
strcpy(filename, POCLBM_KERNNAME".cl");
strcpy(binaryfilename, POCLBM_KERNNAME);
break;
case KL_PHATK:
strcpy(filename, PHATK_KERNNAME".cl");
strcpy(binaryfilename, PHATK_KERNNAME);
break;
case KL_DIAKGCN:
strcpy(filename, DIAKGCN_KERNNAME".cl");
strcpy(binaryfilename, DIAKGCN_KERNNAME);
break;
case KL_SCRYPT:
strcpy(filename, SCRYPT_KERNNAME".cl");
strcpy(binaryfilename, SCRYPT_KERNNAME);
/* Scrypt only supports vector 1 */
cgpu->vwidth = 1;
break;
case KL_BLAKE256:
strcpy(filename, BLAKE256_KERNNAME".cl");
strcpy(binaryfilename, BLAKE256_KERNNAME);
break;
case KL_NONE: /* Shouldn't happen */
case KL_DIABLO:
strcpy(filename, DIABLO_KERNNAME".cl");
strcpy(binaryfilename, DIABLO_KERNNAME);
break;
}
if (cgpu->vwidth)
clState->vwidth = cgpu->vwidth;
else {
clState->vwidth = preferred_vwidth;
cgpu->vwidth = preferred_vwidth;
}
if (((clState->chosen_kernel == KL_POCLBM || clState->chosen_kernel == KL_DIABLO || clState->chosen_kernel == KL_DIAKGCN) &&
clState->vwidth == 1 && clState->hasOpenCL11plus) || opt_scrypt || opt_blake256)
clState->goffset = true;
if (cgpu->work_size && cgpu->work_size <= clState->max_work_size)
clState->wsize = cgpu->work_size;
else if (opt_scrypt)
clState->wsize = 256;
else if (strstr(name, "Tahiti"))
clState->wsize = 64;
else
clState->wsize = (clState->max_work_size <= 256 ? clState->max_work_size : 256) / clState->vwidth;
cgpu->work_size = clState->wsize;
#ifdef USE_SCRYPT
if (opt_scrypt) {
if (!cgpu->opt_lg) {
applog(LOG_DEBUG, "GPU %d: selecting lookup gap of 2", gpu);
cgpu->lookup_gap = 2;
} else
cgpu->lookup_gap = cgpu->opt_lg;
if (!cgpu->opt_tc) {
unsigned int sixtyfours;
sixtyfours = cgpu->max_alloc / 131072 / 64 - 1;
cgpu->thread_concurrency = sixtyfours * 64;
if (cgpu->shaders && cgpu->thread_concurrency > cgpu->shaders) {
cgpu->thread_concurrency -= cgpu->thread_concurrency % cgpu->shaders;
if (cgpu->thread_concurrency > cgpu->shaders * 5)
cgpu->thread_concurrency = cgpu->shaders * 5;
}
applog(LOG_DEBUG, "GPU %d: selecting thread concurrency of %d", gpu, (int)(cgpu->thread_concurrency));
} else
cgpu->thread_concurrency = cgpu->opt_tc;
}
#endif
FILE *binaryfile;
size_t *binary_sizes;
char **binaries;
int pl;
char *source = file_contents(filename, &pl);
size_t sourceSize[] = {(size_t)pl};
cl_uint slot, cpnd;
slot = cpnd = 0;
if (!source)
return NULL;
binary_sizes = calloc(sizeof(size_t) * MAX_GPUDEVICES * 4, 1);
if (unlikely(!binary_sizes)) {
applog(LOG_ERR, "Unable to calloc binary_sizes");
return NULL;
}
binaries = calloc(sizeof(char *) * MAX_GPUDEVICES * 4, 1);
if (unlikely(!binaries)) {
applog(LOG_ERR, "Unable to calloc binaries");
return NULL;
}
strcat(binaryfilename, name);
if (clState->goffset)
strcat(binaryfilename, "g");
if (opt_scrypt) {
#ifdef USE_SCRYPT
sprintf(numbuf, "lg%utc%u", cgpu->lookup_gap, (unsigned int)cgpu->thread_concurrency);
strcat(binaryfilename, numbuf);
#endif
} else {
sprintf(numbuf, "v%d", clState->vwidth);
strcat(binaryfilename, numbuf);
}
sprintf(numbuf, "w%d", (int)clState->wsize);
strcat(binaryfilename, numbuf);
sprintf(numbuf, "l%d", (int)sizeof(long));
strcat(binaryfilename, numbuf);
strcat(binaryfilename, ".bin");
binaryfile = fopen(binaryfilename, "rb");
if (!binaryfile) {
applog(LOG_DEBUG, "No binary found, generating from source");
} else {
struct stat binary_stat;
if (unlikely(stat(binaryfilename, &binary_stat))) {
applog(LOG_DEBUG, "Unable to stat binary, generating from source");
fclose(binaryfile);
goto build;
}
if (!binary_stat.st_size)
goto build;
binary_sizes[slot] = binary_stat.st_size;
binaries[slot] = (char *)calloc(binary_sizes[slot], 1);
if (unlikely(!binaries[slot])) {
applog(LOG_ERR, "Unable to calloc binaries");
fclose(binaryfile);
return NULL;
}
if (fread(binaries[slot], 1, binary_sizes[slot], binaryfile) != binary_sizes[slot]) {
applog(LOG_ERR, "Unable to fread binaries");
fclose(binaryfile);
free(binaries[slot]);
goto build;
}
clState->program = clCreateProgramWithBinary(clState->context, 1, &devices[gpu], &binary_sizes[slot], (const unsigned char **)binaries, &status, NULL);
if (status != CL_SUCCESS) {
applog(LOG_ERR, "Error %d: Loading Binary into cl_program (clCreateProgramWithBinary)", status);
fclose(binaryfile);
free(binaries[slot]);
goto build;
}
fclose(binaryfile);
applog(LOG_DEBUG, "Loaded binary image %s", binaryfilename);
goto built;
}
/////////////////////////////////////////////////////////////////
// Load CL file, build CL program object, create CL kernel object
/////////////////////////////////////////////////////////////////
build:
clState->program = clCreateProgramWithSource(clState->context, 1, (const char **)&source, sourceSize, &status);
if (status != CL_SUCCESS) {
applog(LOG_ERR, "Error %d: Loading Binary into cl_program (clCreateProgramWithSource)", status);
return NULL;
}
/* create a cl program executable for all the devices specified */
char *CompilerOptions = calloc(1, 256);
#ifdef USE_SCRYPT
if (opt_scrypt)
sprintf(CompilerOptions, "-D LOOKUP_GAP=%d -D CONCURRENT_THREADS=%d -D WORKSIZE=%d",
cgpu->lookup_gap, (unsigned int)cgpu->thread_concurrency, (int)clState->wsize);
else
#endif
{
sprintf(CompilerOptions, "-D WORKSIZE=%d -D VECTORS%d -D WORKVEC=%d",
(int)clState->wsize, clState->vwidth, (int)clState->wsize * clState->vwidth);
}
applog(LOG_DEBUG, "Setting worksize to %d", (int)(clState->wsize));
if (clState->vwidth > 1)
applog(LOG_DEBUG, "Patched source to suit %d vectors", clState->vwidth);
if (clState->hasBitAlign) {
strcat(CompilerOptions, " -D BITALIGN");
applog(LOG_DEBUG, "cl_amd_media_ops found, setting BITALIGN");
if (!clState->hasOpenCL12plus &&
(strstr(name, "Cedar") ||
strstr(name, "Redwood") ||
strstr(name, "Juniper") ||
strstr(name, "Cypress" ) ||
strstr(name, "Hemlock" ) ||
strstr(name, "Caicos" ) ||
strstr(name, "Turks" ) ||
strstr(name, "Barts" ) ||
strstr(name, "Cayman" ) ||
strstr(name, "Antilles" ) ||
strstr(name, "Wrestler" ) ||
strstr(name, "Zacate" ) ||
strstr(name, "WinterPark" )))
patchbfi = true;
} else
applog(LOG_DEBUG, "cl_amd_media_ops not found, will not set BITALIGN");
if (patchbfi) {
strcat(CompilerOptions, " -D BFI_INT");
applog(LOG_DEBUG, "BFI_INT patch requiring device found, patched source with BFI_INT");
} else
applog(LOG_DEBUG, "BFI_INT patch requiring device not found, will not BFI_INT patch");
if (clState->goffset)
strcat(CompilerOptions, " -D GOFFSET");
if (!clState->hasOpenCL11plus)
strcat(CompilerOptions, " -D OCL1");
applog(LOG_DEBUG, "CompilerOptions: %s", CompilerOptions);
status = clBuildProgram(clState->program, 1, &devices[gpu], CompilerOptions , NULL, NULL);
free(CompilerOptions);
if (status != CL_SUCCESS) {
applog(LOG_ERR, "Error %d: Building Program (clBuildProgram)", status);
size_t logSize;
status = clGetProgramBuildInfo(clState->program, devices[gpu], CL_PROGRAM_BUILD_LOG, 0, NULL, &logSize);
char *log = malloc(logSize);
status = clGetProgramBuildInfo(clState->program, devices[gpu], CL_PROGRAM_BUILD_LOG, logSize, log, NULL);
applog(LOG_ERR, "%s", log);
return NULL;
}
prog_built = true;
#ifdef __APPLE__
/* OSX OpenCL breaks reading off binaries with >1 GPU so always build
* from source. */
goto built;
#endif
status = clGetProgramInfo(clState->program, CL_PROGRAM_NUM_DEVICES, sizeof(cl_uint), &cpnd, NULL);
if (unlikely(status != CL_SUCCESS)) {
applog(LOG_ERR, "Error %d: Getting program info CL_PROGRAM_NUM_DEVICES. (clGetProgramInfo)", status);
return NULL;
}
status = clGetProgramInfo(clState->program, CL_PROGRAM_BINARY_SIZES, sizeof(size_t)*cpnd, binary_sizes, NULL);
if (unlikely(status != CL_SUCCESS)) {
applog(LOG_ERR, "Error %d: Getting program info CL_PROGRAM_BINARY_SIZES. (clGetProgramInfo)", status);
return NULL;
}
/* The actual compiled binary ends up in a RANDOM slot! Grr, so we have
* to iterate over all the binary slots and find where the real program
* is. What the heck is this!? */
for (slot = 0; slot < cpnd; slot++)
if (binary_sizes[slot])
break;
/* copy over all of the generated binaries. */
applog(LOG_DEBUG, "Binary size for gpu %d found in binary slot %d: %d", gpu, slot, (int)(binary_sizes[slot]));
if (!binary_sizes[slot]) {
applog(LOG_ERR, "OpenCL compiler generated a zero sized binary, FAIL!");
return NULL;
}
binaries[slot] = calloc(sizeof(char) * binary_sizes[slot], 1);
status = clGetProgramInfo(clState->program, CL_PROGRAM_BINARIES, sizeof(char *) * cpnd, binaries, NULL );
if (unlikely(status != CL_SUCCESS)) {
applog(LOG_ERR, "Error %d: Getting program info. CL_PROGRAM_BINARIES (clGetProgramInfo)", status);
return NULL;
}
/* Patch the kernel if the hardware supports BFI_INT but it needs to
* be hacked in */
if (patchbfi) {
unsigned remaining = binary_sizes[slot];
char *w = binaries[slot];
unsigned int start, length;
/* Find 2nd incidence of .text, and copy the program's
* position and length at a fixed offset from that. Then go
* back and find the 2nd incidence of \x7ELF (rewind by one
* from ELF) and then patch the opcocdes */
if (!advance(&w, &remaining, ".text"))
goto build;
w++; remaining--;
if (!advance(&w, &remaining, ".text")) {
/* 32 bit builds only one ELF */
w--; remaining++;
}
memcpy(&start, w + 285, 4);
memcpy(&length, w + 289, 4);
w = binaries[slot]; remaining = binary_sizes[slot];
if (!advance(&w, &remaining, "ELF"))
goto build;
w++; remaining--;
if (!advance(&w, &remaining, "ELF")) {
/* 32 bit builds only one ELF */
w--; remaining++;
}
w--; remaining++;
w += start; remaining -= start;
applog(LOG_DEBUG, "At %p (%u rem. bytes), to begin patching",
w, remaining);
patch_opcodes(w, length);
status = clReleaseProgram(clState->program);
if (status != CL_SUCCESS) {
applog(LOG_ERR, "Error %d: Releasing program. (clReleaseProgram)", status);
return NULL;
}
clState->program = clCreateProgramWithBinary(clState->context, 1, &devices[gpu], &binary_sizes[slot], (const unsigned char **)&binaries[slot], &status, NULL);
if (status != CL_SUCCESS) {
applog(LOG_ERR, "Error %d: Loading Binary into cl_program (clCreateProgramWithBinary)", status);
return NULL;
}
/* Program needs to be rebuilt */
prog_built = false;
}
free(source);
/* Save the binary to be loaded next time */
binaryfile = fopen(binaryfilename, "wb");
if (!binaryfile) {
/* Not a fatal problem, just means we build it again next time */
applog(LOG_DEBUG, "Unable to create file %s", binaryfilename);
} else {
if (unlikely(fwrite(binaries[slot], 1, binary_sizes[slot], binaryfile) != binary_sizes[slot])) {
applog(LOG_ERR, "Unable to fwrite to binaryfile");
return NULL;
}
fclose(binaryfile);
}
built:
if (binaries[slot])
free(binaries[slot]);
free(binaries);
free(binary_sizes);
applog(LOG_INFO, "Initialising kernel %s with%s bitalign, %d vectors and worksize %d",
filename, clState->hasBitAlign ? "" : "out", clState->vwidth, (int)(clState->wsize));
if (!prog_built) {
/* create a cl program executable for all the devices specified */
status = clBuildProgram(clState->program, 1, &devices[gpu], NULL, NULL, NULL);
if (status != CL_SUCCESS) {
applog(LOG_ERR, "Error %d: Building Program (clBuildProgram)", status);
size_t logSize;
status = clGetProgramBuildInfo(clState->program, devices[gpu], CL_PROGRAM_BUILD_LOG, 0, NULL, &logSize);
char *log = malloc(logSize);
status = clGetProgramBuildInfo(clState->program, devices[gpu], CL_PROGRAM_BUILD_LOG, logSize, log, NULL);
applog(LOG_ERR, "%s", log);
return NULL;
}
}
/* get a kernel object handle for a kernel with the given name */
clState->kernel = clCreateKernel(clState->program, "search", &status);
if (status != CL_SUCCESS) {
applog(LOG_ERR, "Error %d: Creating Kernel from program. (clCreateKernel)", status);
return NULL;
}
#ifdef USE_SCRYPT
if (opt_scrypt) {
size_t ipt = (1024 / cgpu->lookup_gap + (1024 % cgpu->lookup_gap > 0));
size_t bufsize = 128 * ipt * cgpu->thread_concurrency;
/* Use the max alloc value which has been rounded to a power of
* 2 greater >= required amount earlier */
if (bufsize > cgpu->max_alloc) {
applog(LOG_WARNING, "Maximum buffer memory device %d supports says %lu",
gpu, (long unsigned int)(cgpu->max_alloc));
applog(LOG_WARNING, "Your scrypt settings come to %d", (int)bufsize);
}
applog(LOG_DEBUG, "Creating scrypt buffer sized %d", (int)bufsize);
clState->padbufsize = bufsize;
/* This buffer is weird and might work to some degree even if
* the create buffer call has apparently failed, so check if we
* get anything back before we call it a failure. */
clState->padbuffer8 = NULL;
clState->padbuffer8 = clCreateBuffer(clState->context, CL_MEM_READ_WRITE, bufsize, NULL, &status);
if (status != CL_SUCCESS && !clState->padbuffer8) {
applog(LOG_ERR, "Error %d: clCreateBuffer (padbuffer8), decrease TC or increase LG", status);
return NULL;
}
clState->CLbuffer0 = clCreateBuffer(clState->context, CL_MEM_READ_ONLY, 128, NULL, &status);
if (status != CL_SUCCESS) {
applog(LOG_ERR, "Error %d: clCreateBuffer (CLbuffer0)", status);
return NULL;
}
clState->outputBuffer = clCreateBuffer(clState->context, CL_MEM_WRITE_ONLY, SCRYPT_BUFFERSIZE, NULL, &status);
} else
#endif
if (opt_blake256) {
clState->CLbuffer0 = clCreateBuffer(clState->context, CL_MEM_READ_ONLY, 128, NULL, &status);
if (status != CL_SUCCESS) {
applog(LOG_ERR, "Error %d: clCreateBuffer (CLbuffer0)", status);
return NULL;
}
clState->outputBuffer = clCreateBuffer(clState->context, CL_MEM_WRITE_ONLY, SCRYPT_BUFFERSIZE, NULL, &status);
} else
clState->outputBuffer = clCreateBuffer(clState->context, CL_MEM_WRITE_ONLY, BUFFERSIZE, NULL, &status);
if (status != CL_SUCCESS) {
applog(LOG_ERR, "Error %d: clCreateBuffer (outputBuffer)", status);
return NULL;
}
return clState;
}
float vorbis_lpc_from_data(float *data,float *lpci,int n,int m){
double *aut=alloca(sizeof(*aut)*(m+1));
double *lpc=alloca(sizeof(*lpc)*(m));
double error;
double epsilon;
int i,j;
/* autocorrelation, p+1 lag coefficients */
j=m+1;
while(j--){
double d=0; /* double needed for accumulator depth */
for(i=j;i<n;i++)d+=(double)data[i]*data[i-j];
aut[j]=d;
}
/* Generate lpc coefficients from autocorr values */
/* set our noise floor to about -100dB */
error=aut[0] * (1. + 1e-10);
epsilon=1e-9*aut[0]+1e-10;
for(i=0;i<m;i++){
double r= -aut[i+1];
if(error<epsilon){
memset(lpc+i,0,(m-i)*sizeof(*lpc));
goto done;
}
/* Sum up this iteration's reflection coefficient; note that in
Vorbis we don't save it. If anyone wants to recycle this code
and needs reflection coefficients, save the results of 'r' from
each iteration. */
for(j=0;j<i;j++)r-=lpc[j]*aut[i-j];
r/=error;
/* Update LPC coefficients and total error */
lpc[i]=r;
for(j=0;j<i/2;j++){
double tmp=lpc[j];
lpc[j]+=r*lpc[i-1-j];
lpc[i-1-j]+=r*tmp;
}
if(i&1)lpc[j]+=lpc[j]*r;
error*=1.-r*r;
}
done:
/* slightly damp the filter */
{
double g = .99;
double damp = g;
for(j=0;j<m;j++){
lpc[j]*=damp;
damp*=g;
}
}
for(j=0;j<m;j++)lpci[j]=(float)lpc[j];
/* we need the error value to know how big an impulse to hit the
filter with later */
return error;
}
void W_AddFile (char *filename)
{
wadinfo_t header;
lumpinfo_t* lump_p;
unsigned i;
int handle;
int length;
int startlump;
filelump_t* fileinfo;
filelump_t singleinfo;
int storehandle;
// open the file and add to directory
// handle reload indicator.
if (filename[0] == '~')
{
filename++;
reloadname = filename;
reloadlump = numlumps;
}
if ( (handle = open (filename,O_RDONLY | O_BINARY)) == -1)
{
printf (" couldn't open %s\n",filename);
return;
}
printf (" adding %s\n",filename);
startlump = numlumps;
if (strcmpi (filename+strlen(filename)-3 , "wad" ) )
{
// single lump file
fileinfo = &singleinfo;
singleinfo.filepos = 0;
singleinfo.size = LONG(filelength(handle));
ExtractFileBase (filename, singleinfo.name);
numlumps++;
}
else
{
// WAD file
read (handle, &header, sizeof(header));
if (strncmp(header.identification,"IWAD",4))
{
// Homebrew levels?
if (strncmp(header.identification,"PWAD",4))
{
I_Error ("Wad file %s doesn't have IWAD "
"or PWAD id\n", filename);
}
// ???modifiedgame = true;
}
header.numlumps = LONG(header.numlumps);
header.infotableofs = LONG(header.infotableofs);
length = header.numlumps*sizeof(filelump_t);
fileinfo = alloca (length);
lseek (handle, header.infotableofs, SEEK_SET);
read (handle, fileinfo, length);
numlumps += header.numlumps;
}
// Fill in lumpinfo
lumpinfo = realloc (lumpinfo, numlumps*sizeof(lumpinfo_t));
if (!lumpinfo)
I_Error ("Couldn't realloc lumpinfo");
lump_p = &lumpinfo[startlump];
storehandle = reloadname ? -1 : handle;
for (i=startlump ; i<numlumps ; i++,lump_p++, fileinfo++)
{
lump_p->handle = storehandle;
lump_p->position = LONG(fileinfo->filepos);
lump_p->size = LONG(fileinfo->size);
strncpy (lump_p->name, fileinfo->name, 8);
}
if (reloadname)
close (handle);
}
int *xapoints, *xapp;
int *yapoints, *yapp;
DATA32 *buf, *src_data;
RGBA_Gfx_Func func, func2 = NULL;
src_data = src->image.data;
/* some maximum region sizes to avoid insane calc point tables */
SCALE_CALC_X_POINTS(xpoints, src_region_w, dst_region_w, dst_clip_x - dst_region_x, dst_clip_w);
SCALE_CALC_Y_POINTS(ypoints, src_data, src_w, src_region_h, dst_region_h, dst_clip_y - dst_region_y, dst_clip_h);
SCALE_CALC_A_POINTS(xapoints, src_region_w, dst_region_w, dst_clip_x - dst_region_x, dst_clip_w);
SCALE_CALC_A_POINTS(yapoints, src_region_h, dst_region_h, dst_clip_y - dst_region_y, dst_clip_h);
/* a scanline buffer */
buf = alloca(dst_clip_w * sizeof(DATA32));
if (!mask_ie)
{
if (mul_col != 0xffffffff)
func = evas_common_gfx_func_composite_pixel_color_span_get(src->cache_entry.flags.alpha, src->cache_entry.flags.alpha_sparse, mul_col, dst->cache_entry.flags.alpha, dst_clip_w, render_op);
else
func = evas_common_gfx_func_composite_pixel_span_get(src->cache_entry.flags.alpha, src->cache_entry.flags.alpha_sparse, dst->cache_entry.flags.alpha, dst_clip_w, render_op);
}
else
{
if (mul_col != 0xffffffff)
{
func = evas_common_gfx_func_composite_pixel_mask_span_get(src->cache_entry.flags.alpha, src->cache_entry.flags.alpha_sparse, dst->cache_entry.flags.alpha, dst_clip_w, render_op);
func2 = evas_common_gfx_func_composite_pixel_color_span_get(src->cache_entry.flags.alpha, src->cache_entry.flags.alpha_sparse, mul_col, dst->cache_entry.flags.alpha, dst_clip_w, EVAS_RENDER_COPY);
}
void __cdecl CJabberProto::FileServerThread(filetransfer *ft)
{
debugLogA("Thread started: type=file_send");
ThreadData info(this, NULL);
ft->type = FT_OOB;
NETLIBBIND nlb = { 0 };
nlb.cbSize = sizeof(NETLIBBIND);
nlb.pfnNewConnectionV2 = JabberFileServerConnection;
nlb.pExtra = this;
nlb.wPort = 0; // Use user-specified incoming port ranges, if available
info.s = (HANDLE)CallService(MS_NETLIB_BINDPORT, (WPARAM)m_hNetlibUser, (LPARAM)&nlb);
if (info.s == NULL) {
debugLogA("Cannot allocate port to bind for file server thread, thread ended.");
ProtoBroadcastAck(ft->std.hContact, ACKTYPE_FILE, ACKRESULT_FAILED, ft, 0);
delete ft;
return;
}
ft->s = info.s;
debugLogA("ft->s = %d", info.s);
HANDLE hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
ft->hFileEvent = hEvent;
TCHAR szPort[20];
mir_sntprintf(szPort, _T("%d"), nlb.wPort);
JABBER_LIST_ITEM *item = ListAdd(LIST_FILE, szPort);
item->ft = ft;
TCHAR *ptszResource = ListGetBestClientResourceNamePtr(ft->jid);
if (ptszResource != NULL) {
ft->state = FT_CONNECTING;
for (int i = 0; i < ft->std.totalFiles && ft->state != FT_ERROR && ft->state != FT_DENIED; i++) {
ft->std.currentFileNumber = i;
ft->state = FT_CONNECTING;
if (ft->httpPath) mir_free(ft->httpPath);
ft->httpPath = NULL;
TCHAR *p;
if ((p = _tcschr(ft->std.ptszFiles[i], '\\')) != NULL)
p++;
else
p = ft->std.ptszFiles[i];
ptrA pFileName(mir_urlEncode(T2Utf(p)));
if (pFileName != NULL) {
ft->szId = JabberId2string(SerialNext());
ptrA myAddr;
if (m_options.BsDirect && m_options.BsDirectManual)
myAddr = getStringA("BsDirectAddr");
if (myAddr == NULL)
myAddr = (char*)CallService(MS_NETLIB_ADDRESSTOSTRING, 1, nlb.dwExternalIP);
char szAddr[256];
mir_snprintf(szAddr, "http://%s:%d/%s", myAddr, nlb.wPort, pFileName);
size_t len = mir_tstrlen(ptszResource) + mir_tstrlen(ft->jid) + 2;
TCHAR *fulljid = (TCHAR *)alloca(sizeof(TCHAR) * len);
mir_sntprintf(fulljid, len, _T("%s/%s"), ft->jid, ptszResource);
XmlNodeIq iq(_T("set"), ft->szId, fulljid);
HXML query = iq << XQUERY(JABBER_FEAT_OOB);
query << XCHILD(_T("url"), _A2T(szAddr));
query << XCHILD(_T("desc"), ft->szDescription);
m_ThreadInfo->send(iq);
debugLogA("Waiting for the file to be sent...");
WaitForSingleObject(hEvent, INFINITE);
}
debugLogA("File sent, advancing to the next file...");
ProtoBroadcastAck(ft->std.hContact, ACKTYPE_FILE, ACKRESULT_NEXTFILE, ft, 0);
}
CloseHandle(hEvent);
ft->hFileEvent = NULL;
debugLogA("Finish all files");
}
ft->s = NULL;
debugLogA("ft->s is NULL");
ListRemove(LIST_FILE, szPort);
switch (ft->state) {
case FT_DONE:
debugLogA("Finish successfully");
ProtoBroadcastAck(ft->std.hContact, ACKTYPE_FILE, ACKRESULT_SUCCESS, ft, 0);
break;
case FT_DENIED:
ProtoBroadcastAck(ft->std.hContact, ACKTYPE_FILE, ACKRESULT_DENIED, ft, 0);
break;
default: // FT_ERROR:
debugLogA("Finish with errors");
ProtoBroadcastAck(ft->std.hContact, ACKTYPE_FILE, ACKRESULT_FAILED, ft, 0);
break;
}
debugLogA("Thread ended: type=file_send");
delete ft;
}
bool
gfc_convert_boz (gfc_expr *expr, gfc_typespec *ts)
{
size_t buffer_size, boz_bit_size, ts_bit_size;
int index;
unsigned char *buffer;
if (!expr->is_boz)
return true;
gcc_assert (expr->expr_type == EXPR_CONSTANT
&& expr->ts.type == BT_INTEGER);
/* Don't convert BOZ to logical, character, derived etc. */
if (ts->type == BT_REAL)
{
buffer_size = size_float (ts->kind);
ts_bit_size = buffer_size * 8;
}
else if (ts->type == BT_COMPLEX)
{
buffer_size = size_complex (ts->kind);
ts_bit_size = buffer_size * 8 / 2;
}
else
return true;
/* Convert BOZ to the smallest possible integer kind. */
boz_bit_size = mpz_sizeinbase (expr->value.integer, 2);
if (boz_bit_size > ts_bit_size)
{
gfc_error_now ("BOZ constant at %L is too large (%ld vs %ld bits)",
&expr->where, (long) boz_bit_size, (long) ts_bit_size);
return false;
}
for (index = 0; gfc_integer_kinds[index].kind != 0; ++index)
if ((unsigned) gfc_integer_kinds[index].bit_size >= ts_bit_size)
break;
expr->ts.kind = gfc_integer_kinds[index].kind;
buffer_size = MAX (buffer_size, size_integer (expr->ts.kind));
buffer = (unsigned char*)alloca (buffer_size);
encode_integer (expr->ts.kind, expr->value.integer, buffer, buffer_size);
mpz_clear (expr->value.integer);
if (ts->type == BT_REAL)
{
mpfr_init (expr->value.real);
gfc_interpret_float (ts->kind, buffer, buffer_size, expr->value.real);
}
else
{
mpc_init2 (expr->value.complex, mpfr_get_default_prec());
gfc_interpret_complex (ts->kind, buffer, buffer_size,
expr->value.complex);
}
expr->is_boz = 0;
expr->ts.type = ts->type;
expr->ts.kind = ts->kind;
return true;
}
