23.5. Atualizando o FreeBSD a partir do código fonte
Anterior | Capítulo 23. Atualização e Upgrade do FreeBSD | Próxima

## 23.5. Atualizando o FreeBSD a partir do código fonte

A atualização do FreeBSD através da compilação a partir do código-fonte oferece várias vantagens sobre as atualizações binárias. O código pode ser compilado com opções para aproveitar o hardware específico. Partes do sistema base podem ser compiladas com configurações não padrões, ou deixadas de fora somente onde não são necessárias ou desejadas. O processo de compilação leva mais tempo para atualizar um sistema do que apenas instalar atualizações binárias, mas permite customização completa para produzir uma versão do FreeBSD adaptada as suas necessidades.

### 23.5.1. Inicio Rápido

Esta é uma referência rápida para as etapas típicas usadas para atualizar o FreeBSD compilando-o a partir do código fonte. As seções posteriores descrevem o processo com mais detalhes.

- Atualizar e Compilar

      # svnlite update /usr/src
      check /usr/src/UPDATING
      # cd /usr/src
      # make -j4 buildworld
      # make -j4 kernel
      # shutdown -r now
      # cd /usr/src
      # make installworld
      # mergemaster -Ui
      # shutdown -r now

  | Obtenha a versão mais recente do código fonte. Veja Seção 23.5.3, “Atualizando o código fonte” para maiores informações sobre como obter e atualizar o código fonte.
  | Verifique o `/usr/src/UPDATING` para quaisquer etapas manuais necessárias antes ou depois de compilar a partir do código fonte.
  | Vá para o diretório de origem.
  | Compile o mundo, tudo exceto o kernel.
  | Compile e instale o kernel. Isso é equivalente a `make installkernel installkernel`.
  | Reinicialize o sistema com o novo kernel.
  | Vá para o diretório de origem.
  | Instale o mundo.
  | Atualize e mescle os arquivos de configuração em `/etc/`.
  | Reinicie o sistema para usar o mundo e o kernel recém-compilados.

### 23.5.2. Preparando-se para uma atualização a partir do código fonte

Leia o `/usr/src/UPDATING`. Quaisquer etapas manuais que devem ser executadas antes ou depois de uma atualização são descritas neste arquivo.

### 23.5.3. Atualizando o código fonte

O código fonte do FreeBSD está localizado em `/usr/src/`. O método preferido para atualizar os fontes é através do sistema de controle de versão do Subversion. Verifique se o código-fonte está sob controle de versão:

    # svnlite info /usr/src
    Path: /usr/src
    Working Copy Root Path: /usr/src
    ...

Isto indica que o `/usr/src/` está sob controle de versão e pode ser atualizado com o svnlite(1):

    # svnlite update /usr/src

O processo de atualização pode levar algum tempo se o diretório não tiver sido atualizado recentemente. Após a conclusão, o código-fonte estará atualizado e o processo de compilação descrito na próxima seção poderá começar.

### Obtendo o código fonte:

Se a saída disser que `'/usr/src' is not a working copy`, estão faltando arquivos no diretório ou eles foram instalados com um método diferente. Um novo checkout da fonte é necessário.

Tabela 23.1. Versões do FreeBSD e Caminhos do Repositório

Saída do `uname -r` | Caminho do Repositório | Descrição
--- | --- | ---
``X.Y`-RELEASE` | `base/releng/``X.Y` | A versão do release mais apenas correções críticas de segurança e correção de erros. Este ramo é recomendado para a maioria dos usuários.
``X.Y`-STABLE` | `base/stable/``X` | A versão de Release mais todos os desenvolvimentos adicionais nesse ramo. O STABLE refere-se à interface binária de aplicativos (ABI) não sendo alterada, portanto, o software compilado para versões anteriores ainda é executado. Por exemplo, o software compilado para rodar no FreeBSD 10.1 ainda rodará no FreeBSD 10-STABLE compilado posteriormente. Os ramos STABLE ocasionalmente possuem bugs ou incompatibilidades que podem afetar os usuários, embora sejam normalmente corrigidos rapidamente.
``X`-CURRENT` | `base/head/` | A mais recente versão de desenvolvimento do FreeBSD. A ramificação CURRENT pode ter grandes erros ou incompatibilidades e é recomendada apenas para usuários avançados.

