Distro que eu posso carregar na RAM? [duplicado]

Question

Existe uma versão modificada do Ubuntu que eu posso escolher para carregar na RAM ao iniciar? Um pouco como o LiveCD, mas isso pode ser facilmente modificado (por exemplo: eu posso instalar coisas) quando eu escolho inicializar do disco.

A ideia é instalá-lo em uma unidade USB. Eu sei que há algo parecido , mas faltam slax em muitos departamentos. Uma versão "completa" do Ubuntu seria melhor.

Uma instalação do LiveUSB parece estar bem perto do que eu quero, mas aparentemente eu tenho que escolher se será ou não persistente no momento em que eu instalá-lo. Eu quero ser capaz de escolher isso toda vez que eu inicializo.

    

Answer 1

Existe o parâmetro toram , que você pode fornecer para os recentes livecds do Ubuntu no momento da inicialização, com o significado recente de 10.04 ou mais recente. Isso carregará tudo na RAM (supondo que você tenha RAM suficiente para armazená-lo) e, depois, poderá remover o CD (ou pendrive) e continuar usando o Ubuntu normalmente.

    

Answer 2

Esta resposta inclui texto que eu usei para responder a uma pergunta diferente, mas ela é colocada aqui para ilustrar e fornecer um guia visual, que você provavelmente já tem.

Na maioria dos casos, o Ubuntu (quase qualquer versão) funcionará perfeitamente em uma sessão ao vivo, e colocado em um USB com opções de dados "Persistentes", você terá o que deseja.

O problema será que, quando você desconectar a memória USB / disco rígido, o disco será desmontado, e assim, mesmo quando você voltar a conectar, o USB ficará inacessível, a menos que você faça alguma coisa para recuperar o disco. ponto de montagem para o USB.

No entanto, todos os aplicativos em execução continuarão sendo executados, mesmo se você desconectar ou desmontar o USB.

Uma boa ideia para tentar é garantir que todos os processos necessários sejam carregados na inicialização, o que garantirá que os processos estarão em execução no momento em que você desconectar o USB.

Eu mesmo fiz isso com apenas alguns aplicativos. Estou usando a distro Israel Remix Team que já está pré-carregada com muitos aplicativos com antecedência e, dessa forma, quando o aplicativo é carregado , Posso desconectar a memória USB e o programa continua a execução.

Eu não tentei recursos pesados exigindo programas, mas no meu caso:

1. O compartilhamento de arquivos continua funcionando e compartilhamento de arquivos, mesmo quando esses arquivos estiverem em uma unidade de disco rígido fixa, além do sistema de arquivos USB.
2. VLC continua tocando um rádio transmissão da estação sem problemas,
3. Yakuake continua o trabalho e faz o que eu peço a menos que eu queira algo do USB desconectado
4. O Google Chrome continua navegando web e me permitem fazer vários coisas como monitorar câmeras ip.

O único problema é quando tento conectar o USB para executar um novo aplicativo, que não será alcançado pela instância do sistema operacional em execução no momento, então tenho que reinicializar para iniciar um novo aplicativo ao lado daqueles que são carregados na inicialização.

Outra boa idéia seria usar o recurso para "Lembrar aplicativos atualmente em execução" na janela de preferências "Sistema / Preferências / Aplicativos de inicialização". Qual (quando habilitado) irá "lembrar" todos os programas que você está usando e irá reabri-los após uma reinicialização ou ao iniciar o sistema pela primeira vez em um dia.

Se você deseja remover um aplicativo deste recurso, basta fechá-lo e ir para esta função e pressione o botão "Lembrar aplicativos atualmente em execução" para atualizar a lista dos programas que serão abertos na próxima vez.

Uma captura de tela é colocada aqui para ilustrar.

Então, levando em consideração o que eu digo acima, vale a pena realizar o próximo experimento:

Guia do disco de inicialização USB:

Primeiro de tudo, você pode fazer um disco de inicialização USB usando uma GUI, o que facilitará a tarefa. Infelizmente, isso só pode ser feito quando dentro de um sistema Ubuntu, tanto a sessão Live quanto o sistema instalado podem fazer o truque.

Eu sei que as pessoas podem sugerir que você siga alguns outros procedimentos bem-sucedidos, mas, no meu caso, falarei sobre o "Criador de discos de inicialização".

Em várias distribuições do Linux, você pode encontrar essa ferramenta em "Criador de sistema / administração / disco de inicialização". Eu sugiro que você experimente a Equipe Israel Remix , a que eu uso, mas quase qualquer distribuição deve ter esta ferramenta.

