Kann man in einem Bash-Skript 32 Bit gegen 64 Bit erkennen?

Question

Ich schreibe ein Bash-Skript, um mit einigen Installationen auf automatisierte Weise umzugehen ... Ich habe die Möglichkeit, ein solches Programm in 32- oder 64-Bit-Binär zu bekommen ... ist es möglich, die Maschinenarchitektur von bash zu erkennen kann die richtige binäre auswählen?

Dies wird für Ubuntu-Maschinen sein.

Answer 1

Does

uname -a 

geben Ihnen alles, was Sie können? Ich habe kein 64-Bit-Gerät zum Testen.

---

Hinweis von Mike Stone: Dies funktioniert, obwohl speziell

uname -m 

Will "x86_64" für 64-Bit geben, und etwas anderes für andere 32-Bit-Typen (in meinen 32-Bit-VM, es ist "i686").

Answer 2

Man könnte so etwas tun:

if $(uname -a | grep 'x86_64'); then 
    echo "I'm 64-bit" 
else 
    echo "I'm 32-bit" 
fi 

Answer 3

MACHINE_TYPE=`uname -m` 
if [ ${MACHINE_TYPE} == 'x86_64' ]; then 
    # 64-bit stuff here 
else 
    # 32-bit stuff here 
fi 

Answer 4

Ja, uname -a den Trick tun sollten. siehe: http://www.stata.com/support/faqs/win/64bit.html.

Answer 5

slot8(msd):/opt # uname -a 
Linux slot8a 2.6.21_mvlcge500-electra #1 SMP PREEMPT Wed Jun 18 16:29:33 \ 
EDT 2008 ppc64 GNU/Linux 

Denken Sie daran, es gibt auch andere CPU-Architekturen als Intel/AMD ...

Answer 6

getconf LONG_BIT scheint auch den Trick zu tun, was es noch einfacher macht, dies zu überprüfen, da diese nur die Ganzzahl zurückgibt, anstatt von einem komplizierten Ausdruck.

if [ `getconf LONG_BIT` = "64" ] 
then 
    echo "I'm 64-bit" 
else 
    echo "I'm 32-bit" 
fi 

Answer 7

Sie verwenden können, das Follow-Skript (i Dieser Auszug aus offiziell Skript von "ioquake3"): zum Beispiel

archs=`uname -m` 
case "$archs" in 
    i?86) archs=i386 ;; 
    x86_64) archs="x86_64 i386" ;; 
    ppc64) archs="ppc64 ppc" ;; 
esac 

for arch in $archs; do 
    test -x ./ioquake3.$arch || continue 
    exec ./ioquake3.$arch "$@" 
done 

============== ================================================= =================

Ich mache ein Skript, um die "Architektur" zu erkennen, das ist mein einfacher Code (ich benutze es mit Wein, für meine Windows Games, unter Linux, bei jedem Spiel verwende ich eine andere Version von WineHQ, heruntergeladen von der "PlayOnLinux" -Seite.

# First Obtain "kernel" name 
KERNEL=$(uname -s) 

if  [ $KERNEL = "Darwin" ]; then 
     KERNEL=mac 
elif  [ $Nucleo = "Linux" ]; then 
     KERNEL=linux 
elif  [ $Nucleo = "FreeBSD" ]; then 
     KERNEL=linux 
else 
     echo "Unsupported OS" 
fi 

# Second get the right Arquitecture 
ARCH=$(uname -m) 

if   [ $ARCH = "i386" ]; then 
      PATH="$PWD/wine/$KERNEL/x86/bin:$PATH" 
      export WINESERVER="$PWD/wine/$KERNEL/x86/bin/wineserver" 
      export WINELOADER="$PWD/wine/$KERNEL/x86/bin/wine" 
      export WINEPREFIX="$PWD/wine/data" 
      export WINEDEBUG=-all:$WINEDEBUG 
      ARCH="32 Bits" 
    elif [ $ARCH = "i486" ]; then 
      PATH="$PWD/wine/$KERNEL/x86/bin:$PATH" 
      export WINESERVER="$PWD/wine/$KERNEL/x86/bin/wineserver" 
      export WINELOADER="$PWD/wine/$KERNEL/x86/bin/wine" 
      export WINEPREFIX="$PWD/wine/data" 
      export WINEDEBUG=-all:$WINEDEBUG 
      ARCH="32 Bits" 
    elif [ $ARCH = "i586" ]; then 
      PATH="$PWD/wine/$KERNEL/x86/bin:$PATH" 
      export WINESERVER="$PWD/wine/$KERNEL/x86/bin/wineserver" 
      export WINELOADER="$PWD/wine/$Nucleo/x86/bin/wine" 
      export WINEPREFIX="$PWD/wine/data" 
      export WINEDEBUG=-all:$WINEDEBUG 
      ARCH="32 Bits" 
    elif [ $ARCH = "i686" ]; then 
      PATH="$PWD/wine/$KERNEL/x86/bin:$PATH" 
      export WINESERVER="$PWD/wine/$KERNEL/x86/bin/wineserver" 
      export WINELOADER="$PWD/wine/$KERNEL/x86/bin/wine" 
      export WINEPREFIX="$PWD/wine/data" 
      export WINEDEBUG=-all:$WINEDEBUG 
      ARCH="32 Bits" 
     elif [ $ARCH = "x86_64" ]; then 
      export WINESERVER="$PWD/wine/$KERNEL/x86_64/bin/wineserver" 
      export WINELOADER="$PWD/wine/$KERNEL/x86_64/bin/wine" 
      export WINEPREFIX="$PWD/wine/data" 
      export WINEDEBUG=-all:$WINEDEBUG 
      ARCH="64 Bits" 
    else 
     echo "Unsoportted Architecture" 
fi 

============================================ ==================================

Jetzt benutze ich das in meinem Bash Skripte, weil es in jeder Distribution besser funktioniert.

# Get the Kernel Name 
Kernel=$(uname -s) 
case "$Kernel" in 
    Linux) Kernel="linux"    ;; 
    Darwin) Kernel="mac"    ;; 
    FreeBSD) Kernel="freebsd"   ;; 
*) echo "Your Operating System -> ITS NOT SUPPORTED" ;; 
esac 

echo 
echo "Operating System Kernel : $Kernel" 
echo 
# Get the machine Architecture 
Architecture=$(uname -m) 
case "$Architecture" in 
    x86) Architecture="x86"     ;; 
    ia64) Architecture="ia64"     ;; 
    i?86) Architecture="x86"     ;; 
    amd64) Architecture="amd64"     ;; 
    x86_64) Architecture="x86_64"     ;; 
    sparc64) Architecture="sparc64"     ;; 
*) echo "Your Architecture '$Architecture' -> ITS NOT SUPPORTED." ;; 
esac 

echo 
echo "Operating System Architecture : $Architecture" 
echo 

Answer 8

Seien Sie vorsichtig, in einem chroot ed 32-Bit-env wird die uname Beantwortung immer noch wie die 64-Bit-Host-System.

getconf LONG_BIT funktioniert gut.

file /bin/cp oder jede bekannte ausführbare Datei oder Bibliothek sollte den Trick tun, wenn Sie getconf nicht haben (aber Sie können Programme speichern, die Sie nicht verwenden können, und vielleicht gibt es nicht an diesem Ort).