Citrix Receiver crashes

hauptstrasse · November 18, 2011, 10:19am

Dear Friends

I just migrated from Ubuntu to openSUSE 12.1, and I like it so far. But Citrix is giving me a headache, and I really need it to function correctly since we use Citrix at work.

I am using the Citrix Receiver Version 11.100.158406 downloaded as 64bit RPM from their website. Kernel is 3.1.0-1.2-desktop x86_64, openSUSE 12.1 desktop version with KDE.

When attempting to connect, it crashes with the following trace:

(wfica:10166): Gtk-WARNING **: Unable to locate theme engine in module_path: "ox - Pastebin.com](http://pastebin.com/S3jei85K)

Any and every help is appreciated. If you need more information I’d be happy to provide it.

Thank you!
Patrick

riderplus · November 18, 2011, 10:42am

Hi,

Try installing the gtk2 engines. I had a similar issue a while ago, though not in 12.1

Best,

hauptstrasse · November 18, 2011, 11:46am

Hello riderplus,

Now the gtk-related warnings are gone, but the pointer error still remains

Regards

riderplus · November 18, 2011, 12:09pm

If you haven’t already checked them, maybe these link could help: linux - How to force abort on “glibc detected *** free(): invalid pointer” - Stack Overflow
or an older thread:
Gentoo Forums :: View topic - glibc detected free(): invalid pointer:

There are different solutions, though.

Best,

hauptstrasse · November 18, 2011, 1:49pm

Thank you, that did it. I am writing down the solution below in case anyone has the same problem.

Turns out glibc terminates the program because its buggy as shyat. Setting MALLOC_CHECK_ to zero doesn’t help, this option is no longer present in 2.14

I downloaded the diehard library from DieHard, compiled it, copied it to /usr/local/lib and edited /opt/Citrix/ICAClient/wfica.sh to LD_PRELOAD it:


#!/bin/sh
ICAROOT=/opt/Citrix/ICAClient 
export ICAROOT
LD_PRELOAD=/usr/local/lib/libdiehard.so
export LD_PRELOAD
$ICAROOT/wfica -log -file $1 >/tmp/icalog 2>&1

Now it works

Thank you for your help.

riderplus · November 18, 2011, 3:35pm

Glad that you solved it!

Best,

mrv · November 21, 2011, 6:49pm

hello hauptstrasse,

please can you tell me how you compiled DieHard?
On openSUSE 12.1 there is gcc 4.6 installed and it says it doesn’t run cause of wrong architecture.
If I delete -march=pentium4 in Makefile then it compiles something with errors.

Please tell me your steps.

Thank you.
Andrew

hauptstrasse:

Thank you, that did it. I am writing down the solution below in case anyone has the same problem.

Turns out glibc terminates the program because its buggy as shyat. Setting MALLOC_CHECK_ to zero doesn’t help, this option is no longer present in 2.14

I downloaded the diehard library from DieHard, compiled it, copied it to /usr/local/lib and edited /opt/Citrix/ICAClient/wfica.sh to LD_PRELOAD it:
#!/bin/sh
ICAROOT=/opt/Citrix/ICAClient 
export ICAROOT
LD_PRELOAD=/usr/local/lib/libdiehard.so
export LD_PRELOAD
$ICAROOT/wfica -log -file $1 >/tmp/icalog 2>&1
Now it works

Thank you for your help.

zma1 · November 24, 2011, 8:55pm

Try to change the value of the arch compiler switch according to i386 and x86-64 Options - Using the GNU Compiler Collection (GCC)

Your choice depends on your system.

Hopefully this helps …

mrv · November 25, 2011, 9:29am

Thank you for this link, but it does not help.

I changed the parameter -march to core2 … or corei7 but nothing helps.
It compiles with lots of errors and nothing special which says whats going on.
At the end of the text it says: make *** [linux] Error 1

matchi · November 25, 2011, 12:42pm

compilation worked fine for me:

