From c57631d87613cb9a2090e1450f7a97f4568434b8 Mon Sep 17 00:00:00 2001 From: Matheus Santos Date: Sun, 26 Apr 2026 14:35:31 -0300 Subject: [PATCH 1/2] pt-br/arch-handbook/kobj: Sync with en 3dcfad6 --- .../books/arch-handbook/kobj/_index.adoc | 259 ++++++++ .../pt-br/books/arch-handbook/kobj/_index.po | 629 ++++++++++++++++++ 2 files changed, 888 insertions(+) create mode 100644 documentation/content/pt-br/books/arch-handbook/kobj/_index.adoc create mode 100644 documentation/content/pt-br/books/arch-handbook/kobj/_index.po diff --git a/documentation/content/pt-br/books/arch-handbook/kobj/_index.adoc b/documentation/content/pt-br/books/arch-handbook/kobj/_index.adoc new file mode 100644 index 00000000000..73b1636b0dc --- /dev/null +++ b/documentation/content/pt-br/books/arch-handbook/kobj/_index.adoc @@ -0,0 +1,259 @@ +--- +description: 'Objetos do Kernel' +next: books/arch-handbook/jail +params: + path: /books/arch-handbook/kobj/ +prev: books/arch-handbook/locking +showBookMenu: 'true' +tags: ["kernel objects", "kobj", "guide", "FreeBSD"] +title: 'Capítulo 3. Objetos do Kernel' +weight: 4 +--- + +[[kernel-objects]] += Objetos do Kernel +:doctype: book +:toc: macro +:toclevels: 1 +:icons: font +:sectnums: +:sectnumlevels: 6 +:sectnumoffset: 3 +:partnums: +:source-highlighter: rouge +:experimental: +:images-path: books/arch-handbook/ + +ifdef::env-beastie[] +ifdef::backend-html5[] +:imagesdir: ../../../../images/{images-path} +endif::[] +ifndef::book[] +include::shared/authors.adoc[] +include::shared/mirrors.adoc[] +include::shared/releases.adoc[] +include::shared/attributes/attributes-{{% lang %}}.adoc[] +include::shared/{{% lang %}}/teams.adoc[] +include::shared/{{% lang %}}/mailing-lists.adoc[] +include::shared/{{% lang %}}/urls.adoc[] +toc::[] +endif::[] +ifdef::backend-pdf,backend-epub3[] +include::../../../../../shared/asciidoctor.adoc[] +endif::[] +endif::[] + +ifndef::env-beastie[] +toc::[] +include::../../../../../shared/asciidoctor.adoc[] +endif::[] + +O Kernel Objects, ou _Kobj_, fornece um sistema de programação C orientado a objetos para o kernel. Dessa forma, os dados que estão sendo manipulados carregam a descrição de como operar sobre eles. Isso permite que operações sejam adicionadas e removidas de uma interface em tempo de execução, sem quebrar a compatibilidade binária. + +[[kernel-objects-term]] +== Terminologia + +Objeto:: +Um conjunto de dados - estrutura de dados - alocação de dados. + +Método:: +Uma operação - Função. + +Classe:: +Um ou mais métodos. + +Interface:: +Um padrão de conjunto de um ou mais métodos. + +[[kernel-objects-operation]] +== Operação Kobj + +Kobj funciona gerando descrições de métodos. Cada descrição contém um ID único, bem como uma função padrão. O endereço da descrição é usado para identificar exclusivamente o método dentro da tabela de métodos de uma classe. + +Uma classe é construída criando-se uma tabela de métodos que associa uma ou mais funções às suas descrições. Antes de ser utilizada, a classe é compilada. A compilação aloca um cache e o associa à classe. Um ID único é atribuído a cada descrição de método dentro da tabela de métodos da classe, caso ainda não tenha sido atribuído por outra compilação de classe referenciadora. Para cada método a ser utilizado, uma função é gerada por script para qualificar os argumentos e referenciar automaticamente a descrição do método para uma busca. A função gerada busca o método utilizando o ID único associado à descrição do método como um hash no cache associado à classe do objeto. Se o método não estiver em cache, a função gerada utiliza a tabela da classe para encontrar o método. Se o método for encontrado, a função associada dentro da classe é utilizada; caso contrário, a função padrão associada à descrição do método é utilizada. + +Essas indireções podem ser visualizadas da seguinte forma: + +[.programlisting] +.... +objeto->cache<->classe +.... + +[[kernel-objects-using]] +== Usando Kobj + +=== Estruturas + +[.programlisting] +.... +struct kobj_method +.... + +=== Funções + +[.programlisting] +.... +void kobj_class_compile(kobj_class_t cls); +void kobj_class_compile_static(kobj_class_t cls, kobj_ops_t ops); +void kobj_class_free(kobj_class_t cls); +kobj_t kobj_create(kobj_class_t cls, struct malloc_type *mtype, int mflags); +void kobj_init(kobj_t obj, kobj_class_t cls); +void kobj_delete(kobj_t obj, struct malloc_type *mtype); +.... + +=== Macros + +[.programlisting] +.... +KOBJ_CLASS_FIELDS +KOBJ_FIELDS +DEFINE_CLASS(name, methods, size) +KOBJMETHOD(NAME, FUNC) +.... + +=== Cabeçalhos + +[.programlisting] +.... + + +.... + +=== Criando um modelo de interface + +O primeiro passo para usar o Kobj é criar uma interface. A criação da interface envolve a criação de um modelo que o script [.filename]#src/sys/kern/makeobjops.pl# pode usar para gerar o cabeçalho e o código para as declarações de métodos e funções de busca de métodos. + +Neste modelo, são utilizadas as seguintes palavras-chave: `#include`, `INTERFACE`, `CODE`, `EPILOG`, `HEADER`, `METHOD`, `PROLOG`, `STATICMETHOD` e `DEFAULT`. + +A declaração `#include` e o que a segue são copiados literalmente para o cabeçalho do arquivo de código gerado. + +Por exemplo: + +[.programlisting] +.... +#include +.... + +A palavra-chave `INTERFACE` é usada para definir o nome da interface. Esse nome é concatenado com cada nome de método como [interface name]_[method name]. Sua sintaxe é INTERFACE [interface name];. + +Por exemplo: + +[.programlisting] +.... +INTERFACE foo; +.... + +A palavra-chave `CODE` copia seus argumentos literalmente para o arquivo de código. Sua sintaxe é `CODE { [qualquer coisa] };` + +Por exemplo: + +[.programlisting] +.... +CODE { + struct foo * foo_alloc_null(struct bar *) + { + return NULL; + } +}; +.... + +A palavra-chave `HEADER` copia seus argumentos literalmente para o arquivo de cabeçalho. Sua sintaxe é `HEADER { [qualquer coisa] };` + +Por exemplo: + +[.programlisting] +.... +HEADER { + struct mumble; + struct grumble; +}; +.... + +A palavra-chave `METHOD` descreve um método. Sua sintaxe é `METHOD [tipo de retorno] [nome do método] { [objeto [, argumentos]] };` + +Por exemplo: + +[.programlisting] +.... +METHOD int bar { + struct object *; + struct foo *; + struct bar; +}; +.... + +A palavra-chave `DEFAULT` pode seguir a palavra-chave `METHOD`. Ela estende a palavra-chave `METHOD` para incluir a função padrão do método. A sintaxe estendida é: `METHOD [tipo de retorno] [nome do método] { [objeto; [outros argumentos]] }DEFAULT [função padrão];` + +Por exemplo: + +[.programlisting] +.... +METHOD int bar { + struct object *; + struct foo *; + int bar; +} DEFAULT foo_hack; +.... + +A palavra-chave `STATICMETHOD` é usada de forma semelhante à palavra-chave `METHOD`, exceto pelo fato de que os dados Kobj não estão no início da estrutura do objeto, portanto, a conversão para kobj_t seria incorreta. Em vez disso, `STATICMETHOD` depende da referência aos dados Kobj como 'ops'. Isso também é útil para chamar métodos diretamente da tabela de métodos de uma classe. + +Os conjuntos de palavras-chave `PROLOG` e `EPILOG` inserem código imediatamente antes ou diretamente depois do `METHOD` ao qual estão associados. Esse recurso é usado principalmente para criar perfis em situações onde é difícil obter as informações de outra forma. + +Outros exemplos completos: + +[.programlisting] +.... +src/sys/kern/bus_if.m +src/sys/kern/device_if.m +.... + +=== Criando uma classe + +O segundo passo para usar o Kobj é criar uma classe. Uma classe consiste em um nome, uma tabela de métodos e o tamanho dos objetos, caso os recursos de manipulação de objetos do Kobj sejam utilizados. Para criar a classe, use a macro `DEFINE_CLASS()`. Para criar a tabela de métodos, crie um array de `kobj_method_t` terminado por uma entrada `NULL`. Cada entrada não nula pode ser criada usando a macro `KOBJMETHOD()`. + +Por exemplo: + +[.programlisting] +.... +DEFINE_CLASS(fooclass, foomethods, sizeof(struct foodata)); + +kobj_method_t foomethods[] = { + KOBJMETHOD(bar_doo, foo_doo), + KOBJMETHOD(bar_foo, foo_foo), + { NULL, NULL} +}; +.... + +A classe deve ser "compilada". Dependendo do estado do sistema no momento da inicialização da classe, um cache alocado estaticamente, a "tabela de operações" (ops table), precisa ser utilizado. Isso pode ser feito declarando uma `struct kobj_ops` e usando `kobj_class_compile_static();`; caso contrário, deve-se usar `kobj_class_compile()`. + +=== Criando um Objeto + +O terceiro passo para usar o Kobj envolve a definição do objeto. As rotinas de criação de objetos Kobj pressupõem que os dados Kobj estejam no início do objeto. Se isso não for apropriado, você terá que alocar o objeto manualmente e, em seguida, usar `kobj_init()` na parte Kobj do objeto; caso contrário, você pode usar `kobj_create()` para alocar e inicializar a parte Kobj do objeto automaticamente. `kobj_init()` também pode ser usado para alterar a classe que um objeto utiliza. + +Para integrar Kobj ao objeto, você deve usar a macro KOBJ_FIELDS. + +Por exemplo + +[.programlisting] +.... +struct foo_data { + KOBJ_FIELDS; + foo_foo; + foo_bar; +}; +.... + +=== Métodos de Chamada + +O último passo para usar o Kobj é simplesmente utilizar as funções geradas para acessar o método desejado dentro da classe do objeto. Isso é tão simples quanto usar o nome da interface e o nome do método com algumas modificações. O nome da interface deve ser concatenado com o nome do método, separados por um '_', e ambos devem estar em maiúsculas. + +Por exemplo, se o nome da interface fosse foo e o método fosse bar, a chamada seria: + +[.programlisting] +.... +[valor de retorno = ] FOO_BAR(objeto [, outros parâmetros]); +.... + +=== Limpando + +Quando um objeto alocado através de `kobj_create()` não for mais necessário, `kobj_delete()` poderá ser chamado nele, e quando uma classe não estiver mais sendo usada, `kobj_class_free()` poderá ser chamado nela. diff --git a/documentation/content/pt-br/books/arch-handbook/kobj/_index.po b/documentation/content/pt-br/books/arch-handbook/kobj/_index.po new file mode 100644 index 00000000000..7aef9f6d089 --- /dev/null +++ b/documentation/content/pt-br/books/arch-handbook/kobj/_index.po @@ -0,0 +1,629 @@ +# SOME DESCRIPTIVE TITLE +# Copyright (C) YEAR The FreeBSD Project +# This file is distributed under the same license as the FreeBSD Documentation package. +# Danilo G. Baio , 2021. +# Matheus Santos , 2026. +msgid "" +msgstr "" +"Project-Id-Version: FreeBSD Documentation VERSION\n" +"POT-Creation-Date: 2025-05-01 19:56-0300\n" +"PO-Revision-Date: 2026-04-26 16:42+0000\n" +"Last-Translator: Matheus Santos \n" +"Language-Team: Portuguese (Brazil) \n" +"Language: pt_BR\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=2; plural=n > 1;\n" +"X-Generator: Weblate 4.17\n" + +#. type: Title = +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:1 +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:14 +#, no-wrap +msgid "Kernel Objects" +msgstr "Objetos do Kernel" + +#. type: YAML Front Matter: title +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:1 +#, no-wrap +msgid "Chapter 3. Kernel Objects" +msgstr "Capítulo 3. Objetos do Kernel" + +#. type: Plain text +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:54 +msgid "" +"Kernel Objects, or _Kobj_ provides an object-oriented C programming system " +"for the kernel. As such the data being operated on carries the description " +"of how to operate on it. This allows operations to be added and removed " +"from an interface at run time and without breaking binary compatibility." +msgstr "" +"O Kernel Objects, ou _Kobj_, fornece um sistema de programação C orientado a " +"objetos para o kernel. Dessa forma, os dados que estão sendo manipulados " +"carregam a descrição de como operar sobre eles. Isso permite que operações " +"sejam adicionadas e removidas de uma interface em tempo de execução, sem " +"quebrar a compatibilidade binária." + +#. type: Title == +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:56 +#, no-wrap +msgid "Terminology" +msgstr "Terminologia" + +#. type: Labeled list +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:58 +#, no-wrap +msgid "Object" +msgstr "Objeto" + +#. type: Plain text +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:60 +msgid "A set of data - data structure - data allocation." +msgstr "Um conjunto de dados - estrutura de dados - alocação de dados." + +#. type: Labeled list +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:61 +#, no-wrap +msgid "Method" +msgstr "Método" + +#. type: Plain text +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:63 +msgid "An operation - function." +msgstr "Uma operação - Função." + +#. type: Labeled list +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:64 +#, no-wrap +msgid "Class" +msgstr "Classe" + +#. type: Plain text +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:66 +msgid "One or more methods." +msgstr "Um ou mais métodos." + +#. type: Labeled list +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:67 +#, no-wrap +msgid "Interface" +msgstr "Interface" + +#. type: Plain text +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:69 +msgid "A standard set of one or more methods." +msgstr "Um padrão de conjunto de um ou mais métodos." + +#. type: Title == +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:71 +#, no-wrap +msgid "Kobj Operation" +msgstr "Operação Kobj" + +#. type: Plain text +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:76 +msgid "" +"Kobj works by generating descriptions of methods. Each description holds a " +"unique id as well as a default function. The description's address is used " +"to uniquely identify the method within a class' method table." +msgstr "" +"Kobj funciona gerando descrições de métodos. Cada descrição contém um ID " +"único, bem como uma função padrão. O endereço da descrição é usado para " +"identificar exclusivamente o método dentro da tabela de métodos de uma " +"classe." + +#. type: Plain text +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:85 +msgid "" +"A class is built by creating a method table associating one or more " +"functions with method descriptions. Before use the class is compiled. The " +"compilation allocates a cache and associates it with the class. A unique id " +"is assigned to each method description within the method table of the class " +"if not already done so by another referencing class compilation. For every " +"method to be used a function is generated by script to qualify arguments and " +"automatically reference the method description for a lookup. The generated " +"function looks up the method by using the unique id associated with the " +"method description as a hash into the cache associated with the object's " +"class. If the method is not cached the generated function proceeds to use " +"the class' table to find the method. If the method is found then the " +"associated function within the class is used; otherwise, the default " +"function associated with the method description is used." +msgstr "" +"Uma classe é construída criando-se uma tabela de métodos que associa uma ou " +"mais funções às suas descrições. Antes de ser utilizada, a classe é " +"compilada. A compilação aloca um cache e o associa à classe. Um ID único é " +"atribuído a cada descrição de método dentro da tabela de métodos da classe, " +"caso ainda não tenha sido atribuído por outra compilação de classe " +"referenciadora. Para cada método a ser utilizado, uma função é gerada por " +"script para qualificar os argumentos e referenciar automaticamente a " +"descrição do método para uma busca. A função gerada busca o método " +"utilizando o ID único associado à descrição do método como um hash no cache " +"associado à classe do objeto. Se o método não estiver em cache, a função " +"gerada utiliza a tabela da classe para encontrar o método. Se o método for " +"encontrado, a função associada dentro da classe é utilizada; caso contrário, " +"a função padrão associada à descrição do método é utilizada." + +#. type: Plain text +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:87 +msgid "These indirections can be visualized as the following:" +msgstr "Essas indireções podem ser visualizadas da seguinte forma:" + +#. type: delimited block . 4 +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:91 +#, no-wrap +msgid "object->cache<->class\n" +msgstr "objeto->cache<->classe\n" + +#. type: Title == +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:94 +#, no-wrap +msgid "Using Kobj" +msgstr "Usando Kobj" + +#. type: Title === +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:96 +#, no-wrap +msgid "Structures" +msgstr "Estruturas" + +#. type: delimited block . 4 +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:101 +#, no-wrap +msgid "struct kobj_method\n" +msgstr "struct kobj_method\n" + +#. type: Title === +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:103 +#, no-wrap +msgid "Functions" +msgstr "Funções" + +#. type: delimited block . 4 +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:113 +#, no-wrap +msgid "" +"void kobj_class_compile(kobj_class_t cls);\n" +"void kobj_class_compile_static(kobj_class_t cls, kobj_ops_t ops);\n" +"void kobj_class_free(kobj_class_t cls);\n" +"kobj_t kobj_create(kobj_class_t cls, struct malloc_type *mtype, int mflags);\n" +"void kobj_init(kobj_t obj, kobj_class_t cls);\n" +"void kobj_delete(kobj_t obj, struct malloc_type *mtype);\n" +msgstr "" +"void kobj_class_compile(kobj_class_t cls);\n" +"void kobj_class_compile_static(kobj_class_t cls, kobj_ops_t ops);\n" +"void kobj_class_free(kobj_class_t cls);\n" +"kobj_t kobj_create(kobj_class_t cls, struct malloc_type *mtype, int mflags);" +"\n" +"void kobj_init(kobj_t obj, kobj_class_t cls);\n" +"void kobj_delete(kobj_t obj, struct malloc_type *mtype);\n" + +#. type: Title === +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:115 +#, no-wrap +msgid "Macros" +msgstr "Macros" + +#. type: delimited block . 4 +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:123 +#, no-wrap +msgid "" +"KOBJ_CLASS_FIELDS\n" +"KOBJ_FIELDS\n" +"DEFINE_CLASS(name, methods, size)\n" +"KOBJMETHOD(NAME, FUNC)\n" +msgstr "" +"KOBJ_CLASS_FIELDS\n" +"KOBJ_FIELDS\n" +"DEFINE_CLASS(name, methods, size)\n" +"KOBJMETHOD(NAME, FUNC)\n" + +#. type: Title === +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:125 +#, no-wrap +msgid "Headers" +msgstr "Cabeçalhos" + +#. type: delimited block . 4 +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:131 +#, no-wrap +msgid "" +"\n" +"\n" +msgstr "" +"\n" +"\n" + +#. type: Title === +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:133 +#, no-wrap +msgid "Creating an Interface Template" +msgstr "Criando um modelo de interface" + +#. type: Plain text +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:137 +msgid "" +"The first step in using Kobj is to create an Interface. Creating the " +"interface involves creating a template that the script [.filename]#src/sys/" +"kern/makeobjops.pl# can use to generate the header and code for the method " +"declarations and method lookup functions." +msgstr "" +"O primeiro passo para usar o Kobj é criar uma interface. A criação da " +"interface envolve a criação de um modelo que o script [.filename]#src/sys/" +"kern/makeobjops.pl# pode usar para gerar o cabeçalho e o código para as " +"declarações de métodos e funções de busca de métodos." + +#. type: Plain text +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:139 +msgid "" +"Within this template the following keywords are used: `#include`, " +"`INTERFACE`, `CODE`, `EPILOG`, `HEADER`, `METHOD`, `PROLOG`, `STATICMETHOD`, " +"and `DEFAULT`." +msgstr "" +"Neste modelo, são utilizadas as seguintes palavras-chave: `#include`, " +"`INTERFACE`, `CODE`, `EPILOG`, `HEADER`, `METHOD`, `PROLOG`, `STATICMETHOD` " +"e `DEFAULT`." + +#. type: Plain text +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:141 +msgid "" +"The `#include` statement and what follows it is copied verbatim to the head " +"of the generated code file." +msgstr "" +"A declaração `#include` e o que a segue são copiados literalmente para o " +"cabeçalho do arquivo de código gerado." + +#. type: Plain text +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:143 +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:154 +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:164 +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:179 +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:192 +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:207 +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:241 +msgid "For example:" +msgstr "Por exemplo:" + +#. type: delimited block . 4 +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:147 +#, no-wrap +msgid "#include \n" +msgstr "#include \n" + +#. type: Plain text +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:152 +msgid "" +"The `INTERFACE` keyword is used to define the interface name. This name is " +"concatenated with each method name as [interface name]_[method name]. Its " +"syntax is INTERFACE [interface name];." +msgstr "" +"A palavra-chave `INTERFACE` é usada para definir o nome da interface. Esse " +"nome é concatenado com cada nome de método como [interface name]_[method " +"name]. Sua sintaxe é INTERFACE [interface name];." + +#. type: delimited block . 4 +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:158 +#, no-wrap +msgid "INTERFACE foo;\n" +msgstr "INTERFACE foo;\n" + +#. type: Plain text +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:162 +msgid "" +"The `CODE` keyword copies its arguments verbatim into the code file. Its " +"syntax is `CODE { [whatever] };`" +msgstr "" +"A palavra-chave `CODE` copia seus argumentos literalmente para o arquivo de " +"código. Sua sintaxe é `CODE { [qualquer coisa] };`" + +#. type: delimited block . 4 +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:173 +#, no-wrap +msgid "" +"CODE {\n" +"\tstruct foo * foo_alloc_null(struct bar *)\n" +"\t{\n" +"\t\treturn NULL;\n" +"\t}\n" +"};\n" +msgstr "" +"CODE {\n" +"\tstruct foo * foo_alloc_null(struct bar *)\n" +"\t{\n" +"\t\treturn NULL;\n" +"\t}\n" +"};\n" + +#. type: Plain text +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:177 +msgid "" +"The `HEADER` keyword copies its arguments verbatim into the header file. " +"Its syntax is `HEADER { [whatever] };`" +msgstr "" +"A palavra-chave `HEADER` copia seus argumentos literalmente para o arquivo " +"de cabeçalho. Sua sintaxe é `HEADER { [qualquer coisa] };`" + +#. type: delimited block . 4 +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:186 +#, no-wrap +msgid "" +"HEADER {\n" +" struct mumble;\n" +" struct grumble;\n" +"};\n" +msgstr "" +"HEADER {\n" +" struct mumble;\n" +" struct grumble;\n" +"};\n" + +#. type: Plain text +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:190 +msgid "" +"The `METHOD` keyword describes a method. Its syntax is `METHOD [return " +"type] [method name] { [object [, arguments]] };`" +msgstr "" +"A palavra-chave `METHOD` descreve um método. Sua sintaxe é `METHOD [tipo de " +"retorno] [nome do método] { [objeto [, argumentos]] };`" + +#. type: delimited block . 4 +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:200 +#, no-wrap +msgid "" +"METHOD int bar {\n" +"\tstruct object *;\n" +"\tstruct foo *;\n" +"\tstruct bar;\n" +"};\n" +msgstr "" +"METHOD int bar {\n" +"\tstruct object *;\n" +"\tstruct foo *;\n" +"\tstruct bar;\n" +"};\n" + +#. type: Plain text +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:205 +msgid "" +"The `DEFAULT` keyword may follow the `METHOD` keyword. It extends the " +"`METHOD` key word to include the default function for method. The extended " +"syntax is `METHOD [return type] [method name] { [object; [other arguments]] }" +"DEFAULT [default function];`" +msgstr "" +"A palavra-chave `DEFAULT` pode seguir a palavra-chave `METHOD`. Ela estende " +"a palavra-chave `METHOD` para incluir a função padrão do método. A sintaxe " +"estendida é: `METHOD [tipo de retorno] [nome do método] { [objeto; [outros " +"argumentos]] }DEFAULT [função padrão];`" + +#. type: delimited block . 4 +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:215 +#, no-wrap +msgid "" +"METHOD int bar {\n" +"\tstruct object *;\n" +"\tstruct foo *;\n" +"\tint bar;\n" +"} DEFAULT foo_hack;\n" +msgstr "" +"METHOD int bar {\n" +"\tstruct object *;\n" +"\tstruct foo *;\n" +"\tint bar;\n" +"} DEFAULT foo_hack;\n" + +#. type: Plain text +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:220 +msgid "" +"The `STATICMETHOD` keyword is used like the `METHOD` keyword except the kobj " +"data is not at the head of the object structure so casting to kobj_t would " +"be incorrect. Instead `STATICMETHOD` relies on the Kobj data being " +"referenced as 'ops'. This is also useful for calling methods directly out " +"of a class's method table." +msgstr "" +"A palavra-chave `STATICMETHOD` é usada de forma semelhante à palavra-chave " +"`METHOD`, exceto pelo fato de que os dados Kobj não estão no início da " +"estrutura do objeto, portanto, a conversão para kobj_t seria incorreta. Em " +"vez disso, `STATICMETHOD` depende da referência aos dados Kobj como 'ops'. " +"Isso também é útil para chamar métodos diretamente da tabela de métodos de " +"uma classe." + +#. type: Plain text +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:223 +msgid "" +"The `PROLOG` and `EPILOG` keywords sets inserts code immediately before or " +"directly after the `METHOD` they are attached to. This feature is used " +"primarily for profiling situations where it's difficult to obtain the " +"information in another way." +msgstr "" +"Os conjuntos de palavras-chave `PROLOG` e `EPILOG` inserem código " +"imediatamente antes ou diretamente depois do `METHOD` ao qual estão " +"associados. Esse recurso é usado principalmente para criar perfis em " +"situações onde é difícil obter as informações de outra forma." + +#. type: Plain text +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:225 +msgid "Other complete examples:" +msgstr "Outros exemplos completos:" + +#. type: delimited block . 4 +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:230 +#, no-wrap +msgid "" +"src/sys/kern/bus_if.m\n" +"src/sys/kern/device_if.m\n" +msgstr "" +"src/sys/kern/bus_if.m\n" +"src/sys/kern/device_if.m\n" + +#. type: Title === +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:232 +#, no-wrap +msgid "Creating a Class" +msgstr "Criando uma classe" + +#. type: Plain text +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:239 +msgid "" +"The second step in using Kobj is to create a class. A class consists of a " +"name, a table of methods, and the size of objects if Kobj's object handling " +"facilities are used. To create the class use the macro `DEFINE_CLASS()`. " +"To create the method table create an array of kobj_method_t terminated by a " +"NULL entry. Each non-NULL entry may be created using the macro " +"`KOBJMETHOD()`." +msgstr "" +"O segundo passo para usar o Kobj é criar uma classe. Uma classe consiste em " +"um nome, uma tabela de métodos e o tamanho dos objetos, caso os recursos de " +"manipulação de objetos do Kobj sejam utilizados. Para criar a classe, use a " +"macro `DEFINE_CLASS()`. Para criar a tabela de métodos, crie um array de " +"`kobj_method_t` terminado por uma entrada `NULL`. Cada entrada não nula pode " +"ser criada usando a macro `KOBJMETHOD()`." + +#. type: delimited block . 4 +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:245 +#, no-wrap +msgid "DEFINE_CLASS(fooclass, foomethods, sizeof(struct foodata));\n" +msgstr "DEFINE_CLASS(fooclass, foomethods, sizeof(struct foodata));\n" + +#. type: delimited block . 4 +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:251 +#, no-wrap +msgid "" +"kobj_method_t foomethods[] = {\n" +"\tKOBJMETHOD(bar_doo, foo_doo),\n" +"\tKOBJMETHOD(bar_foo, foo_foo),\n" +"\t{ NULL, NULL}\n" +"};\n" +msgstr "" +"kobj_method_t foomethods[] = {\n" +"\tKOBJMETHOD(bar_doo, foo_doo),\n" +"\tKOBJMETHOD(bar_foo, foo_foo),\n" +"\t{ NULL, NULL}\n" +"};\n" + +#. type: Plain text +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:256 +msgid "" +"The class must be \"compiled\". Depending on the state of the system at the " +"time that the class is to be initialized a statically allocated cache, \"ops " +"table\" have to be used. This can be accomplished by declaring a `struct " +"kobj_ops` and using `kobj_class_compile_static();` otherwise, " +"`kobj_class_compile()` should be used." +msgstr "" +"A classe deve ser \"compilada\". Dependendo do estado do sistema no momento " +"da inicialização da classe, um cache alocado estaticamente, a \"tabela de " +"operações\" (ops table), precisa ser utilizado. Isso pode ser feito " +"declarando uma `struct kobj_ops` e usando `kobj_class_compile_static();`; " +"caso contrário, deve-se usar `kobj_class_compile()`." + +#. type: Title === +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:257 +#, no-wrap +msgid "Creating an Object" +msgstr "Criando um Objeto" + +#. type: Plain text +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:263 +msgid "" +"The third step in using Kobj involves how to define the object. Kobj object " +"creation routines assume that Kobj data is at the head of an object. If " +"this in not appropriate you will have to allocate the object yourself and " +"then use `kobj_init()` on the Kobj portion of it; otherwise, you may use " +"`kobj_create()` to allocate and initialize the Kobj portion of the object " +"automatically. `kobj_init()` may also be used to change the class that an " +"object uses." +msgstr "" +"O terceiro passo para usar o Kobj envolve a definição do objeto. As rotinas " +"de criação de objetos Kobj pressupõem que os dados Kobj estejam no início do " +"objeto. Se isso não for apropriado, você terá que alocar o objeto " +"manualmente e, em seguida, usar `kobj_init()` na parte Kobj do objeto; caso " +"contrário, você pode usar `kobj_create()` para alocar e inicializar a parte " +"Kobj do objeto automaticamente. `kobj_init()` também pode ser usado para " +"alterar a classe que um objeto utiliza." + +#. type: Plain text +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:265 +msgid "To integrate Kobj into the object you should use the macro KOBJ_FIELDS." +msgstr "Para integrar Kobj ao objeto, você deve usar a macro KOBJ_FIELDS." + +#. type: Plain text +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:267 +msgid "For example" +msgstr "Por exemplo" + +#. type: delimited block . 4 +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:275 +#, no-wrap +msgid "" +"struct foo_data {\n" +"\tKOBJ_FIELDS;\n" +"\tfoo_foo;\n" +"\tfoo_bar;\n" +"};\n" +msgstr "" +"struct foo_data {\n" +"\tKOBJ_FIELDS;\n" +"\tfoo_foo;\n" +"\tfoo_bar;\n" +"};\n" + +#. type: Title === +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:277 +#, no-wrap +msgid "Calling Methods" +msgstr "Métodos de Chamada" + +#. type: Plain text +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:282 +msgid "" +"The last step in using Kobj is to simply use the generated functions to use " +"the desired method within the object's class. This is as simple as using " +"the interface name and the method name with a few modifications. The " +"interface name should be concatenated with the method name using a '_' " +"between them, all in upper case." +msgstr "" +"O último passo para usar o Kobj é simplesmente utilizar as funções geradas " +"para acessar o método desejado dentro da classe do objeto. Isso é tão " +"simples quanto usar o nome da interface e o nome do método com algumas " +"modificações. O nome da interface deve ser concatenado com o nome do método, " +"separados por um '_', e ambos devem estar em maiúsculas." + +#. type: Plain text +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:284 +msgid "" +"For example, if the interface name was foo and the method was bar then the " +"call would be:" +msgstr "" +"Por exemplo, se o nome da interface fosse foo e o método fosse bar, a " +"chamada seria:" + +#. type: delimited block . 4 +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:288 +#, no-wrap +msgid "[return value = ] FOO_BAR(object [, other parameters]);\n" +msgstr "[valor de retorno = ] FOO_BAR(objeto [, outros parâmetros]);\n" + +#. type: Title === +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:290 +#, no-wrap +msgid "Cleaning Up" +msgstr "Limpando" + +#. type: Plain text +#: documentation/content/en/books/arch-handbook/kobj/_index.adoc:292 +msgid "" +"When an object allocated through `kobj_create()` is no longer needed " +"`kobj_delete()` may be called on it, and when a class is no longer being " +"used `kobj_class_free()` may be called on it." +msgstr "" +"Quando um objeto alocado através de `kobj_create()` não for mais necessário, " +"`kobj_delete()` poderá ser chamado nele, e quando uma classe não estiver " +"mais sendo usada, `kobj_class_free()` poderá ser chamado nela." + +#~ msgid "" +#~ "include::shared/attributes/attributes-{{% lang %}}.adoc[] include::shared/" +#~ "{{% lang %}}/teams.adoc[] include::shared/{{% lang %}}/mailing-lists." +#~ "adoc[] include::shared/{{% lang %}}/urls.adoc[]" +#~ msgstr "" +#~ "include::shared/attributes/attributes-{{% lang %}}.adoc[] include::shared/" +#~ "{{% lang %}}/teams.adoc[] include::shared/{{% lang %}}/mailing-lists." +#~ "adoc[] include::shared/{{% lang %}}/urls.adoc[]" From 3311128fd877267a868257c512369d4f2fcdca48 Mon Sep 17 00:00:00 2001 From: Matheus Santos Date: Sat, 2 May 2026 15:07:04 -0300 Subject: [PATCH 2/2] pt-br/books/arch-handbook/sysinit: Sync with en 3dcfad6 --- .../books/arch-handbook/sysinit/_index.adoc | 165 +++++++ .../books/arch-handbook/sysinit/_index.po | 403 ++++++++++++++++++ 2 files changed, 568 insertions(+) create mode 100644 documentation/content/pt-br/books/arch-handbook/sysinit/_index.adoc create mode 100644 documentation/content/pt-br/books/arch-handbook/sysinit/_index.po diff --git a/documentation/content/pt-br/books/arch-handbook/sysinit/_index.adoc b/documentation/content/pt-br/books/arch-handbook/sysinit/_index.adoc new file mode 100644 index 00000000000..abd48751a5c --- /dev/null +++ b/documentation/content/pt-br/books/arch-handbook/sysinit/_index.adoc @@ -0,0 +1,165 @@ +--- +description: 'O Framework SYSINIT' +next: books/arch-handbook/mac +params: + path: /books/arch-handbook/sysinit/ +prev: books/arch-handbook/jail +showBookMenu: 'true' +tags: ["SYSINIT", "framework", "Terminology"] +title: 'Capítulo 5. O Framework SYSINIT' +weight: 6 +--- + +[[sysinit]] += O Framework SYSINIT +:doctype: book +:toc: macro +:toclevels: 1 +:icons: font +:sectnums: +:sectnumlevels: 6 +:sectnumoffset: 5 +:partnums: +:source-highlighter: rouge +:experimental: +:images-path: books/arch-handbook/ + +ifdef::env-beastie[] +ifdef::backend-html5[] +:imagesdir: ../../../../images/{images-path} +endif::[] +ifndef::book[] +include::shared/authors.adoc[] +include::shared/mirrors.adoc[] +include::shared/releases.adoc[] +include::shared/attributes/attributes-{{% lang %}}.adoc[] +include::shared/{{% lang %}}/teams.adoc[] +include::shared/{{% lang %}}/mailing-lists.adoc[] +include::shared/{{% lang %}}/urls.adoc[] +toc::[] +endif::[] +ifdef::backend-pdf,backend-epub3[] +include::../../../../../shared/asciidoctor.adoc[] +endif::[] +endif::[] + +ifndef::env-beastie[] +toc::[] +include::../../../../../shared/asciidoctor.adoc[] +endif::[] + +SYSINIT é a estrutura para um mecanismo genérico de ordenação e despacho de chamadas. O FreeBSD atualmente o utiliza para a inicialização dinâmica do kernel. O SYSINIT permite que os subsistemas do kernel do FreeBSD sejam reordenados, adicionados, removidos e substituídos durante a vinculação do kernel, quando o kernel ou um de seus módulos é carregado, sem a necessidade de editar um roteamento de inicialização estaticamente ordenado e recompilar o kernel. Este sistema também permite que módulos do kernel, atualmente chamados de _KLDs_, sejam compilados, vinculados e inicializados separadamente durante a inicialização do sistema e carregados posteriormente, enquanto o sistema já está em execução. Isso é realizado utilizando o "linker do kernel" e os "conjuntos de linkers". + +[[sysinit-term]] +== Terminologia + +Conjunto de Linkers:: +Uma técnica de vinculação na qual o vinculador reúne dados declarados estaticamente em todos os arquivos de origem de um programa em uma única unidade de dados endereçável de forma contígua. + +[[sysinit-operation]] +== Operação SYSINIT + +O SYSINIT depende da capacidade do linker de pegar dados estáticos declarados em vários locais ao longo do código-fonte de um programa e agrupá-los em um único bloco contíguo de dados. Essa técnica do linker é chamada de "conjunto de linker". O SYSINIT usa dois conjuntos de linker para manter dois conjuntos de dados contendo a ordem de chamada de cada consumidor, a função e um ponteiro para os dados a serem passados para essa função. + +O SYSINIT utiliza duas prioridades ao ordenar a execução das funções. A primeira prioridade é um ID de subsistema que define a ordem geral de despacho das funções do SYSINIT. Os IDs predefinidos atuais estão em [.filename]## na lista enum `sysinit_sub_id`. A segunda prioridade utilizada é a ordem dos elementos dentro do subsistema. As ordens de elementos predefinidas atualmente para o subsistema são as seguintes: [.filename]## na lista enum `sysinit_elem_order`. + +Atualmente, o SYSINIT possui duas utilizações: o despacho de funções na inicialização do sistema e o carregamento de módulos do kernel, e o despacho de funções no desligamento do sistema e o descarregamento de módulos do kernel. Subsistemas do kernel frequentemente utilizam o SYSINIT de inicialização do sistema para inicializar estruturas de dados; por exemplo, o subsistema de escalonamento de processos utiliza um SYSINIT para inicializar a estrutura de dados da fila de execução. Drivers de dispositivo devem evitar o uso direto de `SYSINIT()`. Em vez disso, drivers para dispositivos reais que fazem parte de uma estrutura de barramento devem utilizar `DRIVER_MODULE()` para fornecer uma função que detecta o dispositivo e, se presente, o inicializa. Essa função executará algumas operações específicas para dispositivos e, em seguida, chamará o próprio `SYSINIT()`. Para pseudodispositivos, que não fazem parte de uma estrutura de barramento, utilize `DEV_MODULE()`. + +[[sysinit-using]] +== Usando SYSINIT + +=== Interface + +==== Cabeçalhos + +[.programlisting] +.... + +.... + +==== Macros + +[.programlisting] +.... +SYSINIT(uniquifier, subsystem, order, func, ident) +SYSUNINIT(uniquifier, subsystem, order, func, ident) +.... + +=== Começando + +A macro `SYSINIT()` cria os dados necessários no conjunto de dados de inicialização do SYSINIT para que ele possa classificar e despachar uma função na inicialização do sistema e no carregamento de módulos. `SYSINIT()` recebe um identificador único que o SYSINIT usa para identificar os dados de despacho da função específica, a ordem do subsistema, a ordem dos elementos do subsistema, a função a ser chamada e os dados a serem passados para a função. Todas as funções devem receber um ponteiro constante como argumento. + +.Exemplo de uma chamada `SYSINIT()` +[example] +==== +[.programlisting] +.... +#include + +void foo_null(void *unused) +{ + foo_doo(); +} +SYSINIT(foo, SI_SUB_FOO, SI_ORDER_FOO, foo_null, NULL); + +struct foo foo_voodoo = { + FOO_VOODOO; +} + +void foo_arg(void *vdata) +{ + struct foo *foo = (struct foo *)vdata; + foo_data(foo); +} +SYSINIT(bar, SI_SUB_FOO, SI_ORDER_FOO, foo_arg, &foo_voodoo); +.... +==== + +Observe que `SI_SUB_FOO` e `SI_ORDER_FOO` precisam estar presentes nas enumerações `sysinit_sub_id` e `sysinit_elem_order`, conforme mencionado anteriormente. Você pode usar valores existentes ou adicionar os seus próprios às enumerações. Também é possível usar cálculos para ajustar a ordem de execução de um SYSINIT. Este exemplo mostra um SYSINIT que precisa ser executado logo antes dos SYSINITs responsáveis pelo ajuste dos parâmetros do kernel. + +.Exemplo de ajuste da ordem de `SYSINIT()` +[example] +==== +[.programlisting] +.... +static void +mptable_register(void *dummy __unused) +{ + + apic_register_enumerator(&mptable_enumerator); +} + +SYSINIT(mptable_register, SI_SUB_TUNABLES - 1, SI_ORDER_FIRST, + mptable_register, NULL); +.... + +==== + +=== Desligar + +A macro `SYSUNINIT()` comporta-se de forma semelhante à macro `SYSINIT()`, exceto pelo fato de adicionar os dados SYSINIT ao conjunto de dados de desligamento do SYSINIT. + +.Exemplo de um `SYSUNINIT()` +[example] +==== +[.programlisting] +.... +#include + +void foo_cleanup(void *unused) +{ + foo_kill(); +} +SYSUNINIT(foobar, SI_SUB_FOO, SI_ORDER_FOO, foo_cleanup, NULL); + +struct foo_stack foo_stack = { + FOO_STACK_VOODOO; +} + +void foo_flush(void *vdata) +{ +} +SYSUNINIT(barfoo, SI_SUB_FOO, SI_ORDER_FOO, foo_flush, &foo_stack); +.... + +==== diff --git a/documentation/content/pt-br/books/arch-handbook/sysinit/_index.po b/documentation/content/pt-br/books/arch-handbook/sysinit/_index.po new file mode 100644 index 00000000000..5d961b98627 --- /dev/null +++ b/documentation/content/pt-br/books/arch-handbook/sysinit/_index.po @@ -0,0 +1,403 @@ +# SOME DESCRIPTIVE TITLE +# Copyright (C) YEAR The FreeBSD Project +# This file is distributed under the same license as the FreeBSD Documentation package. +# Danilo G. Baio , 2021. +# Matheus Santos , 2026. +msgid "" +msgstr "" +"Project-Id-Version: FreeBSD Documentation VERSION\n" +"POT-Creation-Date: 2025-05-01 19:56-0300\n" +"PO-Revision-Date: 2026-05-02 14:50-0300\n" +"Last-Translator: Matheus Santos \n" +"Language-Team: Portuguese (Brazil) \n" +"Language: pt_BR\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=2; plural=n > 1;\n" +"X-Generator: Poedit 3.9\n" + +#. type: Title = +#: documentation/content/en/books/arch-handbook/sysinit/_index.adoc:1 +#: documentation/content/en/books/arch-handbook/sysinit/_index.adoc:14 +#, no-wrap +msgid "The SYSINIT Framework" +msgstr "O Framework SYSINIT" + +#. type: YAML Front Matter: title +#: documentation/content/en/books/arch-handbook/sysinit/_index.adoc:1 +#, no-wrap +msgid "Chapter 5. The SYSINIT Framework" +msgstr "Capítulo 5. O Framework SYSINIT" + +#. type: Plain text +#: documentation/content/en/books/arch-handbook/sysinit/_index.adoc:52 +msgid "" +"SYSINIT is the framework for a generic call sort and dispatch mechanism. " +"FreeBSD currently uses it for the dynamic initialization of the kernel. " +"SYSINIT allows FreeBSD's kernel subsystems to be reordered, and added, " +"removed, and replaced at kernel link time when the kernel or one of its " +"modules is loaded without having to edit a statically ordered initialization " +"routing and recompile the kernel. This system also allows kernel modules, " +"currently called _KLD's_, to be separately compiled, linked, and initialized " +"at boot time and loaded even later while the system is already running. This " +"is accomplished using the \"kernel linker\" and \"linker sets\"." +msgstr "" +"SYSINIT é a estrutura para um mecanismo genérico de ordenação e despacho de " +"chamadas. O FreeBSD atualmente o utiliza para a inicialização dinâmica do " +"kernel. O SYSINIT permite que os subsistemas do kernel do FreeBSD sejam " +"reordenados, adicionados, removidos e substituídos durante a vinculação do " +"kernel, quando o kernel ou um de seus módulos é carregado, sem a necessidade " +"de editar um roteamento de inicialização estaticamente ordenado e recompilar " +"o kernel. Este sistema também permite que módulos do kernel, atualmente " +"chamados de _KLDs_, sejam compilados, vinculados e inicializados " +"separadamente durante a inicialização do sistema e carregados " +"posteriormente, enquanto o sistema já está em execução. Isso é realizado " +"utilizando o \"linker do kernel\" e os \"conjuntos de linkers\"." + +#. type: Title == +#: documentation/content/en/books/arch-handbook/sysinit/_index.adoc:54 +#, no-wrap +msgid "Terminology" +msgstr "Terminologia" + +#. type: Labeled list +#: documentation/content/en/books/arch-handbook/sysinit/_index.adoc:56 +#, no-wrap +msgid "Linker Set" +msgstr "Conjunto de Linkers" + +#. type: Plain text +#: documentation/content/en/books/arch-handbook/sysinit/_index.adoc:58 +msgid "" +"A linker technique in which the linker gathers statically declared data " +"throughout a program's source files into a single contiguously addressable " +"unit of data." +msgstr "" +"Uma técnica de vinculação na qual o vinculador reúne dados declarados " +"estaticamente em todos os arquivos de origem de um programa em uma única " +"unidade de dados endereçável de forma contígua." + +#. type: Title == +#: documentation/content/en/books/arch-handbook/sysinit/_index.adoc:60 +#, no-wrap +msgid "SYSINIT Operation" +msgstr "Operação SYSINIT" + +#. type: Plain text +#: documentation/content/en/books/arch-handbook/sysinit/_index.adoc:63 +msgid "" +"SYSINIT relies on the ability of the linker to take static data declared at " +"multiple locations throughout a program's source and group it together as a " +"single contiguous chunk of data. This linker technique is called a \"linker " +"set\". SYSINIT uses two linker sets to maintain two data sets containing " +"each consumer's call order, function, and a pointer to the data to pass to " +"that function." +msgstr "" +"O SYSINIT depende da capacidade do linker de pegar dados estáticos " +"declarados em vários locais ao longo do código-fonte de um programa e agrupá-" +"los em um único bloco contíguo de dados. Essa técnica do linker é chamada de " +"\"conjunto de linker\". O SYSINIT usa dois conjuntos de linker para manter " +"dois conjuntos de dados contendo a ordem de chamada de cada consumidor, a " +"função e um ponteiro para os dados a serem passados para essa função." + +#. type: Plain text +#: documentation/content/en/books/arch-handbook/sysinit/_index.adoc:65 +msgid "" +"SYSINIT uses two priorities when ordering the functions for execution. The " +"first priority is a subsystem ID giving an overall order for SYSINIT's " +"dispatch of functions. Current predeclared ID's are in [.filename]## in the enum list `sysinit_sub_id`. The second priority used is an " +"element order within the subsystem. Current predeclared subsystem element " +"orders are in [.filename]## in the enum list " +"`sysinit_elem_order`." +msgstr "" +"O SYSINIT utiliza duas prioridades ao ordenar a execução das funções. A " +"primeira prioridade é um ID de subsistema que define a ordem geral de " +"despacho das funções do SYSINIT. Os IDs predefinidos atuais estão em " +"[.filename]## na lista enum `sysinit_sub_id`. A segunda " +"prioridade utilizada é a ordem dos elementos dentro do subsistema. As ordens " +"de elementos predefinidas atualmente para o subsistema são as seguintes: " +"[.filename]## na lista enum `sysinit_elem_order`." + +#. type: Plain text +#: documentation/content/en/books/arch-handbook/sysinit/_index.adoc:67 +msgid "" +"There are currently two uses for SYSINIT. Function dispatch at system " +"startup and kernel module loads, and function dispatch at system shutdown " +"and kernel module unload. Kernel subsystems often use system startup " +"SYSINIT's to initialize data structures, for example the process scheduling " +"subsystem uses a SYSINIT to initialize the run queue data structure. Device " +"drivers should avoid using `SYSINIT()` directly. Instead drivers for real " +"devices that are part of a bus structure should use `DRIVER_MODULE()` to " +"provide a function that detects the device and, if it is present, " +"initializes the device. It will do a few things specific to devices and then " +"call `SYSINIT()` itself. For pseudo-devices, which are not part of a bus " +"structure, use `DEV_MODULE()`." +msgstr "" +"Atualmente, o SYSINIT possui duas utilizações: o despacho de funções na " +"inicialização do sistema e o carregamento de módulos do kernel, e o despacho " +"de funções no desligamento do sistema e o descarregamento de módulos do " +"kernel. Subsistemas do kernel frequentemente utilizam o SYSINIT de " +"inicialização do sistema para inicializar estruturas de dados; por exemplo, " +"o subsistema de escalonamento de processos utiliza um SYSINIT para " +"inicializar a estrutura de dados da fila de execução. Drivers de dispositivo " +"devem evitar o uso direto de `SYSINIT()`. Em vez disso, drivers para " +"dispositivos reais que fazem parte de uma estrutura de barramento devem " +"utilizar `DRIVER_MODULE()` para fornecer uma função que detecta o " +"dispositivo e, se presente, o inicializa. Essa função executará algumas " +"operações específicas para dispositivos e, em seguida, chamará o próprio " +"`SYSINIT()`. Para pseudodispositivos, que não fazem parte de uma estrutura " +"de barramento, utilize `DEV_MODULE()`." + +#. type: Title == +#: documentation/content/en/books/arch-handbook/sysinit/_index.adoc:69 +#, no-wrap +msgid "Using SYSINIT" +msgstr "Usando SYSINIT" + +#. type: Title === +#: documentation/content/en/books/arch-handbook/sysinit/_index.adoc:71 +#, no-wrap +msgid "Interface" +msgstr "Interface" + +#. type: Title ==== +#: documentation/content/en/books/arch-handbook/sysinit/_index.adoc:73 +#, no-wrap +msgid "Headers" +msgstr "Cabeçalhos" + +#. type: delimited block . 4 +#: documentation/content/en/books/arch-handbook/sysinit/_index.adoc:78 +#, no-wrap +msgid "\n" +msgstr "\n" + +#. type: Title ==== +#: documentation/content/en/books/arch-handbook/sysinit/_index.adoc:80 +#, no-wrap +msgid "Macros" +msgstr "Macros" + +#. type: delimited block . 4 +#: documentation/content/en/books/arch-handbook/sysinit/_index.adoc:86 +#, no-wrap +msgid "" +"SYSINIT(uniquifier, subsystem, order, func, ident)\n" +"SYSUNINIT(uniquifier, subsystem, order, func, ident)\n" +msgstr "" +"SYSINIT(uniquifier, subsystem, order, func, ident)\n" +"SYSUNINIT(uniquifier, subsystem, order, func, ident)\n" + +#. type: Title === +#: documentation/content/en/books/arch-handbook/sysinit/_index.adoc:88 +#, no-wrap +msgid "Startup" +msgstr "Começando" + +#. type: Plain text +#: documentation/content/en/books/arch-handbook/sysinit/_index.adoc:91 +msgid "" +"The `SYSINIT()` macro creates the necessary SYSINIT data in SYSINIT's " +"startup data set for SYSINIT to sort and dispatch a function at system " +"startup and module load. `SYSINIT()` takes a uniquifier that SYSINIT uses to " +"identify the particular function dispatch data, the subsystem order, the " +"subsystem element order, the function to call, and the data to pass the " +"function. All functions must take a constant pointer argument." +msgstr "" +"A macro `SYSINIT()` cria os dados necessários no conjunto de dados de " +"inicialização do SYSINIT para que ele possa classificar e despachar uma " +"função na inicialização do sistema e no carregamento de módulos. `SYSINIT()` " +"recebe um identificador único que o SYSINIT usa para identificar os dados de " +"despacho da função específica, a ordem do subsistema, a ordem dos elementos " +"do subsistema, a função a ser chamada e os dados a serem passados para a " +"função. Todas as funções devem receber um ponteiro constante como argumento." + +#. type: Block title +#: documentation/content/en/books/arch-handbook/sysinit/_index.adoc:92 +#, no-wrap +msgid "Example of a `SYSINIT()`" +msgstr "Exemplo de uma chamada `SYSINIT()`" + +#. type: delimited block . 4 +#: documentation/content/en/books/arch-handbook/sysinit/_index.adoc:98 +#: documentation/content/en/books/arch-handbook/sysinit/_index.adoc:148 +#, no-wrap +msgid "#include \n" +msgstr "#include \n" + +#. type: delimited block . 4 +#: documentation/content/en/books/arch-handbook/sysinit/_index.adoc:104 +#, no-wrap +msgid "" +"void foo_null(void *unused)\n" +"{\n" +" foo_doo();\n" +"}\n" +"SYSINIT(foo, SI_SUB_FOO, SI_ORDER_FOO, foo_null, NULL);\n" +msgstr "" +"void foo_null(void *unused)\n" +"{\n" +" foo_doo();\n" +"}\n" +"SYSINIT(foo, SI_SUB_FOO, SI_ORDER_FOO, foo_null, NULL);\n" + +#. type: delimited block . 4 +#: documentation/content/en/books/arch-handbook/sysinit/_index.adoc:108 +#, no-wrap +msgid "" +"struct foo foo_voodoo = {\n" +" FOO_VOODOO;\n" +"}\n" +msgstr "" +"struct foo foo_voodoo = {\n" +" FOO_VOODOO;\n" +"}\n" + +#. type: delimited block . 4 +#: documentation/content/en/books/arch-handbook/sysinit/_index.adoc:115 +#, no-wrap +msgid "" +"void foo_arg(void *vdata)\n" +"{\n" +" struct foo *foo = (struct foo *)vdata;\n" +" foo_data(foo);\n" +"}\n" +"SYSINIT(bar, SI_SUB_FOO, SI_ORDER_FOO, foo_arg, &foo_voodoo);\n" +msgstr "" +"void foo_arg(void *vdata)\n" +"{\n" +" struct foo *foo = (struct foo *)vdata;\n" +" foo_data(foo);\n" +"}\n" +"SYSINIT(bar, SI_SUB_FOO, SI_ORDER_FOO, foo_arg, &foo_voodoo);\n" + +#. type: delimited block = 4 +#: documentation/content/en/books/arch-handbook/sysinit/_index.adoc:119 +msgid "" +"Note that `SI_SUB_FOO` and `SI_ORDER_FOO` need to be in the `sysinit_sub_id` " +"and `sysinit_elem_order` enum's as mentioned above. Either use existing ones " +"or add your own to the enum's. You can also use math for fine-tuning the " +"order a SYSINIT will run in. This example shows a SYSINIT that needs to be " +"run just barely before the SYSINIT's that handle tuning kernel parameters." +msgstr "" +"Observe que `SI_SUB_FOO` e `SI_ORDER_FOO` precisam estar presentes nas " +"enumerações `sysinit_sub_id` e `sysinit_elem_order`, conforme mencionado " +"anteriormente. Você pode usar valores existentes ou adicionar os seus " +"próprios às enumerações. Também é possível usar cálculos para ajustar a " +"ordem de execução de um SYSINIT. Este exemplo mostra um SYSINIT que precisa " +"ser executado logo antes dos SYSINITs responsáveis pelo ajuste dos " +"parâmetros do kernel." + +#. type: Block title +#: documentation/content/en/books/arch-handbook/sysinit/_index.adoc:120 +#, no-wrap +msgid "Example of Adjusting `SYSINIT()` Order" +msgstr "Exemplo de ajuste da ordem de `SYSINIT()`" + +#. type: delimited block . 4 +#: documentation/content/en/books/arch-handbook/sysinit/_index.adoc:128 +#, no-wrap +msgid "" +"static void\n" +"mptable_register(void *dummy __unused)\n" +"{\n" +msgstr "" +"static void\n" +"mptable_register(void *dummy __unused)\n" +"{\n" + +#. type: delimited block . 4 +#: documentation/content/en/books/arch-handbook/sysinit/_index.adoc:131 +#, no-wrap +msgid "" +"\tapic_register_enumerator(&mptable_enumerator);\n" +"}\n" +msgstr "" +"\tapic_register_enumerator(&mptable_enumerator);\n" +"}\n" + +#. type: delimited block . 4 +#: documentation/content/en/books/arch-handbook/sysinit/_index.adoc:134 +#, no-wrap +msgid "" +"SYSINIT(mptable_register, SI_SUB_TUNABLES - 1, SI_ORDER_FIRST,\n" +" mptable_register, NULL);\n" +msgstr "" +"SYSINIT(mptable_register, SI_SUB_TUNABLES - 1, SI_ORDER_FIRST,\n" +" mptable_register, NULL);\n" + +#. type: Title === +#: documentation/content/en/books/arch-handbook/sysinit/_index.adoc:138 +#, no-wrap +msgid "Shutdown" +msgstr "Desligar" + +#. type: delimited block = 4 +#: documentation/content/en/books/arch-handbook/sysinit/_index.adoc:141 +msgid "" +"The `SYSUNINIT()` macro behaves similarly to the `SYSINIT()` macro except " +"that it adds the SYSINIT data to SYSINIT's shutdown data set." +msgstr "" +"A macro `SYSUNINIT()` comporta-se de forma semelhante à macro `SYSINIT()`, " +"exceto pelo fato de adicionar os dados SYSINIT ao conjunto de dados de " +"desligamento do SYSINIT." + +#. type: Block title +#: documentation/content/en/books/arch-handbook/sysinit/_index.adoc:142 +#, no-wrap +msgid "Example of a `SYSUNINIT()`" +msgstr "Exemplo de um `SYSUNINIT()`" + +#. type: delimited block . 4 +#: documentation/content/en/books/arch-handbook/sysinit/_index.adoc:154 +#, no-wrap +msgid "" +"void foo_cleanup(void *unused)\n" +"{\n" +" foo_kill();\n" +"}\n" +"SYSUNINIT(foobar, SI_SUB_FOO, SI_ORDER_FOO, foo_cleanup, NULL);\n" +msgstr "" +"void foo_cleanup(void *unused)\n" +"{\n" +" foo_kill();\n" +"}\n" +"SYSUNINIT(foobar, SI_SUB_FOO, SI_ORDER_FOO, foo_cleanup, NULL);\n" + +#. type: delimited block . 4 +#: documentation/content/en/books/arch-handbook/sysinit/_index.adoc:158 +#, no-wrap +msgid "" +"struct foo_stack foo_stack = {\n" +" FOO_STACK_VOODOO;\n" +"}\n" +msgstr "" +"struct foo_stack foo_stack = {\n" +" FOO_STACK_VOODOO;\n" +"}\n" + +#. type: delimited block . 4 +#: documentation/content/en/books/arch-handbook/sysinit/_index.adoc:163 +#, no-wrap +msgid "" +"void foo_flush(void *vdata)\n" +"{\n" +"}\n" +"SYSUNINIT(barfoo, SI_SUB_FOO, SI_ORDER_FOO, foo_flush, &foo_stack);\n" +msgstr "" +"void foo_flush(void *vdata)\n" +"{\n" +"}\n" +"SYSUNINIT(barfoo, SI_SUB_FOO, SI_ORDER_FOO, foo_flush, &foo_stack);\n" + +#~ msgid "" +#~ "include::shared/attributes/attributes-{{% lang %}}.adoc[] include::shared/" +#~ "{{% lang %}}/teams.adoc[] include::shared/{{% lang %}}/mailing-" +#~ "lists.adoc[] include::shared/{{% lang %}}/urls.adoc[]" +#~ msgstr "" +#~ "include::shared/attributes/attributes-{{% lang %}}.adoc[] include::shared/" +#~ "{{% lang %}}/teams.adoc[] include::shared/{{% lang %}}/mailing-" +#~ "lists.adoc[] include::shared/{{% lang %}}/urls.adoc[]"