Uma captura de tela é colocada aqui para você ver a ferramenta quando aberta recentemente:

Certifique-se de ter baixado sua distribuição preferida do Ubuntu antes de tentar isso em uma sessão ao vivo.

Na janela "Make Startup Disk", clique no botão "Other" no canto superior direito para escolher a iso da sua distribuição Linux que você baixou anteriormente e já inseriu o USB que você vai usar para o processo. Tanto o ".iso" quanto o USB devem aparecer em suas respectivas áreas.

NOTA: Se você for usar um DVD pré-gravado para o processo, simplesmente insira o DVD na bandeja e ele será listado na lista de fontes como mostrado na próxima imagem:

No meu caso, minha memória USB de 4 GB já tem uma sessão ao vivo já instalada, o que eu vou fazer primeiro é clicar no "Erase Disk" para reunir espaço suficiente para o sistema, depois disso eu vou obter as opções para o tratamento de dados, em que eu vou escolher a quantidade de tamanho de disco que eu gostaria de usar para salvar dados e configurações (como instalar programas, etc.) Eu vou usar 1,4 GB para esse fim. / p>

Agora clico em "Make Startup Disk" e o processo de cópia vai acontecer.

Após o qual o GRUB também deve ser instalado. Infelizmente, o processo de instalação do GRUB foi muito rápido, então não pude tirar a foto.

O arquivo de persistência será criado.

Então você poderá começar a partir desse USB. Observe que você pode usar memórias USB ou unidades de disco rígido USB, mesmo quando em uso com um adaptador, IDE para USB ou SATA para USB.

Isso deve funcionar como você deseja, pelo menos me faz feliz com os resultados.

Boa sorte!

    

Answer 3

Eu tenho trabalhado nisso. Uma configuração de livecd-to-usb não estava funcionando muito bem para mim. Eu criei uma versão modificada do script "local" para o servidor ubuntu 11.04. Depois de aplicar o patch (ou manualmente editar localmente com as mudanças, é claro) você precisa apenas de update-iniramfs -u, e boot linux com um argumento de kernel "ramboot", e seu sistema irá inicializar um sistema linux normal completamente em ram. Fazer alterações persistentes é tão fácil quanto rsyncar o sistema de arquivos ramdisk no dispositivo de inicialização. No meu caso, uma caneta usb, mas poderia ser facilmente qualquer dispositivo de bloco inicializável adequado. Você pode, é claro, apenas reiniciar sem o argumento "ramboot" e fazer mudanças, já que você estará de volta no dispositivo de bloco, e então reiniciará no ramboot novamente, mas não há necessidade, exceto deixar bem claro quando você está em qual estado.

0) "sudo su"

(você não tem que fazer este passo, mas então você precisa ter certeza de que você suou tudo o que possa exigir) Eu tendo apenas "sudo su" quando estou fazendo este tipo de modificações de sistemas.

1) faça o download ou copie / cole o conteúdo deste patch em um arquivo:

"/ usr / share / initramfs-tools / scripts / ramboot.patch" - não poderia incluir pastebin, newbie. incluído no final

2) cd / usr / share / initramfs-tools / scripts; cp local local.bak #apenas no caso

3) remendo local ramboot.patch

Isso aplica as alterações definidas no ramboot.patch ao seu script local. / usr / share / initramfs-tools / scripts / local é o configurador de script de inicialização normal que configura a função rootmount para init. O patch foi criado por "diff local local.modified & gt; ramboot.patch"

4) cp / bin / busybox / usr / lib / initramfs-tools / bin / busybox

Isso torna o arquivo initramfs.img um pouco maior do que seria normalmente, mas a diferença é de cerca de 1,5 megabytes, não major. Eu queria a saída legível por humanos do df -h, que o df do busybox despojado não suporta. Se você se preocupa em manter a versão de 300k do busybox, certifique-se de cp / usr / lib / initramfs-tools / bin / busybox / small_busybox e, em seguida, retorne ao seu nome / local anterior após a etapa 5.

5) update-initramfs -u

6) opcional você provavelmente irá querer criar um /etc/grub.d/06_custom, com o argumento do kernel "ramboot" incluído, e um título que implica isso.

(ou 40_custom se você quiser que a entrada do menu ramboot esteja no final da lista, em vez de no topo) por exemplo. 06_custom - não foi possível incluir o link pastebin, novato aqui.

você precisará preencher sua versão do kernel e initrd.img-verion corretos e também o sistema de arquivos uuid do seu dispositivo raiz neste arquivo 06_custom ou então não funcionará.