j926280@w001m0d8: ~/Downloads/diehard-1.1/src> make linux
g++ -finline-functions -static -malign-double -pipe -march=pentium4 -O3 -fomit-frame-pointer -DNDEBUG  -I. -D_REENTRANT=1 -DDIEHARD_REPLICATED=0 -DDIEHARD_MULTITHREADED=1 -shared libdiehard.cpp -Bsymbolic -o libdiehard.so -ldl -lpthread
libdiehard.cpp:19:12: warning: declaration ‘class std::bad_alloc’ does not declare anything [enabled by default]
randomheap.h:36:25: warning: inline function ‘size_t RandomHeapBase<Numerator, Denominator>::getSize(void*) [with int Numerator = 4, int Denominator = 3, size_t = unsigned int]’ used but never defined [enabled by default]
randomheap.h:34:25: warning: inline function ‘void* RandomHeapBase<Numerator, Denominator>::malloc(size_t) [with int Numerator = 4, int Denominator = 3, size_t = unsigned int]’ used but never defined [enabled by default]
randomheap.h:35:23: warning: inline function ‘bool RandomHeapBase<Numerator, Denominator>::free(void*) [with int Numerator = 4, int Denominator = 3]’ used but never defined [enabled by default]
randomminiheap.h:34:23: warning: inline function ‘virtual bool RandomMiniHeapBase::free(void*)’ used but never defined [enabled by default]
randomminiheap.h:35:25: warning: inline function ‘virtual size_t RandomMiniHeapBase::getSize(void*)’ used but never defined [enabled by default]
randomminiheap.h:33:25: warning: inline function ‘virtual void* RandomMiniHeapBase::malloc(size_t)’ used but never defined [enabled by default]
g++ -static -malign-double -pipe -march=pentium4 -O3 -fno-rtti -finline-functions  -ffast-math -fomit-frame-pointer -DNDEBUG  -I. -D_REENTRANT=1 -DDIEHARD_REPLICATED=1 -DDIEHARD_MULTITHREADED=1 -shared libdiehard.cpp -Bsymbolic -o libdiehard_r.so -ldl -lpthread
libdiehard.cpp:19:12: warning: declaration ‘class std::bad_alloc’ does not declare anything [enabled by default]
randomheap.h:36:25: warning: inline function ‘size_t RandomHeapBase<Numerator, Denominator>::getSize(void*) [with int Numerator = 4, int Denominator = 3, size_t = unsigned int]’ used but never defined [enabled by default]
randomheap.h:34:25: warning: inline function ‘void* RandomHeapBase<Numerator, Denominator>::malloc(size_t) [with int Numerator = 4, int Denominator = 3, size_t = unsigned int]’ used but never defined [enabled by default]
randomheap.h:35:23: warning: inline function ‘bool RandomHeapBase<Numerator, Denominator>::free(void*) [with int Numerator = 4, int Denominator = 3]’ used but never defined [enabled by default]
randomminiheap.h:34:23: warning: inline function ‘virtual bool RandomMiniHeapBase::free(void*)’ used but never defined [enabled by default]
randomminiheap.h:35:25: warning: inline function ‘virtual size_t RandomMiniHeapBase::getSize(void*)’ used but never defined [enabled by default]
randomminiheap.h:33:25: warning: inline function ‘virtual void* RandomMiniHeapBase::malloc(size_t)’ used but never defined [enabled by default]

j926280@w001m0d8: ~/Downloads/diehard-1.1/src> ls -al libdiehard.so 
-rwxr-xr-x 1 j926280 users 1195033 25. Nov 12:40 libdiehard.so

Citrix Reciever v12 is running again - Thank you guys! lol!

mrv · November 25, 2011, 2:02pm

nice, that it will work for others.
could it be that you don’t have a 64-Bit system?
Or maybe are there missing any gcc packages on my workstation?
zypper se gcc shows a lot.
(gcc45,46, also with 32-bit, etc)

matchi · November 25, 2011, 2:23pm

Hi mrv,

I have following gcc packages installed:

gcc-c++-4.6-15.1.3.i586
gcc46-c++-4.6.2_20111026-1.1.4.i586
gcc46-4.6.2_20111026-1.1.4.i586
gcc-4.6-15.1.3.i586
libstlport_gcc4-4.6.2-12.1.2.i586
libgcc46-4.6.2_20111026-1.1.4.i586

running on 32-bit version

maybe you could post your compilation output of libdiehard?!

mrv · November 25, 2011, 2:45pm

First, thanks for help

Maybe your 32-Bit was the clue.


/tmp/diehard-1.1/src> make linux
g++ -finline-functions -static -malign-double -pipe -march=pentium4 -O3 -fomit-frame-pointer -DNDEBUG  -I. -D_REENTRANT=1 -DDIEHARD_REPLICATED=0 -DDIEHARD_MULTITHREADED=1 -shared libdiehard.cpp -Bsymbolic -o libdiehard.so -ldl -lpthread
libdiehard.cpp:1:0: error: CPU you selected does not support x86-64 instruction set
libdiehard.cpp:1:0: error: CPU you selected does not support x86-64 instruction set
make: *** [linux] Fehler 1

I have an Intel i5.
So I changed -march to core2 or also to corei7 as it was described in a given link up above.


/tmp/diehard-1.1/src> make linux
g++ -finline-functions -static -malign-double -pipe -march=corei7 -O3 -fomit-frame-pointer -DNDEBUG  -I. -D_REENTRANT=1 -DDIEHARD_REPLICATED=0 -DDIEHARD_MULTITHREADED=1 -shared libdiehard.cpp -Bsymbolic -o libdiehard.so -ldl -lpthread
libdiehard.cpp:19:12: warning: declaration ‘class std::bad_alloc’ does not declare anything [enabled by default]
In file included from diehardheap.h:23:0,
                 from libdiehard.cpp:34:
randomheap.h: In static member function ‘static void RandomHeap<Numerator, Denominator, ObjectSize, AllocationGrain, MiniHeap, DieFastOn>::Initializer<Index>::run(char*) [with int Index = 19, int Numerator = 4, int Denominator = 3, long unsigned int ObjectSize = 8ul, long unsigned int AllocationGrain = 65536ul, MiniHeap = RandomMiniHeap, bool DieFastOn = false]’:
staticforloop.h:24:5:   recursively instantiated from ‘static void StaticForLoop<From, Iterations, C, V>::run(V) [with int From = 2, int Iterations = 45, C = RandomHeap<4, 3, 8ul, 65536ul, RandomMiniHeap, false>::Initializer, V = char*]’
staticforloop.h:24:5:   instantiated from ‘static void StaticForLoop<From, Iterations, C, V>::run(V) [with int From = 1, int Iterations = 46, C = RandomHeap<4, 3, 8ul, 65536ul, RandomMiniHeap, false>::Initializer, V = char*]’
randomheap.h:106:5:   instantiated from ‘RandomHeap<Numerator, Denominator, ObjectSize, AllocationGrain, MiniHeap, DieFastOn>::RandomHeap() [with int Numerator = 4, int Denominator = 3, long unsigned int ObjectSize = 8ul, long unsigned int AllocationGrain = 65536ul, MiniHeap = RandomMiniHeap, bool DieFastOn = false]’
diehardheap.h:136:7:   instantiated from ‘static void DieHardHeap<Numerator, Denominator, MaxSize, DieFast>::Initializer<index>::run(void*) [with int index = 0, int Numerator = 4, int Denominator = 3, int MaxSize = 65536, bool DieFast = false]’
staticforloop.h:21:5:   instantiated from ‘static void StaticForLoop<From, Iterations, C, V>::run(V) [with int From = 0, int Iterations = 14, C = DieHardHeap<4, 3, 65536, false>::Initializer, V = void*]’
diehardheap.h:58:5:   instantiated from ‘DieHardHeap<Numerator, Denominator, MaxSize, DieFast>::DieHardHeap() [with int Numerator = 4, int Denominator = 3, int MaxSize = 65536, bool DieFast = false]’                                                                                                                                                                                         
combineheap.h:8:7:   instantiated from ‘ReentrantHeap<Super, BufferSize>::ReentrantHeap() [with Super = CombineHeap<DieHardHeap<4, 3, 65536, false>, TheLargeHeap>, int BufferSize = 65536]’    
lockheap.h:10:7:   instantiated from here                                                                                                                                                       
randomheap.h:207:7: warning: integer overflow in expression -Woverflow]                                                                                                                        
randomheap.h:207:7: error: overflow in constant expression -fpermissive]                                                                                                                       
randomheap.h:207:7: note: in template argument for type ‘int’                                                                                                                                   
randomheap.h: In static member function ‘static void RandomHeap<Numerator, Denominator, ObjectSize, AllocationGrain, MiniHeap, DieFastOn>::Initializer<Index>::run(char*) [with int Index = 20, int Numerator = 4, int Denominator = 3, long unsigned int ObjectSize = 8ul, long unsigned int AllocationGrain = 65536ul, MiniHeap = RandomMiniHeap, bool DieFastOn = false]’:
staticforloop.h:24:5:   recursively instantiated from ‘static void StaticForLoop<From, Iterations, C, V>::run(V) [with int From = 2, int Iterations = 45, C = RandomHeap<4, 3, 8ul, 65536ul, RandomMiniHeap, false>::Initializer, V = char*]’
staticforloop.h:24:5:   instantiated from ‘static void StaticForLoop<From, Iterations, C, V>::run(V) [with int From = 1, int Iterations = 46, C = RandomHeap<4, 3, 8ul, 65536ul, RandomMiniHeap, false>::Initializer, V = char*]’
randomheap.h:106:5:   instantiated from ‘RandomHeap<Numerator, Denominator, ObjectSize, AllocationGrain, MiniHeap, DieFastOn>::RandomHeap() [with int Numerator = 4, int Denominator = 3, long unsigned int ObjectSize = 8ul, long unsigned int AllocationGrain = 65536ul, MiniHeap = RandomMiniHeap, bool DieFastOn = false]’
diehardheap.h:136:7:   instantiated from ‘static void DieHardHeap<Numerator, Denominator, MaxSize, DieFast>::Initializer<index>::run(void*) [with int index = 0, int Numerator = 4, int Denominator = 3, int MaxSize = 65536, bool DieFast = false]’
staticforloop.h:21:5:   instantiated from ‘static void StaticForLoop<From, Iterations, C, V>::run(V) [with int From = 0, int Iterations = 14, C = DieHardHeap<4, 3, 65536, false>::Initializer, V = void*]’
diehardheap.h:58:5:   instantiated from ‘DieHardHeap<Numerator, Denominator, MaxSize, DieFast>::DieHardHeap() [with int Numerator = 4, int Denominator = 3, int MaxSize = 65536, bool DieFast = false]’
combineheap.h:8:7:   instantiated from ‘ReentrantHeap<Super, BufferSize>::ReentrantHeap() [with Super = CombineHeap<DieHardHeap<4, 3, 65536, false>, TheLargeHeap>, int BufferSize = 65536]’
lockheap.h:10:7:   instantiated from here
randomheap.h:207:7: warning: integer overflow in expression -Woverflow]
randomheap.h:207:7: error: overflow in constant expression -fpermissive]
randomheap.h:207:7: note: in template argument for type ‘int’ 
randomheap.h: In static member function ‘static void RandomHeap<Numerator, Denominator, ObjectSize, AllocationGrain, MiniHeap, DieFastOn>::Initializer<Index>::run(char*) [with int Index = 21, int Numerator = 4, int Denominator = 3, long unsigned int ObjectSize = 8ul, long unsigned int AllocationGrain = 65536ul, MiniHeap = RandomMiniHeap, bool DieFastOn = false]’:
staticforloop.h:24:5:   recursively instantiated from ‘static void StaticForLoop<From, Iterations, C, V>::run(V) [with int From = 2, int Iterations = 45, C = RandomHeap<4, 3, 8ul, 65536ul, RandomMiniHeap, false>::Initializer, V = char*]’
staticforloop.h:24:5:   instantiated from ‘static void StaticForLoop<From, Iterations, C, V>::run(V) [with int From = 1, int Iterations = 46, C = RandomHeap<4, 3, 8ul, 65536ul, RandomMiniHeap, false>::Initializer, V = char*]’
randomheap.h:106:5:   instantiated from ‘RandomHeap<Numerator, Denominator, ObjectSize, AllocationGrain, MiniHeap, DieFastOn>::RandomHeap() [with int Numerator = 4, int Denominator = 3, long unsigned int ObjectSize = 8ul, long unsigned int AllocationGrain = 65536ul, MiniHeap = RandomMiniHeap, bool DieFastOn = false]’
diehardheap.h:136:7:   instantiated from ‘static void DieHardHeap<Numerator, Denominator, MaxSize, DieFast>::Initializer<index>::run(void*) [with int index = 0, int Numerator = 4, int Denominator = 3, int MaxSize = 65536, bool DieFast = false]’
staticforloop.h:21:5:   instantiated from ‘static void StaticForLoop<From, Iterations, C, V>::run(V) [with int From = 0, int Iterations = 14, C = DieHardHeap<4, 3, 65536, false>::Initializer, V = void*]’
diehardheap.h:58:5:   instantiated from ‘DieHardHeap<Numerator, Denominator, MaxSize, DieFast>::DieHardHeap() [with int Numerator = 4, int Denominator = 3, int MaxSize = 65536, bool DieFast = false]’
combineheap.h:8:7:   instantiated from ‘ReentrantHeap<Super, BufferSize>::ReentrantHeap() [with Super = CombineHeap<DieHardHeap<4, 3, 65536, false>, TheLargeHeap>, int BufferSize = 65536]’
lockheap.h:10:7:   instantiated from here
randomheap.h:207:7: warning: integer overflow in expression -Woverflow]
randomheap.h:207:7: error: overflow in constant expression -fpermissive]
randomheap.h:207:7: note: in template argument for type ‘int’ 
randomheap.h: In static member function ‘static void RandomHeap<Numerator, Denominator, ObjectSize, AllocationGrain, MiniHeap, 

