int
gx_forward_strip_copy_rop2(gx_device * dev, const byte * sdata, int sourcex,
uint sraster, gx_bitmap_id id,
const gx_color_index * scolors,
const gx_strip_bitmap * textures,
const gx_color_index * tcolors,
int x, int y, int width, int height,
int phase_x, int phase_y, gs_logical_operation_t lop,
uint planar_height)
{
gx_device_forward * const fdev = (gx_device_forward *)dev;
gx_device *tdev = fdev->target;
if (planar_height != 0) {
dev_proc_strip_copy_rop2((*proc2)) =
(tdev == 0 ? (tdev = dev, gx_default_strip_copy_rop2) :
dev_proc(tdev, strip_copy_rop2));
return proc2(tdev, sdata, sourcex, sraster, id, scolors,
textures, tcolors, x, y, width, height,
phase_x, phase_y, lop, planar_height);
} else {
dev_proc_strip_copy_rop((*proc)) =
(tdev == 0 ? (tdev = dev, gx_default_strip_copy_rop) :
dev_proc(tdev, strip_copy_rop));
return proc(tdev, sdata, sourcex, sraster, id, scolors,
textures, tcolors, x, y, width, height,
phase_x, phase_y, lop);
}
}
int main(int argc, char* argv[]) {
// Blokada wskazuje na 1 proces.
lock = 1;
boost::thread proc1(&process1);
boost::thread proc2(&process2);
proc1.join(); proc2.join();
return 0;
}
int main(int argc, char argv[]) {
int pid1, pid2;
int ret1 = 0;
int ret2 = 0;
//Semaphore
key_t cle;
int er;
/*
cle = ftok("/home/eleves/promo16/elec/fan/Documents/embeddedLinux/tp3/tp3_prog2.log",0);
if(cle == (key_t) -1) {
perror("erreur ftok\n");
exit(1);
}*/
int semid;
semid = semget(cle,2,IPC_CREAT|0666);
if(semid == -1) {
perror("erreur semget\n");
exit(1);
}
//Initialisation a 1 de notre semaphore (qui est le semaphore number 0 de l'ensemble)
union semun{
int val;
struct smid_ds *buf;
ushort *array;
} arg;
arg.val = 1;
er = semctl(semid,0,SETVAL,arg);
if (er == -1) {
perror("erreur semctl\n");
exit(1);
}
arg.val = 0;
er = semctl(semid,1,SETVAL,arg);
if (er == -1) {
perror("erreur semctl\n");
exit(1);
}
pid1 = fork();
if(pid1 == 0) proc1 (semid);
pid2 = fork();
if(pid2 == 0) proc2 (semid);
wait (&ret1); //Il attend que le thread finit son travail
wait (&ret2); //Il attend que le thread finit son travail
//Quand on a fini, on nettoye le semaphore
if (semctl(semid, 1, IPC_RMID ) == -1 )
{
perror("semctl failure while clearing Reason:");
exit(-1);
}
return 0;
}
int main(void)
{
int cnt = 0;
char eventa[4] = "ab\0";
char eventb[4] = "bcd\0";
char eventc[4] = "cde\0";
char eventd[4] = "d\0";
char *events[] = {eventa, eventb, eventc, eventd};
int rt, e0, e1, e2, e3;
int tab[4];
pid_t pid;
print_test_scenario();
pid = fork();
switch(pid) {
case 0:
proc2();
break;
default:
printf("proc1: event_set\n");
e0 = event_set(eventa);
event_check_error_exit(e0, "proc1: event_set");
e1 = event_set(eventb);
event_check_error_exit(e1, "proc1: event_set");
e2 = event_set(eventc);
event_check_error_exit(e2, "proc1: event_set");
e3 = event_set(eventd);
event_check_error_exit(e3, "proc1: event_set");
tab[0] = e0;
tab[1] = e1;
tab[2] = e2;
tab[3] = e3;
sleep(1);
while(cnt < 4) {
sleep(1);
printf("proc1: event_throw, event %s\n", events[cnt]);
rt = event_throw(tab[cnt]);
event_check_error_exit(rt, "proc2: event_throw FAILS!");
cnt++;
}
printf("proc1: Unsetting events\n");
rt = event_unset(e0);
event_check_error(rt, "proc1: event_unset event0");
rt = event_unset(e1);
event_check_error(rt, "proc1: event_unset event1");
rt = event_unset(e2);
event_check_error(rt, "proc1: event_unset event2");
rt = event_unset(e3);
event_check_error(rt, "proc1: event_unset event3");
sleep(1);
printf("proc1: returning\n");
exit(0);
}
return 0;
}
// address: 8048b10
int main(int argc, char *argv[], char *envp[]) {
__size32 eax; // r24
int ecx; // r25
__size8 *edi; // r31
__size8 *esi; // r30
eax = *argv;
global4 = eax;
setlocale(6, "");
bindtextdomain("coreutils", "/usr/share/locale");
textdomain("coreutils");
proc2();
if (argc == 2) {
getenv("POSIXLY_CORRECT");
flags = LOGICALFLAGS32(eax);
if (eax == 0) {
eax = *(argv + 4);
edi = 0x804a055;
esi = eax;
ecx = 7;
do {
if (ecx == 0) {
goto L7;
}
tmpb = *esi - *edi;
flags = SUBFLAGS8(*esi, *edi, tmpb);
esi += (DF == 0) ? 1 : -1;
edi += (DF == 0) ? 1 : -1;
ecx = ecx - 1;
} while (tmpb == 0);
L7:
if (flags) {
proc4(0);
}
do {
} while (ecx != 0 && ZF);
if ( !flags) {
*(__size32*)(esp + 20) = eax;
*(__size32*)(esp + 16) = edi;
*(__size32*)(esp + 12) = esi;
*(__size32*)(esp + 8) = ebx;
*(__size32*)(esp + 4) = ecx;
*(__size32*)esp = eax;
proc3(*(esp - 72), *(esp + 4), *(esp + 8), *(esp + 12), *(esp + 16), *(esp + 20));
}
}
}
*(__size32*)esp = 0;
exit(*(esp + 4));
return;
}
int main(int argc, char argv[]) {
//Tube initialise
int tube[2];
pipe(tube);
int pid;
int ret = 0;
key_t cle;
int er;
int semid;
semid = semget(cle,2,IPC_CREAT|0666);
if(semid == -1) {
perror("semget\n");
exit(1);
}
union semun{
int val;
struct smid_ds *buf;
ushort *array;
} arg;
arg.val = 1;
er = semctl(semid,0,SETVAL,arg);
if (er == -1) {
perror("semctl\n");
exit(1);
}
arg.val = 0;
er = semctl(semid,1,SETVAL,arg);
if (er == -1) {
perror("semctl\n");
exit(1);
}
pid = fork();
if(pid == 0) {
proc2 (tube, semid);
}
proc1(tube, semid);
wait (&ret);
//Once finished, it clears the semaphore
if (semctl(semid, 1, IPC_RMID ) == -1 )
{
perror("semctl failure while clearing Reason:");
exit(-1);
}
return 0;
}
int main(int argc, char **argv)
{
#if 1
int pid;
pid = fork();
if(pid < 0) {
perror("fork");
exit(2);
}
if(pid == 0) {
proc1();
exit(0);
}
waitpid(pid, NULL, 0);
proc2();
#else
proc1();
proc2();
#endif
return 0;
}
int main(void)
{
pthread_t t1, t2;
int n;
pthread_create(&t1, NULL, thread1, NULL);
pthread_create(&t2, NULL, thread2, NULL);
while (scanf("%d", &n) == 1) {
if (n == 1)
proc1();
if (n == 2)
proc2();
}
pthread_join(t1, NULL);
pthread_join(t2, NULL);
return 0;
}
// address: 0x401000
void _start(__size32 param1) {
__size32 *eax; // r24
__size32 eax_1; // r24{11}
__size32 ecx; // r25
eax = *(param1 + 160);
eax = *eax;
eax = *(eax + 8);
eax = *eax;
eax = *eax;
eax = *eax;
eax_1 = *(eax - 4);
eax = *(eax_1 + 4);
if (eax != 0) {
proc1();
proc2();
}
proc3(pc, ecx, eax, ecx, eax_1 + 4, param1, LOGICALFLAGS32(eax), LOGICALFLAGS32(eax), LOGICALFLAGS32(eax));
}
int main(int argc, char **argv) {
int pid;
pid = fork();
if(pid < 0) {
perror("fork");
exit(2);
}
if(pid == 0) {
proc1();
exit(EXIT_SUCCESS);
}
waitpid(pid, NULL, 0);
proc2();
printf("Ok\n");
return 0;
}
int main(int argc, char **argv)
{
int pid;
// rvm_verbose(1);
pid = fork();
if(pid < 0) {
perror("fork");
exit(2);
}
if(pid == 0) {
proc1();
exit(0);
}
waitpid(pid, NULL, 0);
proc2();
return 0;
}
int main(int argc, char **argv)
{
int pid;
pid = fork();
if(pid < 0) {
perror("fork");
exit(2);
}
if(pid == 0) {
proc1();
printf("proc1 successful ! \n");
exit(0);
}
waitpid(pid, NULL, 0);
printf("Before proc2 called \n");
proc2();
printf("After proc2 called \n");
return 0;
}
int main(int argc, char **argv)
{
#if 1
int pid;
pid = fork();
if(pid < 0) {
perror("fork");
exit(2);
}
if(pid == 0) {
proc1();
exit(0);
}
waitpid(pid, NULL, 0);
proc2();
#else
/* truncate test */
proc1();
rvm_t rvm;
printf("Before Truncation:\n");
system("ls -l rvm_segments");
rvm = rvm_init("rvm_segments");
rvm_truncate_log(rvm);
printf("\nAfter Truncation:\n");
system("ls -l rvm_segments");
#endif
return 0;
}
void *launch_proc2() {
int msec = rand() % INIT_SLEEP;
usleep(msec);
proc2(REPEAT, MAX_SLEEP);
return NULL;
}
double Propagation::ExtractMinDist(Process &proc, int type, double R, double R2,
std::vector<double> &Etarget) const {
double min_dist1 = 0;
double min_dist2 = 0;
Process proc1(proc);
Process proc2(proc);
double tmp_lambda1 = 0;
double tmp_lambda2 = 0;
Particle pt;
pt.SetType(0);
pt.Setz(proc.GetIncidentParticle().Getz());
if (type == 22) {
if (Etarget[0]) {
proc1.SetName(Process::PP);
pt.SetEnergy(Etarget[0]);
proc1.SetTargetParticle(pt);
proc1.SetCMEnergy();
tmp_lambda1 = GetLambdaTab(proc1, Process::PP);
min_dist1 = -tmp_lambda1 * log(R);
}
if (Etarget[1]) {
pt.SetEnergy(Etarget[1]);
proc2.SetTargetParticle(pt);
proc2.SetCMEnergy();
tmp_lambda2 = GetLambdaTab(proc2, Process::DPP);
min_dist2 = -tmp_lambda2 * log(R2);
}
#ifdef DEBUG_ELECA
std::cerr << "comparing 2 mindists: " << min_dist1 << "("
<< tmp_lambda1 << ") vs " << min_dist2 << " ( "
<< tmp_lambda2 << ") " << std::endl;
#endif
if (min_dist2 < min_dist1) {
min_dist1 = min_dist2;
proc.SetName(Process::DPP);
pt.SetEnergy(Etarget[1]);
proc.SetTargetParticle(pt);
proc.SetCMEnergy();
} else {
proc.SetName(Process::PP);
pt.SetEnergy(Etarget[0]);
proc.SetTargetParticle(pt);
proc.SetCMEnergy();
}
} //end if type 0
else if (abs(type) == 11) {
proc1.SetName(Process::ICS);
pt.SetEnergy(Etarget[0]);
proc1.SetTargetParticle(pt);
tmp_lambda1 = GetLambdaTab(proc1, Process::ICS);
min_dist1 = -tmp_lambda1 * log(R);
proc2.SetName(Process::TPP);
pt.SetEnergy(Etarget[1]);
proc2.SetTargetParticle(pt);
tmp_lambda2 = GetLambdaTab(proc2, Process::TPP);
min_dist2 = -tmp_lambda2 * log(R2);
#ifdef DEBUG_ELECA
std::cerr << "comparing 2 mindists: " << min_dist1 << "("
<< tmp_lambda1 << ") vs " << min_dist2 << " ( "
<< tmp_lambda2 << ") " << std::endl;
#endif
if (min_dist2 < min_dist1) {
min_dist1 = min_dist2;
proc.SetName(Process::TPP);
pt.SetEnergy(Etarget[1]);
proc.SetTargetParticle(pt);
proc.SetCMEnergy();
} else {
proc.SetName(Process::ICS);
pt.SetEnergy(Etarget[0]);
proc.SetTargetParticle(pt);
proc.SetCMEnergy();
}
} //else e+/e-
else
std::cerr << "something wrong in particle type ( " << type
<< ". Propagation of photons and e+/e- is the only allowed.)"
<< std::endl;
return min_dist1;
}
// address: 0x401010
void _start(unsigned int param1, __size32 param2) {
unsigned char dl; // r10
__size32 eax; // r24
int *eax_1; // r24{64}
void *eax_2; // r24{144}
void *eax_3; // r24{241}
int *ebx; // r27
int ebx_1; // r27
int ecx; // r25
__size32 ecx_1; // r25{225}
void *esi; // r30
int esp; // r28
void *esp_1; // r28{14}
__size32 local0; // m[esp - 24]
unsigned int local1; // m[esp - 16]
void *local10; // m[esp_1 - 20]{161}
void *local11; // m[esp_1 - 20]{205}
unsigned int local2; // m[esp - 12]
__size32 local3; // m[esp - 20]
unsigned int local4; // m[esp - 8]
int local5; // m[esp - 28]
unsigned int local6; // m[esp_1 - 20]{79}
void *local9; // m[esp_1 - 20]{146}
esp_1 = proc1(¶m2);
*(__size32*)(esp_1 - 4) = 0x2000;
local0 = *(esp_1 - 4);
*(__size32*)(esp_1 - 4) = 0x10e3f1cf;
local1 = *(esp_1 - 4);
*(__size32*)(esp_1 - 4) = 0xfb750a4;
local2 = *(esp_1 - 4);
eax = param1 * 256 + local0 + 0x3fa900;
ecx = eax - param1 + 203;
*(__size32*)(esp_1 - 4) = *ecx;
local3 = *(esp_1 - 4);
eax_1 = eax - param1 + 223;
*(union { void * x1; int x2; }*)(esp_1 - 4) = esp - 8;
*(__size32*)(esp_1 - 8) = 4;
*(__size32*)(esp_1 - 12) = local3;
*(int **)(esp_1 - 16) = eax_1;
VirtualProtect();
ecx = local3;
ebx = eax_1;
eax = local1 + param1;
local4 = 1;
ecx_1 = ecx;
*(int*)ebx = *ebx ^ eax;
ecx = ecx_1 - param1 + 83;
while (ecx_1 + 83 >= (int)param1) {
eax += local2;
eax += local4;
ebx = ebx - param1 + 91;
local4 = 0 - local4;
ecx_1 = ecx;
*(int*)ebx = *ebx ^ eax;
ecx = ecx_1 - param1 + 83;
}
ebx = eax_1 - param1 + 147;
ebx_1 = *ebx;
dl = *(ebx_1 + eax_1 + 6);
local5 = 0 >> 8 & 0xffffff | (dl);
*(__size32*)(esp_1 - 20) = 64;
*(__size32*)(esp_1 - 24) = 0x3000;
*(__size32*)(esp_1 - 28) = *(ebx_1 + eax_1 + 80);
*(__size32*)(esp_1 - 32) = *(ebx_1 + eax_1 + 52);
eax_2 = VirtualAlloc(*(esp_1 - 32), *(esp_1 - 28), *(esp_1 - 24), *(esp_1 - 20));
local9 = eax_2;
*(int **)(esp_1 - 24) = eax_1;
*(__size32*)(esp_1 - 28) = *(ebx_1 + eax_1 + 84);
proc2(*(esp_1 - 28), *(esp_1 - 24), *(esp_1 - 20));
esi = ebx_1 + eax_1 + 248;
do {
ecx = eax_2 + *(esi + 12);
local10 = ecx;
eax = eax_1 + *(esi + 20);
*(void **)(esp_1 - 24) = eax;
*(__size32*)(esp_1 - 28) = *(esi + 16);
proc2(*(esp_1 - 28), *(esp_1 - 24), *(esp_1 - 20));
esi += 40;
local5 = local5 - 1;
} while (local5 != 0);
eax = eax_2;
do {
eax_3 = eax;
eax = eax_3 + 4;
} while (*(eax_3 + 4) != 0xaabbccdd);
local11 = eax_3 + 4;
*(__size32*)(esp_1 - 24) = 0x401174;
*(__size32*)(esp_1 - 28) = 56;
proc2(*(esp_1 - 28), *(esp_1 - 24), *(esp_1 - 20));
return;
}
// address: 0x4010e0
void _start(char param1, unsigned char param2, __size32 param3, __size32 param4, __size32 param5) {
__size32 eax; // r24
__size32 eax_1; // r24{18}
int ecx; // r25
int edx; // r26
int esp; // r28
__size32 *esp_1; // r28{116}
__size32 *esp_2; // r28{147}
__size32 *esp_3; // r28{251}
__size32 *local10; // esp_3{251}
unsigned int local6; // m[esp - 8]
eax_1 = GetModuleHandleA();
LoadIconA(0, 0x7f00);
GetWindowsDirectoryA();
ecx = (param2);
if (ecx != 58) {
}
lstrcatA(¶m1, "\hh.exe");
eax = CreateFileA();
if (eax != -1) {
GetWindowsDirectoryA();
edx = (param2);
if (edx != 58) {
}
lstrcatA(¶m1, "\hXCXXXXCXXAAXCh.exe");
eax = CreateFileA(); /* Warning: also results in esp_1 */
local10 = esp_1;
if (eax == -1) {
local6 = 0;
esp_3 = local10;
while (local6 < global67) {
*(__size32*)(esp_3 - 4) = 0;
esp_2 = GetModuleHandleA();
local10 = esp_2;
edx = local6 + 0x402333;
eax = *(edx + 8);
ecx = local6 + 0x402333;
*(int*)(ecx + 8) = eax ^ 22;
local6 += 8;
esp_3 = local10;
}
*(__size32*)(esp_3 - 4) = global68;
eax = proc1(*(esp_3 - 4));
global73 = eax;
*(unsigned int*)(esp_3 - 4) = global67;
*(__size32*)(esp_3 - 8) = global73;
*(__size32*)(esp_3 - 12) = 0x40233b;
proc2(*(esp_3 - 184), *(esp_3 - 180), *(esp_3 - 48), *(esp_3 - 44), *(esp_3 - 32), *(esp_3 - 12), *(esp_3 - 8), *(esp_3 - 4));
global76 = param5;
global77 = param4;
global78 = param3;
ecx = *24;
global27 = ecx;
global80 = (esp - 4);
*(__size32*)(esp_3 - 4) = eax_1;
*(__size32*)(esp_3 - 8) = 0x40128f - eax_1;
esp = proc3(*(esp_3 - 4));
*(__size32*)(esp + 4) = global73;
proc4(*(esp + 4));
/* goto m[0x406720]*/
}
} else {
// address: 0x4014ec
void _start() {
__size16 ax; // r0
__size16 cx; // r1
unsigned char dl; // r10
__size32 eax; // r24
__size32 *ebp; // r29
__size32 ebx; // r27
__size32 ecx; // r25
__size32 edi; // r31
int edx; // r26
__size32 esi; // r30
int esp; // r28
void *esp_1; // r28{8}
void *esp_2; // r28{44}
void *esp_3; // r28{191}
int local0; // m[esp - 4]
int local1; // m[esp - 24]
int local2; // m[esp - 20]
unsigned int local3; // m[esp - 12]
int local4; // m[esp - 8]
void *local5; // esp_3{191}
esi = proc1(local1, local2, esi); /* Warning: also results in ebx, edi */
esp_1 = proc2(16, ebx, esi, edi); /* Warning: also results in ebp */
local5 = esp_1;
ebx = 0;
*(__size32*)(ebp - 4) = 0;
eax = *24;
esi = *(eax + 4);
*(__size32*)(ebp - 28) = 0;
edi = 0x403374;
for(;;) {
esp_3 = local5;
*(__size32*)(esp_3 - 4) = 0;
*(__size32*)(esp_3 - 8) = esi;
*(__size32*)(esp_3 - 12) = 0x403374;
eax = InterlockedCompareExchange(); /* Warning: also results in edx */
if (eax == 0) {
goto L24;
}
if (eax == esi) {
break;
}
*(__size32*)(esp_3 - 16) = 1000;
esp_2 = Sleep(*(esp_3 - 16));
local5 = esp_2;
}
*(__size32*)(ebp - 28) = 1;
L24:
esi = 1;
if (global61 != 1) {
if (global61 != 0) {
global68 = 1;
L16:
if (global61 == 1) {
*(__size32*)(esp_3 - 16) = 0x4020cc;
*(__size32*)(esp_3 - 20) = 0x4020c4;
edx = _initterm();
global61 = 2;
}
if (*(ebp - 28) == 0) {
*(__size32*)(esp_3 - 16) = 0;
*(__size32*)(esp_3 - 20) = 0x403374;
edx = InterlockedExchange(*(esp_3 - 20), *(esp_3 - 16));
}
esp = esp_3 - 12;
if (*0x403380 != 0) {
*(__size32*)(esp_3 - 16) = 0x403380;
eax = proc5(*(esp_3 - 16), dl, edx, 0); /* Warning: also results in ax, cx, dl, edx */
ecx = *(esp_3 - 16);
esp = esp_3 - 12;
if (eax != 0) {
*(__size32*)(esp_3 - 16) = 0;
*(__size32*)(esp_3 - 20) = 2;
*(__size32*)(esp_3 - 24) = 0;
(*global53)(local1, local2, pc, 0x4021d8, 16, ax, cx, dl, eax, ecx, edx, 0, ebp, 1, 0x403374, LOGICALFLAGS32(eax), LOGICALFLAGS32(eax), LOGICALFLAGS32(eax));
}
}
*(__size32*)0x23cc = global75;
local0 = global75;
local4 = global76;
local3 = global77;
eax = proc6(*(esp - 12), *(esp - 8), 0x23cc, ebx, esi, edi); /* Warning: also results in ebx */
global79 = eax;
if (*0x403024 == ebx) {
local0 = eax;
exit(*(esp - 4));
}
if (*0x403034 == ebx) {
_cexit();
}
*(__size32*)(ebp - 4) = -2;
} else {
global61 = 1;
*(__size32*)(esp_3 - 16) = 0x4020dc;
*(__size32*)(esp_3 - 20) = 0x4020d0;
eax = _initterm_e(); /* Warning: also results in edx */
esp = esp_3 - 12;
if (eax == 0) {
goto L16;
} else {
*(__size32*)(ebp - 4) = -2;
}
}
} else {
*(__size32*)(esp_3 - 16) = 31;
edx = _amsg_exit();
goto L16;
}
proc8(ebp);
return;
}