você pode encontrar as informações do kernel / initrd.img olhando apenas em / boot / com "ls / boot" e o seguinte comando deve mostrar o seu sistema de arquivos raiz uuid:

blkid | grep 'df / | grep dev | cortar -d' '-f1' | cortar -d '"' -f2

Uma vez que seu 06_custom tem os caminhos e nomes de arquivos uuid, kernel e initrm.img corretos, você pode atualizar o grub e testá-lo!

7) update-grub para adicionar as entradas personalizadas ao seu arquivo /boot/grub/grub.cfg.

Nota: Eu tenho um pequeno sistema com a partição raiz, incluindo apenas cerca de 1,2 g de dados para copiar em memória RAM. Se o seu sistema não tiver memória sobressalente suficiente, este script inicializará com segurança normalmente (ou pelo menos tentará!) Encontrei remastersys e instalações persistentes de usb-casper para não serem exatamente adequadas às minhas necessidades.

Isso é usado em um servidor scst-iscsi atualmente, e é apenas uma fraqueza real se você não salvar as alterações no sistema e perder energia, ou algum outro erro (init 0, oh não, eu esqueci de verifique meu trabalho de volta ao subversion! disaster!) então o sistema ramdisk não faz nada persistente. Eu ainda não tenho uma tonelada de tempo nessa configuração, mas desde que eu procurei por esse tipo de informação, encontrei muitas maneiras que não eram exatamente adequadas, ou simplesmente confusas para mim, eu pensei Coloque isso lá fora. talvez isso salve alguém com um pequeno dente puxando * 8 ^)

remastersys e os scripts root-ro me ajudaram nesse ponto. ambos são projetos úteis, mas diferentes. O remastersys empacota seu sistema em execução, tanto para implantar / clonar, quanto para rodar como uma versão live.iso do sistema, ou backup, eu acho. root-ro é um sistema de arquivos dual-ramdisk sistema de arquivos montado no estilo de união, com o ramdisk gravável, e o blockdev somente leitura. então para sincronizar você pode simplesmente remontar o blockdev rw, rsync uma ramificação para a outra e remontá-lo novamente. Isso era quase perfeito, mas eu queria que a caneta usb fosse desmontada / pudesse ser removida e o sistema manteria seu estado, o que esta solução faz.

raiz-ro inferior da página - link

remastersys - link

Você pode facilmente rsync ou copiar -r a partir do ramboot (montado em /) e do disco / dispositivo de onde ele veio originalmente quando rodando em memória ram, para tornar essa mudança "persistente". Eu salvo o uuid do dispositivo que o ramboot inicializou, para que você possa sempre encontrá-lo depois. Está em /.bootdisk_byuuid no ramdisk, e você pode facilmente configurar um script para montar este dispositivo em algum lugar, fazer o rsync, e desmontá-lo novamente, e chamar esse script de "ramtodisk" ou qualquer outra coisa.

NB! você pode querer fazer o backup de seu arquivo /boot/initrd.img para que, caso algo dê errado, seu sistema ainda seja inicializável. Eu salvei o meu para / boot / initrd enquanto trabalhava nisso. quando eu tinha problemas com o grub / init, eu apenas editei meu initrd para apontar para o arquivo backup / boot / initrd e voltei para a depuração. de qualquer forma, eu estou supondo que isso é mais orientações não livro de receitas. diverta-se! leva meu sistema de 1.2gig 9: 30ish para inicializar em usb 1.1, 1: 30-45 em usb 2.0 e ~ = 35 segundos em usb 3.0 para carregar em ram. mais e mais suculenta a cada ano! * 8 ^)

aqui está o ramboot.patch