...]

diehardheap.h:58:5:   instantiated from ‘DieHardHeap<Numerator, Denominator, MaxSize, DieFast>::DieHardHeap() [with int Numerator = 4, int Denominator = 3, int MaxSize = 65536, bool DieFast = false]’
combineheap.h:8:7:   instantiated from ‘ReentrantHeap<Super, BufferSize>::ReentrantHeap() [with Super = CombineHeap<DieHardHeap<4, 3, 65536, false>, TheLargeHeap>, int BufferSize = 65536]’
lockheap.h:10:7:   instantiated from here
randomheap.h:207:7: warning: left shift count >= width of type [enabled by default]
randomheap.h: In static member function ‘static void RandomHeap<Numerator, Denominator, ObjectSize, AllocationGrain, MiniHeap, DieFastOn>::Initializer<Index>::run(char*) [with int Index = 46, int Numerator = 4, int Denominator = 3, long unsigned int ObjectSize = 65536ul, long unsigned int AllocationGrain = 65536ul, MiniHeap = RandomMiniHeap, bool DieFastOn = false]’:
staticforloop.h:24:5:   recursively instantiated from ‘static void StaticForLoop<From, Iterations, C, V>::run(V) [with int From = 2, int Iterations = 45, C = RandomHeap<4, 3, 65536ul, 65536ul, RandomMiniHeap, false>::Initializer, V = char*]’
staticforloop.h:24:5:   instantiated from ‘static void StaticForLoop<From, Iterations, C, V>::run(V) [with int From = 1, int Iterations = 46, C = RandomHeap<4, 3, 65536ul, 65536ul, RandomMiniHeap, false>::Initializer, V = char*]’
randomheap.h:106:5:   instantiated from ‘RandomHeap<Numerator, Denominator, ObjectSize, AllocationGrain, MiniHeap, DieFastOn>::RandomHeap() [with int Numerator = 4, int Denominator = 3, long unsigned int ObjectSize = 65536ul, long unsigned int AllocationGrain = 65536ul, MiniHeap = RandomMiniHeap, bool DieFastOn = false]’
diehardheap.h:136:7:   instantiated from ‘static void DieHardHeap<Numerator, Denominator, MaxSize, DieFast>::Initializer<index>::run(void*) [with int index = 13, int Numerator = 4, int Denominator = 3, int MaxSize = 65536, bool DieFast = false]’
staticforloop.h:24:5:   recursively instantiated from ‘static void StaticForLoop<From, Iterations, C, V>::run(V) [with int From = 1, int Iterations = 13, C = DieHardHeap<4, 3, 65536, false>::Initializer, V = void*]’
staticforloop.h:24:5:   instantiated from ‘static void StaticForLoop<From, Iterations, C, V>::run(V) [with int From = 0, int Iterations = 14, C = DieHardHeap<4, 3, 65536, false>::Initializer, V = void*]’
diehardheap.h:58:5:   instantiated from ‘DieHardHeap<Numerator, Denominator, MaxSize, DieFast>::DieHardHeap() [with int Numerator = 4, int Denominator = 3, int MaxSize = 65536, bool DieFast = false]’
combineheap.h:8:7:   instantiated from ‘ReentrantHeap<Super, BufferSize>::ReentrantHeap() [with Super = CombineHeap<DieHardHeap<4, 3, 65536, false>, TheLargeHeap>, int BufferSize = 65536]’
lockheap.h:10:7:   instantiated from here
randomheap.h:207:7: warning: left shift count >= width of type [enabled by default]
In file included from diehardheap.h:24:0,
                 from libdiehard.cpp:34:
randomminiheap.h: In member function ‘void* RandomMiniHeap<Numerator, Denominator, ObjectSize, NObjects, Allocator, DieFastOn>::malloc(size_t) [with int Numerator = 4, int Denominator = 3, long unsigned int ObjectSize = 65536ul, int NObjects = -0x00000000080000000, Allocator = OneHeap<BumpAlloc<MmapAlloc, 4096> >, bool DieFastOn = false, size_t = long unsigned int]’:
libdiehard.cpp:200:1:   instantiated from here
randomminiheap.h:102:55: warning: integer overflow in expression -Woverflow]
randomminiheap.h: In member function ‘void RandomMiniHeap<Numerator, Denominator, ObjectSize, NObjects, Allocator, DieFastOn>::checkOverflowError(void*, int) const [with int Numerator = 4, int Denominator = 3, long unsigned int ObjectSize = 65536ul, int NObjects = -0x00000000080000000, Allocator = OneHeap<BumpAlloc<MmapAlloc, 4096> >, bool DieFastOn = false]’:
randomminiheap.h:159:2:   instantiated from ‘bool RandomMiniHeap<Numerator, Denominator, ObjectSize, NObjects, Allocator, DieFastOn>::free(void*) [with int Numerator = 4, int Denominator = 3, long unsigned int ObjectSize = 65536ul, int NObjects = -0x00000000080000000, Allocator = OneHeap<BumpAlloc<MmapAlloc, 4096> >, bool DieFastOn = false]’
libdiehard.cpp:200:1:   instantiated from here
randomminiheap.h:234:5: warning: integer overflow in expression -Woverflow]
randomheap.h: At global scope:
randomheap.h:36:25: warning: inline function ‘size_t RandomHeapBase<Numerator, Denominator>::getSize(void*) [with int Numerator = 4, int Denominator = 3, size_t = long unsigned int]’ used but never defined [enabled by default]
randomheap.h:34:25: warning: inline function ‘void* RandomHeapBase<Numerator, Denominator>::malloc(size_t) [with int Numerator = 4, int Denominator = 3, size_t = long unsigned int]’ used but never defined [enabled by default]
randomheap.h:35:23: warning: inline function ‘bool RandomHeapBase<Numerator, Denominator>::free(void*) [with int Numerator = 4, int Denominator = 3]’ used but never defined [enabled by default]
randomminiheap.h:34:23: warning: inline function ‘virtual bool RandomMiniHeapBase::free(void*)’ used but never defined [enabled by default]
randomminiheap.h:35:25: warning: inline function ‘virtual size_t RandomMiniHeapBase::getSize(void*)’ used but never defined [enabled by default]
randomminiheap.h:33:25: warning: inline function ‘virtual void* RandomMiniHeapBase::malloc(size_t)’ used but never defined [enabled by default]
make: *** [linux] Fehler 1

smile there are not quite a few lines :shame: I had to delete quite a lot to be able to post them here

matchi · November 25, 2011, 2:55pm

Well…this is were my knowledge comes to an ending.
I don’t know compiler process that much, so I can just recommend you trying with a separate 32 bit installation on your machine, at least to get a definitive answer if the architecture is your problem.

martin_helm · November 25, 2011, 2:50pm

Am 25.11.2011 14:46, schrieb mrv:

> smile there are not quite a few lines :shame: I had to delete quite a
> lot to be able to post them here
>
Use susepaste.org for things like that and post the link to it here.

martin_helm · November 25, 2011, 3:36pm

Am 25.11.2011 14:50, schrieb Martin Helm:
> Am 25.11.2011 14:46, schrieb mrv:
>
>> smile there are not quite a few lines :shame: I had to delete quite a
>> lot to be able to post them here
>>
> Use susepaste.org for things like that and post the link to it here.
>
>
I am not absolutely sure which kind of libs you want to get in the end.
But if you replace the original -march=pentium4 in the Makefile with
-m32 for cross compiling to the 32bit architecture it just compiles fine.

rniesen · November 30, 2011, 8:04am

mrv:

First, thanks for help

Maybe your 32-Bit was the clue.


/tmp/diehard-1.1/src> make linux
g++ -finline-functions -static -malign-double -pipe -march=pentium4 -O3 -fomit-frame-pointer -DNDEBUG  -I. -D_REENTRANT=1 -DDIEHARD_REPLICATED=0 -DDIEHARD_MULTITHREADED=1 -shared libdiehard.cpp -Bsymbolic -o libdiehard.so -ldl -lpthread
libdiehard.cpp:1:0: error: CPU you selected does not support x86-64 instruction set
libdiehard.cpp:1:0: error: CPU you selected does not support x86-64 instruction set
make: *** [linux] Fehler 1

I have an Intel i5.
So I changed -march to core2 or also to corei7 as it was described in a given link up above.


/tmp/diehard-1.1/src> make linux
g++ -finline-functions -static -malign-double -pipe -march=corei7 -O3 -fomit-frame-pointer -DNDEBUG  -I. -D_REENTRANT=1 -DDIEHARD_REPLICATED=0 -DDIEHARD_MULTITHREADED=1 -shared libdiehard.cpp -Bsymbolic -o libdiehard.so -ldl -lpthread
libdiehard.cpp:19:12: warning: declaration ‘class std::bad_alloc’ does not declare anything [enabled by default]
In file included from diehardheap.h:23:0,
                 from libdiehard.cpp:34:
randomheap.h: In static member function ‘static void RandomHeap<Numerator, Denominator, ObjectSize, AllocationGrain, MiniHeap, DieFastOn>::Initializer<Index>::run(char*) [with int Index = 19, int Numerator = 4, int Denominator = 3, long unsigned int ObjectSize = 8ul, long unsigned int AllocationGrain = 65536ul, MiniHeap = RandomMiniHeap, bool DieFastOn = false]’:
staticforloop.h:24:5:   recursively instantiated from ‘static void StaticForLoop<From, Iterations, C, V>::run(V) [with int From = 2, int Iterations = 45, C = RandomHeap<4, 3, 8ul, 65536ul, RandomMiniHeap, false>::Initializer, V = char*]’
staticforloop.h:24:5:   instantiated from ‘static void StaticForLoop<From, Iterations, C, V>::run(V) [with int From = 1, int Iterations = 46, C = RandomHeap<4, 3, 8ul, 65536ul, RandomMiniHeap, false>::Initializer, V = char*]’
randomheap.h:106:5:   instantiated from ‘RandomHeap<Numerator, Denominator, ObjectSize, AllocationGrain, MiniHeap, DieFastOn>::RandomHeap() [with int Numerator = 4, int Denominator = 3, long unsigned int ObjectSize = 8ul, long unsigned int AllocationGrain = 65536ul, MiniHeap = RandomMiniHeap, bool DieFastOn = false]’
diehardheap.h:136:7:   instantiated from ‘static void DieHardHeap<Numerator, Denominator, MaxSize, DieFast>::Initializer<index>::run(void*) [with int index = 0, int Numerator = 4, int Denominator = 3, int MaxSize = 65536, bool DieFast = false]’
staticforloop.h:21:5:   instantiated from ‘static void StaticForLoop<From, Iterations, C, V>::run(V) [with int From = 0, int Iterations = 14, C = DieHardHeap<4, 3, 65536, false>::Initializer, V = void*]’
diehardheap.h:58:5:   instantiated from ‘DieHardHeap<Numerator, Denominator, MaxSize, DieFast>::DieHardHeap() [with int Numerator = 4, int Denominator = 3, int MaxSize = 65536, bool DieFast = false]’                                                                                                                                                                                         
combineheap.h:8:7:   instantiated from ‘ReentrantHeap<Super, BufferSize>::ReentrantHeap() [with Super = CombineHeap<DieHardHeap<4, 3, 65536, false>, TheLargeHeap>, int BufferSize = 65536]’    
lockheap.h:10:7:   instantiated from here                                                                                                                                                       
randomheap.h:207:7: warning: integer overflow in expression -Woverflow]                                                                                                                        
randomheap.h:207:7: error: overflow in constant expression -fpermissive]                                                                                                                       
randomheap.h:207:7: note: in template argument for type ‘int’                                                                                                                                   
randomheap.h: In static member function ‘static void RandomHeap<Numerator, Denominator, ObjectSize, AllocationGrain, MiniHeap, DieFastOn>::Initializer<Index>::run(char*) [with int Index = 20, int Numerator = 4, int Denominator = 3, long unsigned int ObjectSize = 8ul, long unsigned int AllocationGrain = 65536ul, MiniHeap = RandomMiniHeap, bool DieFastOn = false]’:
staticforloop.h:24:5:   recursively instantiated from ‘static void StaticForLoop<From, Iterations, C, V>::run(V) [with int From = 2, int Iterations = 45, C = RandomHeap<4, 3, 8ul, 65536ul, RandomMiniHeap, false>::Initializer, V = char*]’
staticforloop.h:24:5:   instantiated from ‘static void StaticForLoop<From, Iterations, C, V>::run(V) [with int From = 1, int Iterations = 46, C = RandomHeap<4, 3, 8ul, 65536ul, RandomMiniHeap, false>::Initializer, V = char*]’
randomheap.h:106:5:   instantiated from ‘RandomHeap<Numerator, Denominator, ObjectSize, AllocationGrain, MiniHeap, DieFastOn>::RandomHeap() [with int Numerator = 4, int Denominator = 3, long unsigned int ObjectSize = 8ul, long unsigned int AllocationGrain = 65536ul, MiniHeap = RandomMiniHeap, bool DieFastOn = false]’
diehardheap.h:136:7:   instantiated from ‘static void DieHardHeap<Numerator, Denominator, MaxSize, DieFast>::Initializer<index>::run(void*) [with int index = 0, int Numerator = 4, int Denominator = 3, int MaxSize = 65536, bool DieFast = false]’
staticforloop.h:21:5:   instantiated from ‘static void StaticForLoop<From, Iterations, C, V>::run(V) [with int From = 0, int Iterations = 14, C = DieHardHeap<4, 3, 65536, false>::Initializer, V = void*]’
diehardheap.h:58:5:   instantiated from ‘DieHardHeap<Numerator, Denominator, MaxSize, DieFast>::DieHardHeap() [with int Numerator = 4, int Denominator = 3, int MaxSize = 65536, bool DieFast = false]’
combineheap.h:8:7:   instantiated from ‘ReentrantHeap<Super, BufferSize>::ReentrantHeap() [with Super = CombineHeap<DieHardHeap<4, 3, 65536, false>, TheLargeHeap>, int BufferSize = 65536]’
lockheap.h:10:7:   instantiated from here
randomheap.h:207:7: warning: integer overflow in expression -Woverflow]
randomheap.h:207:7: error: overflow in constant expression -fpermissive]
randomheap.h:207:7: note: in template argument for type ‘int’ 
randomheap.h: In static member function ‘static void RandomHeap<Numerator, Denominator, ObjectSize, AllocationGrain, MiniHeap, DieFastOn>::Initializer<Index>::run(char*) [with int Index = 21, int Numerator = 4, int Denominator = 3, long unsigned int ObjectSize = 8ul, long unsigned int AllocationGrain = 65536ul, MiniHeap = RandomMiniHeap, bool DieFastOn = false]’:
staticforloop.h:24:5:   recursively instantiated from ‘static void StaticForLoop<From, Iterations, C, V>::run(V) [with int From = 2, int Iterations = 45, C = RandomHeap<4, 3, 8ul, 65536ul, RandomMiniHeap, false>::Initializer, V = char*]’
staticforloop.h:24:5:   instantiated from ‘static void StaticForLoop<From, Iterations, C, V>::run(V) [with int From = 1, int Iterations = 46, C = RandomHeap<4, 3, 8ul, 65536ul, RandomMiniHeap, false>::Initializer, V = char*]’
randomheap.h:106:5:   instantiated from ‘RandomHeap<Numerator, Denominator, ObjectSize, AllocationGrain, MiniHeap, DieFastOn>::RandomHeap() [with int Numerator = 4, int Denominator = 3, long unsigned int ObjectSize = 8ul, long unsigned int AllocationGrain = 65536ul, MiniHeap = RandomMiniHeap, bool DieFastOn = false]’
diehardheap.h:136:7:   instantiated from ‘static void DieHardHeap<Numerator, Denominator, MaxSize, DieFast>::Initializer<index>::run(void*) [with int index = 0, int Numerator = 4, int Denominator = 3, int MaxSize = 65536, bool DieFast = false]’
staticforloop.h:21:5:   instantiated from ‘static void StaticForLoop<From, Iterations, C, V>::run(V) [with int From = 0, int Iterations = 14, C = DieHardHeap<4, 3, 65536, false>::Initializer, V = void*]’
diehardheap.h:58:5:   instantiated from ‘DieHardHeap<Numerator, Denominator, MaxSize, DieFast>::DieHardHeap() [with int Numerator = 4, int Denominator = 3, int MaxSize = 65536, bool DieFast = false]’
combineheap.h:8:7:   instantiated from ‘ReentrantHeap<Super, BufferSize>::ReentrantHeap() [with Super = CombineHeap<DieHardHeap<4, 3, 65536, false>, TheLargeHeap>, int BufferSize = 65536]’
lockheap.h:10:7:   instantiated from here
randomheap.h:207:7: warning: integer overflow in expression -Woverflow]
randomheap.h:207:7: error: overflow in constant expression -fpermissive]
randomheap.h:207:7: note: in template argument for type ‘int’ 
randomheap.h: In static member function ‘static void RandomHeap<Numerator, Denominator, ObjectSize, AllocationGrain, MiniHeap, 

