diff --git a/documentation/content/pt-br/books/arch-handbook/_index.adoc b/documentation/content/pt-br/books/arch-handbook/_index.adoc new file mode 100644 index 00000000000..7c96a81e5e9 --- /dev/null +++ b/documentation/content/pt-br/books/arch-handbook/_index.adoc @@ -0,0 +1,57 @@ +--- +add_single_page_link: 'true' +authors: + - + author: 'The FreeBSD Documentation Project' +bookOrder: 50 +copyright: '2000-2006, 2012-2023 The FreeBSD Documentation Project' +description: 'Para desenvolvedores de sistemas FreeBSD. Este livro aborda os detalhes arquitetônicos de muitos subsistemas importantes do kernel do FreeBSD' +next: books/arch-handbook/parti +params: + path: /books/arch-handbook/ +showBookMenu: 'true' +tags: ["Arch Handbook", "FreeBSD"] +title: 'Manual de Arquitetura do FreeBSD' +trademarks: ["freebsd", "apple", "microsoft", "unix", "general"] +weight: 0 +--- + += Manual de Arquitetura do FreeBSD +:doctype: book +:toc: macro +:toclevels: 1 +:icons: font +:sectnums: +:sectnumlevels: 6 +:partnums: +:source-highlighter: rouge +:experimental: +:images-path: books/arch-handbook/ + +ifdef::env-beastie[] +ifdef::backend-html5[] +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[] +endif::[] +ifdef::backend-pdf,backend-epub3[] +include::../../../../../shared/asciidoctor.adoc[] +endif::[] +endif::[] + +ifndef::env-beastie[] +include::../../../../../shared/asciidoctor.adoc[] +endif::[] + +[.abstract-title] +Resumo + +Bem-vindo ao Manual de Arquitetura do FreeBSD. Este manual é um _trabalho em andamento_ e é fruto do trabalho de muitas pessoas. Muitas seções ainda não existem e algumas das que existem precisam ser atualizadas. Se você estiver interessado em contribuir com este projeto, envie um e-mail para {freebsd-doc}. + +A versão mais recente deste documento está sempre disponível no link:https://www.FreeBSD.org/[servidor web do FreeBSD]. Também pode ser baixado em diversos formatos e opções de compressão no https://download.freebsd.org/doc/[servidor de downloads do FreeBSD] ou em um dos inúmeros espelhos extref:{handbook}mirrors. + +''' diff --git a/documentation/content/pt-br/books/arch-handbook/_index.po b/documentation/content/pt-br/books/arch-handbook/_index.po new file mode 100644 index 00000000000..4f0d9f47d86 --- /dev/null +++ b/documentation/content/pt-br/books/arch-handbook/_index.po @@ -0,0 +1,82 @@ +# 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. +# Edson Brandi , 2023. +# "Danilo G. Baio" , 2023. +# Wagner Ferreira , 2025. +msgid "" +msgstr "" +"Project-Id-Version: FreeBSD Documentation VERSION\n" +"POT-Creation-Date: 2025-11-08 16:17+0000\n" +"PO-Revision-Date: 2026-04-21 19:57-0300\n" +"Last-Translator: Wagner Ferreira \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: YAML Front Matter: description +#: documentation/content/en/books/arch-handbook/_index.adoc:1 +#, no-wrap +msgid "For FreeBSD system developers. This book covers the architectural details of many important FreeBSD kernel subsystems" +msgstr "Para desenvolvedores de sistemas FreeBSD. Este livro aborda os detalhes arquitetônicos de muitos subsistemas importantes do kernel do FreeBSD" + +#. type: Title = +#: documentation/content/en/books/arch-handbook/_index.adoc:1 documentation/content/en/books/arch-handbook/_index.adoc:18 +#, no-wrap +msgid "FreeBSD Architecture Handbook" +msgstr "Manual de Arquitetura do FreeBSD" + +#. type: Plain text +#: documentation/content/en/books/arch-handbook/_index.adoc:51 +msgid "Abstract" +msgstr "Resumo" + +#. type: Plain text +#: documentation/content/en/books/arch-handbook/_index.adoc:53 +msgid "" +"Welcome to the FreeBSD Architecture Handbook. This manual is a _work in progress_ and is the work of many individuals. " +"Many sections do not yet exist and some of those that do exist need to be updated. If you are interested in helping with " +"this project, send email to the {freebsd-doc}." +msgstr "" +"Bem-vindo ao Manual de Arquitetura do FreeBSD. Este manual é um _trabalho em andamento_ e é fruto do trabalho de muitas " +"pessoas. Muitas seções ainda não existem e algumas das que existem precisam ser atualizadas. Se você estiver interessado " +"em contribuir com este projeto, envie um e-mail para {freebsd-doc}." + +#. type: Plain text +#: documentation/content/en/books/arch-handbook/_index.adoc:55 +msgid "" +"The latest version of this document is always available from the link:https://www.FreeBSD.org/[FreeBSD World Wide Web " +"server]. It may also be downloaded in a variety of formats and compression options from the https://download.freebsd.org/" +"doc/[FreeBSD download server] or one of the numerous extref:{handbook}mirrors[mirror sites, mirrors]." +msgstr "" +"A versão mais recente deste documento está sempre disponível no link:https://www.FreeBSD.org/[servidor web do FreeBSD]. " +"Também pode ser baixado em diversos formatos e opções de compressão no https://download.freebsd.org/doc/[servidor de " +"downloads do FreeBSD] ou em um dos inúmeros espelhos extref:{handbook}mirrors." + +#. type: Plain text +#: documentation/content/en/books/arch-handbook/_index.adoc:56 +msgid "'''" +msgstr "'''" + +#~ 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[]" + +#~ msgid "Kernel" +#~ msgstr "Kernel" + +#, fuzzy +#~ msgid "Device Drivers" +#~ msgstr "Drivers de dispositivos." + +#~ msgid "Appendices" +#~ msgstr "Apêndices" 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[]"