2a3,13
> parse_cmdline() {
>     RAM=""
>     for x in $(cat /proc/cmdline); do
>         case $x in
>           ramboot)
>               RAM="Yes" ;;
>             quiet)
>                 quiet=y ;;
>         esac
>     done
> }
66c77
<
---
>       parse_cmdline
90,91c101,164
<       # Mount root
<       mount ${roflag} ${FSTYPE:+-t ${FSTYPE} }${ROOTFLAGS} ${ROOT} ${rootmnt}
---
>       # Mount root - custom ramboot.patch
>       # By: Justin Perkins -- 4/25/12 Email: [email protected]
>       if [ -z "${RAM}" ]; then
>               mount ${roflag} ${FSTYPE:+-t ${FSTYPE} }${ROOTFLAGS} ${ROOT} ${rootmnt}
>       else
>               mkdir /ramboot
>               mount ${roflag} -t ${FSTYPE} ${ROOTFLAGS} ${ROOT} /ramboot
>               log_begin_msg "Detecting system resources"
>               size=$(df|grep ramboot|tr -s ' '|cut -d ' ' -f3)
>               datasize=${size}
>               size=$(expr ${size} + ${size} / 20 )    #5% more to be sure
>               freespace=$(awk '/^MemFree:/{f=} /^Cached:/{c=} END{print f+c}' /proc/meminfo)
>               log_end_msg
>               if [ "${freespace}" -lt "${size}" ] ; then
>                       echo "Not enough system RAM, ${freespace}k > ${size}k."
>                       echo "Attempting normal rootmount."
>                       mount ${roflag} ${FSTYPE:+-t ${FSTYPE} }${ROOTFLAGS} ${ROOT} ${rootmnt}
>               else
>                       if [ "$quiet" != "y" ] ; then
>                               tstart_min=$(date|cut -d ' ' -f4|cut -d : -f2)
>                               tstart_sec=$(date|cut -d ' ' -f4|cut -d : -f3)
>                               mount -t tmpfs -o size=100% none ${rootmnt}
>                               cd ${rootmnt}
>                               size=$(df -h|grep ramboot|tr -s ' '|cut -d ' ' -f3)     #reuse size
>                               echo "System size: ${size} (${datasize}k) this may take a couple of minutes."
>                               log_begin_msg "Copying system files into RAM"
>                               echo -e -n "\b"
>                               cp -rfa /ramboot/* ${rootmnt} &
>                               pid=$!
>                               while [ ! ${pid} == "done" ] ; do
>                                       alive=$(ps -o pid,args|grep -E ${pid}|grep -v grep)
>                                       alive=$(echo ${alive}|cut -d ' ' -f1)
>                                       if [ -z ${alive} ] ; then pid="done" ; fi
>                                       printf "."
>                                       sleep 1
>                               done
>                               log_end_msg
>                               echo ${ROOT} > ${rootmnt}/.bootdisk_byuuid
>                               tend_min=$(date|cut -d ' ' -f4|cut -d : -f2)
>                               tend_sec=$(date|cut -d ' ' -f4|cut -d : -f3)
>                               if [ ${tend_sec} -lt ${tstart_sec} ] ; then
>                                       tend_sec=$(expr ${tend_sec} + 60)
>                                       tend_min=$(expr ${tend_min} - 1)
>                               fi
>                               if [ ${tend_min} -lt ${tstart_min} ] ; then
>                                       tend_min=$(expr ${tend_min} + 60)
>                           fi
>                           tduration_min=$(expr ${tend_min} - ${tstart_min})
>                           tduration_sec=$(expr ${tend_sec} - ${tstart_sec})
>                           echo "Copy complete, duration: $tduration_min minutes $tduration_sec seconds."
>                           freespace=$(awk '/^MemFree:/{f=} END{print f}' /proc/meminfo)
>                           freespace=$(expr ${freespace} + 425000)         #this accounts for the temporal settling issue
>                           echo "You have approximately ${freespace}k free RAM after loading the ramboot."
>                           if [ ${freespace} -lt "502400" ] ; then echo "Warning! you have critically low system RAM free after ramboot." ; fi
>
>                   else
>                           cp -rfa /ramboot/* ${rootmnt}
>                           echo ${ROOT} > ${rootmnt}/.bootdisk_byuuid
>                           freespace=$(awk '/^MemFree:/{f=} END{print f}' /proc/meminfo)
>                           if [ ${freespace} -lt "102400" ] ; then echo "Warning! you have critically low system RAM free after ramboot." ; fi
>                   fi
>           fi
>           umount /ramboot
>   fi      #end custom ramboot.patch

06_custom

#!/bin/sh
exec tail -n +3 %pre%
# This file provides an easy way to add custom menu entries.  Simply type the
# menu entries you want to add after this comment.  Be careful not to change
# the 'exec tail' line above.
#uuid_<placeholder>, and vmlinuz-<placeholder>, and initrd.img-<placeholder> and
#set root='(hd0,2)' need to be replaced with your system's values, although, if you
#get the hd0,2 wrong, but the uuid correct, grub will grep around and find it anyhow. 
menuentry "Ubuntu, with Linux Custom-Ramboot" {
    recordfail
    set root='(hd0,2)'
    search --no-floppy --fs-uuid --set=root uuid_placeholder
    linux /boot/vmlinuz-<placeholder> root=UUID=<uuid-placeholder> ro ramboot
    initrd /boot/initrd.img-<placeholder>
}

    

Answer 4

Eu acho que o filhote de cachorro linux agora é baseado no ubuntu, e é muito pequeno e facilmente carregado na RAM.