Determine qual versão do FreeBSD está sendo usada com uname(1):

    # uname -r
    10.3-RELEASE

Baseado em Tabela 23.1, “Versões do FreeBSD e Caminhos do Repositório”, a fonte usada para atualizar `10.3-RELEASE` tem como caminho de repositório `base/releng/10.3`. Este caminho é usado ao verificar a fonte:

    # mv /usr/src /usr/src.bak
    # svnlite checkout https://svn.freebsd.org/base/releng/10.3 /usr/src

| Mova o diretório antigo para fora do caminho. Se não houver modificações locais nesse diretório, ele poderá ser excluído.
| O caminho da Tabela 23.1, “Versões do FreeBSD e Caminhos do Repositório” é adicionado a URL repositório . O terceiro parâmetro é o diretório de destino do código-fonte no sistema local.

### 23.5.4. Compilando a partir do código-fonte

O world, ou todo o sistema operacional, exceto o kernel, é compilado. Isso é feito primeiro para fornecer ferramentas atualizadas para construir o kernel. Então o próprio kernel é construído:

    # cd /usr/src
    # make buildworld
    # make buildkernel

O código compilado é escrito em `/usr/obj`.

Estes são os passos básicos. Opções adicionais para controlar a compilação são descritas abaixo.

#### 23.5.4.1. Executando uma compilação limpa

Algumas versões do sistema de compilação do FreeBSD deixam o código previamente compilado no diretório de objetos temporários, `/usr/obj`. Isso pode acelerar as compilações posteriores, evitando recompilar o código que não foi alterado. Para forçar uma reconstrução limpa de tudo, use `cleanworld` antes de iniciar uma construção:

    # make cleanworld

#### 23.5.4.2. Definindo o Número de Jobs

Aumentar o número de jobs de compilação em processadores com vários núcleos pode melhorar a velocidade de construção. Determine o número de núcleos com `sysctl hw.ncpu`. Os processadores variam, assim como os sistemas de compilação usados ​​com diferentes versões do FreeBSD, portanto, o teste é o único método seguro para determinar como um número diferente de tarefas afeta a velocidade de compilação. Como ponto de partida, considere valores entre metade e o dobro do número de núcleos. O número de jobs é especificado com a opção `-j`.

Exemplo 23.1. Aumentando o número de jobs de compilação

Compilando o mundo e o kernel com quatro jobs:

    # make -j4 buildworld buildkernel

#### 23.5.4.3. Compilando Apenas o Kernel

Um `buildworld` deve ser completado se o código-fonte for alterado. Depois disso, um `buildkernel` para compilar um kernel pode ser executado a qualquer momento. Para compilar apenas o kernel:

    # cd /usr/src
    # make buildkernel

#### 23.5.4.4. Compilando um Kernel Customizado

O kernel padrão do FreeBSD é baseado em um arquivo de configuração do kernel chamado `GENERIC`. O kernel `GENERIC` inclui os drivers e opções de dispositivos mais comumente necessários. Às vezes, é útil ou necessário criar um kernel personalizado, adicionando ou removendo drivers de dispositivo ou opções para atender a uma necessidade específica.

Por exemplo, alguém que desenvolve um pequeno computador embarcado com RAM severamente limitada pode remover drivers de dispositivo desnecessários ou opções para tornar o kernel um pouco menor.

Os arquivos de configuração do Kernel estão localizados em `/usr/src/sys/`arch`/conf/`, onde `arch` é a saída do `uname - m`. Na maioria dos computadores, a saida será `amd64`, resultando no diretório de arquivos de configuração `/usr/src/sys/`amd64`/conf/`.

### Dica:

O `/usr/src` pode ser deletado ou recriado, então é preferível manter os arquivos de configuração do kernel em um diretório separado, como por exemplo em `/root`. Vincule o arquivo de configuração do kernel ao diretório `conf`. Se esse diretório for excluído ou sobrescrito, a configuração do kernel pode ser vinculada novamente ao novo.

Um arquivo de configuração personalizado pode ser criado copiando o arquivo de configuração `GENERIC`. Neste exemplo, o novo kernel personalizado é para um servidor de armazenamento, portanto, é denominado `STORAGESERVER`:

    # cp /usr/src/sys/amd64/conf/GENERIC /root/STORAGESERVER
    # cd /usr/src/sys/amd64/conf
    # ln -s /root/STORAGESERVER .

O `/root/STORAGESERVER` é então editado, adicionando ou removendo dispositivos ou opções como mostrado em config(5).

O kernel personalizado é compilado pela configuração `KERNCONF` no arquivo de configuração do kernel na linha de comando:

    # make buildkernel KERNCONF=STORAGESERVER

### 23.5.5. Instalando o código compilado

Depois que as etapas `buildworld` e `buildkernel` forem concluídas, o novo kernel e o restante do sistema base serão instalados:

    # cd /usr/src
    # make installkernel
    # shutdown -r now
    # cd /usr/src
    # make installworld
    # shutdown -r now

Se um kernel customizado foi compilado, `KERNCONF` também deve ser configurado para usar o novo kernel customizado:

    # cd /usr/src
    # make installkernel KERNCONF=STORAGESERVER
    # shutdown -r now
    # cd /usr/src
    # make installworld
    # shutdown -r now

### 23.5.6. Concluindo a atualização

Algumas tarefas finais completam a atualização. Quaisquer arquivos de configuração que tenham sido modificados serão mesclado com as novas versões, as bibliotecas desatualizadas são localizadas e removidas e, em seguida, o sistema é reiniciado.

#### 23.5.6.1. Mesclando arquivos de configuração com o mergemaster(8)

O mergemaster(8) fornece uma maneira fácil de mesclar as alterações feitas nos arquivos de configuração do sistema com novas versões desses arquivos.

Com a opção `-Ui`, o mergemaster(8) atualizará automaticamente os arquivos que não foram modificados pelo usuário e instalará os novos arquivos que ainda não estiverem presentes:

    # mergemaster -Ui

Se um arquivo precisar ser mesclado manualmente, uma exibição interativa permitirá que o usuário escolha quais partes dos arquivos serão mantidas. Veja mergemaster(8) para maiores informações.

#### 23.5.6.2. Verificando Arquivos e Bibliotecas Desatualizados

Alguns arquivos ou diretórios obsoletos podem permanecer após uma atualização. Esses arquivos podem ser localizados:

    # make check-old

e excluído:

    # make delete-old

Algumas bibliotecas obsoletas também podem permanecer. Estes podem ser detectados com:

    # make check-old-libs

e deletado com

    # make delete-old-libs

Os programas que ainda estavam usando estas bibliotecas antigas deixarão de funcionar quando a biblioteca for excluída. Estes programas devem ser recompilados ou substituídos após a exclusão das bibliotecas antigas.

### Dica:

Quando todos os arquivos ou diretórios antigos forem considerados seguros para serem excluídos, a ação de pressionar y e Enter para excluir cada arquivo poderá ser evitada configurando a variável `BATCH_DELETE_OLD_FILES` no comando. Por exemplo:

    # make BATCH_DELETE_OLD_FILES=yes delete-old-libs

#### 23.5.6.3. Reiniciando após a atualização

A última etapa após a atualização é reiniciar o computador para que todas as alterações entrem em vigor:

    # shutdown -r now

Anterior | Acima | Próxima
23.4. Acompanhando um ramo de desenvolvimento | Principal | 23.6. Atualização de várias máquinas

All FreeBSD documents are available for download at https://download.freebsd.org/ftp/doc/

Questions that are not answered by the documentation may be sent to <freebsd-questions@FreeBSD.org>.
Send questions about this document to <freebsd-doc@FreeBSD.org>.