...]

diehardheap.h:58:5:   instantiated from ‘DieHardHeap<Numerator, Denominator, MaxSize, DieFast>::DieHardHeap() [with int Numerator = 4, int Denominator = 3, int MaxSize = 65536, bool DieFast = false]’
combineheap.h:8:7:   instantiated from ‘ReentrantHeap<Super, BufferSize>::ReentrantHeap() [with Super = CombineHeap<DieHardHeap<4, 3, 65536, false>, TheLargeHeap>, int BufferSize = 65536]’
lockheap.h:10:7:   instantiated from here
randomheap.h:207:7: warning: left shift count >= width of type [enabled by default]
randomheap.h: In static member function ‘static void RandomHeap<Numerator, Denominator, ObjectSize, AllocationGrain, MiniHeap, DieFastOn>::Initializer<Index>::run(char*) [with int Index = 46, int Numerator = 4, int Denominator = 3, long unsigned int ObjectSize = 65536ul, long unsigned int AllocationGrain = 65536ul, MiniHeap = RandomMiniHeap, bool DieFastOn = false]’:
staticforloop.h:24:5:   recursively instantiated from ‘static void StaticForLoop<From, Iterations, C, V>::run(V) [with int From = 2, int Iterations = 45, C = RandomHeap<4, 3, 65536ul, 65536ul, RandomMiniHeap, false>::Initializer, V = char*]’
staticforloop.h:24:5:   instantiated from ‘static void StaticForLoop<From, Iterations, C, V>::run(V) [with int From = 1, int Iterations = 46, C = RandomHeap<4, 3, 65536ul, 65536ul, RandomMiniHeap, false>::Initializer, V = char*]’
randomheap.h:106:5:   instantiated from ‘RandomHeap<Numerator, Denominator, ObjectSize, AllocationGrain, MiniHeap, DieFastOn>::RandomHeap() [with int Numerator = 4, int Denominator = 3, long unsigned int ObjectSize = 65536ul, long unsigned int AllocationGrain = 65536ul, MiniHeap = RandomMiniHeap, bool DieFastOn = false]’
diehardheap.h:136:7:   instantiated from ‘static void DieHardHeap<Numerator, Denominator, MaxSize, DieFast>::Initializer<index>::run(void*) [with int index = 13, int Numerator = 4, int Denominator = 3, int MaxSize = 65536, bool DieFast = false]’
staticforloop.h:24:5:   recursively instantiated from ‘static void StaticForLoop<From, Iterations, C, V>::run(V) [with int From = 1, int Iterations = 13, C = DieHardHeap<4, 3, 65536, false>::Initializer, V = void*]’
staticforloop.h:24:5:   instantiated from ‘static void StaticForLoop<From, Iterations, C, V>::run(V) [with int From = 0, int Iterations = 14, C = DieHardHeap<4, 3, 65536, false>::Initializer, V = void*]’
diehardheap.h:58:5:   instantiated from ‘DieHardHeap<Numerator, Denominator, MaxSize, DieFast>::DieHardHeap() [with int Numerator = 4, int Denominator = 3, int MaxSize = 65536, bool DieFast = false]’
combineheap.h:8:7:   instantiated from ‘ReentrantHeap<Super, BufferSize>::ReentrantHeap() [with Super = CombineHeap<DieHardHeap<4, 3, 65536, false>, TheLargeHeap>, int BufferSize = 65536]’
lockheap.h:10:7:   instantiated from here
randomheap.h:207:7: warning: left shift count >= width of type [enabled by default]
In file included from diehardheap.h:24:0,
                 from libdiehard.cpp:34:
