Quando faccio un gatto in / proc / cpuinfo, mostra una linea con clflushsize: 64
Questo significa che il mio kernel funziona a 64 bit?
Quando faccio un gatto in / proc / cpuinfo, mostra una linea con clflushsize: 64
Questo significa che il mio kernel funziona a 64 bit?
Risposte:
uname -a
ti dirà il kernel - il bit finale ti dice l'architettura.
Due esempi:
Il mio mac:
Darwin Mac.local 9.8.0 Darwin Kernel Version 9.8.0: Wed Jul 15 16:55:01 PDT 2009; root:xnu-1228.15.4~1/RELEASE_I386 i386
Il mio hosting Dreamhost:
Linux ecco 2.6.24.5-serf-xeon-c6.1-grsec #1 SMP Tue Oct 7 06:18:04 PDT 2008 x86_64 GNU/Linux
i386 = 32 bit
x86_64 = 64 bit
uname -mti darà l'architettura per cui il kernel è compilato. Se stampa, il i686tuo kernel è a 32 bit, se x86_64è a 64 bit, supponendo che tu abbia un chip Intel / AMD.
i386su vecchie piattaforme a 32 bit (e ho anche visto alcuni pacchetti compilati per i586- non sono sicuro se questo sarebbe mai stato prodotto uname, però)
uname -mti dà l'architettura che il kernel sceglie di esporre a questo particolare processo, non l'architettura nativa del kernel. Vedere questo link .
uname -m non segnalare l'architettura reale. In caso contrario, molto probabilmente l'amministratore vuole davvero che tu creda di essere su quell'altra architettura e la cosa migliore da fare è accettare che sa cosa sta facendo. Se sei l'amministratore e stai scherzando, setarchallora sai già meglio comunque.
setarche potresti invocare un tale script senza avere alcuna idea che provochi uname -ma restituire qualcosa di diverso. È possibile, forse anche probabile, che questo tipo di problemi sia il motivo per cui l'OP sta chiedendo.
initpensi che sia a 32 bit: la situazione per questo è un kernel a 64 bit con spazio utente a 32 bit. Molti sistemi di compilazione dipendono dalla uname -mdeterminazione dei flag del compilatore, ad esempio quello di GDB, devono essere forniti con personalità falsa. Ma alcune altre applicazioni dello spazio utente possono ancora voler sapere che tipo di kernel ha (ad esempio per alcune esigenze di basso livello), indipendentemente dalla personalità.
Penso che il modo più preciso sia
getconf LONG_BIT
qui mostra esattamente 64
trovato su questo suggerimento
getconf proviene dal pacchetto libc-bin (su ubuntu)
Se vuoi un rapporto semplice ma dettagliato sul tuo sistema (CPU, Kernel e software Core OS) e non solo sul kernel, ecco un piccolo script bash che ti darà rapidamente le risposte.
Se conosci abbastanza le peculiarità delle CPU a 32 bit / 64 bit e S / W è semplicemente utile. Se non sai molto e pensi che il tuo "sistema" sia a 32 bit o 64 bit, ti aiuterà a scoprire che la verità può essere più complessa (parti del tuo sistema possono essere 64 bit mentre altri 32 bit) senza confonderti.
Ancora una volta questo script (e la risposta) non è per la domanda letterale "Come faccio a sapere se il mio kernel Linux è in esecuzione a 32 bit o 64 bit?" ma per coloro che vogliono anche conoscere l'arco della propria CPU e il core del SO SW.
Questi sono esempi per un caso piuttosto insolito:
You have a 64 bit CPU
Your kernel reports that the architecture is 32 bit
Your /sbin/init process is 64 bit
Your C compiler is configured to produce 32 bit executables
You have a 64 bit CPU
Your kernel reports that the architecture is 32 bit
If you are not the admin he can make a 64bit kernel report 32bit (see man setarch)
In this case he has (because we have 64bit programs)
Your /sbin/init process is 64 bit
Most other core OS programs will probably be 64 bits also.
You may use the following command to check a specific program.
file -L /path/to/program
Your C compiler is configured to produce 32 bit executables
(Note that a 64bit compiler may be setup to produce 32bit code)
Queste 4 righe forniscono tutte le informazioni essenziali.
grep -w 'lm' /proc/cpuinfo > /dev/null && echo "You have a 64 bit CPU" || echo "You have a 32 bit CPU"
echo "Your kernel reports that the architecture is $(uname -m|sed -e 's/x86_64/64 bit/' -e 's/i.86/32 bit/')"
echo "Your /sbin/init process is $(file /sbin/init|sed -e 's/^.* \(32\|64\) bit.*$/\1bit/')"
echo "Your C compiler is configured to produce $(getconf LONG_BIT) bit executables"
Questa sceneggiatura stampa molte spiegazioni ed è utile se non si ha esperienza sull'argomento e ci si trova di fronte a un caso particolare.
#!/bin/bash
# collect system info
grep -w 'lm' /proc/cpuinfo > /dev/null && CPU=64 || CPU=32
ARCH=$(uname -m|sed -e 's/x86_64/64/' -e 's/i.86/32/')
INIT=$(file -L /sbin/init|sed -e 's/^.* \(32\|64\)-bit.*$/\1/')
COMPILER=$(getconf LONG_BIT)
# if all values are the same we set UNIFORM="YES"
! echo "$CPU $ARCH $INIT $COMPILER" | grep -q "$CPU $CPU $CPU $CPU" && UNIFORM="NO" || UNIFORM="YES"
# report to the user
echo "You have a $CPU bit CPU"
echo "Your kernel reports that the architecture is $ARCH bit"
if [ "$UNIFORM" = "NO" ] && [ "$ARCH" = "32" ] ; then
echo " If you are not the admin he can make a 64bit kernel report 32bit (see man setarch)"
if [ "$INIT" = "64" ] || [ "$COMPILER" = "64" ] ; then
echo " In this case he has (because we have 64bit programs)"
else
echo " We don't see such signs so you most likely run a 32bit kernel"
echo " (A 64bit CPU can run 32bit kernels)"
fi
fi
echo "Your /sbin/init process is $INIT bit"
if [ "$CPU" = "64" ] ; then
echo " Most other core OS programs will probably be $INIT bits also."
echo " You may use the following command to check a specific program."
echo " file -L /path/to/program"
fi
if [ "$UNIFORM" = "NO" ] && [ "$INIT" = "32" ] ; then
echo " (Note that a 64bit kernel may start a 32bit init process)"
fi
echo "Your C compiler is configured to produce $COMPILER bit executables"
if [ "$UNIFORM" = "NO" ] && [ "$COMPILER" = "32" ] ; then
echo " (Note that a 64bit compiler may be setup to produce 32bit code)"
fi
Se vuoi saperne di più leggi queste due pagine da cui ho ottenuto la maggior parte delle informazioni a) /programming/246007/how-to-determine-whether-a-given-linux-is-32- bit-or-64-bit b) /unix//a/134394/73271
Se vuoi vedere solo la piattaforma su cui stai girando, puoi usare
uname -i
L'elenco completo delle opzioni supportate per unameè
$ uname --help
Usage: uname [OPTION]...
Print certain system information. With no OPTION, same as -s.
-a, --all print all information, in the following order,
except omit -p and -i if unknown:
-s, --kernel-name print the kernel name
-n, --nodename print the network node hostname
-r, --kernel-release print the kernel release
-v, --kernel-version print the kernel version
-m, --machine print the machine hardware name
-p, --processor print the processor type or "unknown"
-i, --hardware-platform print the hardware platform or "unknown"
-o, --operating-system print the operating system
--help display this help and exit
--version output version information and exit
uname -istampe GenuineIntel, che non è proprio quello che sta cercando.
Unknownsu un Mac.
i386sulla mia macchina!
CLFLUSHSIZEnon ti dice nulla sulla modalità operativa del processore. Secondo questa risposta , si riferisce alla più piccola unità di cache lavabile. Nel tuo caso, le righe della cache vengono lette / scritte in unità di 64 byte.
unamel'output varia troppo per essere utile, come mostra uno sguardo alla tabella degli esempi di Wikipedia . Il metodo più affidabile è getconf LONG_BITquello mostrato nella risposta di Aquarius Power . Funziona indipendentemente dall'architettura del processore, quindi è a casa su ARM, Power o MIPS come su x86.