randomminiheap.h: In member function ‘void* RandomMiniHeap<Numerator, Denominator, ObjectSize, NObjects, Allocator, DieFastOn>::malloc(size_t) [with int Numerator = 4, int Denominator = 3, long unsigned int ObjectSize = 65536ul, int NObjects = -0x00000000080000000, Allocator = OneHeap<BumpAlloc<MmapAlloc, 4096> >, bool DieFastOn = false, size_t = long unsigned int]’:
libdiehard.cpp:200:1:   instantiated from here
randomminiheap.h:102:55: warning: integer overflow in expression -Woverflow]
randomminiheap.h: In member function ‘void RandomMiniHeap<Numerator, Denominator, ObjectSize, NObjects, Allocator, DieFastOn>::checkOverflowError(void*, int) const [with int Numerator = 4, int Denominator = 3, long unsigned int ObjectSize = 65536ul, int NObjects = -0x00000000080000000, Allocator = OneHeap<BumpAlloc<MmapAlloc, 4096> >, bool DieFastOn = false]’:
randomminiheap.h:159:2:   instantiated from ‘bool RandomMiniHeap<Numerator, Denominator, ObjectSize, NObjects, Allocator, DieFastOn>::free(void*) [with int Numerator = 4, int Denominator = 3, long unsigned int ObjectSize = 65536ul, int NObjects = -0x00000000080000000, Allocator = OneHeap<BumpAlloc<MmapAlloc, 4096> >, bool DieFastOn = false]’
libdiehard.cpp:200:1:   instantiated from here
randomminiheap.h:234:5: warning: integer overflow in expression -Woverflow]
randomheap.h: At global scope:
randomheap.h:36:25: warning: inline function ‘size_t RandomHeapBase<Numerator, Denominator>::getSize(void*) [with int Numerator = 4, int Denominator = 3, size_t = long unsigned int]’ used but never defined [enabled by default]
randomheap.h:34:25: warning: inline function ‘void* RandomHeapBase<Numerator, Denominator>::malloc(size_t) [with int Numerator = 4, int Denominator = 3, size_t = long unsigned int]’ used but never defined [enabled by default]
randomheap.h:35:23: warning: inline function ‘bool RandomHeapBase<Numerator, Denominator>::free(void*) [with int Numerator = 4, int Denominator = 3]’ used but never defined [enabled by default]
randomminiheap.h:34:23: warning: inline function ‘virtual bool RandomMiniHeapBase::free(void*)’ used but never defined [enabled by default]
randomminiheap.h:35:25: warning: inline function ‘virtual size_t RandomMiniHeapBase::getSize(void*)’ used but never defined [enabled by default]
randomminiheap.h:33:25: warning: inline function ‘virtual void* RandomMiniHeapBase::malloc(size_t)’ used but never defined [enabled by default]
make: *** [linux] Fehler 1

smile there are not quite a few lines :shame: I had to delete quite a lot to be able to post them here

I have the same problem.
Did someboy found a solution yet?

cpu = corei7
opensuse 12.1 x64

Thanks

matchi · November 30, 2011, 10:23am

Hi rniesen,

seems to work with the following solution:

phatmack · December 14, 2011, 6:10am

hauptstrasse:

Thank you, that did it. I am writing down the solution below in case anyone has the same problem.

Turns out glibc terminates the program because its buggy as shyat. Setting MALLOC_CHECK_ to zero doesn’t help, this option is no longer present in 2.14

I downloaded the diehard library from DieHard, compiled it, copied it to /usr/local/lib and edited /opt/Citrix/ICAClient/wfica.sh to LD_PRELOAD it:
#!/bin/sh
ICAROOT=/opt/Citrix/ICAClient 
export ICAROOT
LD_PRELOAD=/usr/local/lib/libdiehard.so
export LD_PRELOAD
$ICAROOT/wfica -log -file $1 >/tmp/icalog 2>&1
Now it works

Thank you for your help.

Ran through these steps but I’m still getting the exact error messages you’re receiving… Triple checked and it seems that I’ve got wfica.sh setup the exact same way you do. However, I’m trying to launch an application through the Citrix web interface… would there be any differences to where I call libdiehard.so? Thanks!
-Dan

phatmack · December 14, 2011, 6:24am

EDIT: If I remove/disable the Citrix Receiver for Linux plugin from Firefox and tell it to open the .ica files with the /opt/Citrix/ICAClient/wfica.sh script everything works fine! This is great but I would LOVE to be able to use the built in plugin with this fix… because now it downloads each .ica file and then launches that. I’d like for it to be transparent to my users. Thanks again!!!