Units
Translation components API.
See the Weblate's Web API documentation for detailed description of the API.
GET /api/translations/documentation/articleslinux-emulation_index/es/units/?format=api&page=8
{ "count": 396, "next": null, "previous": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/units/?format=api&page=7", "results": [ { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "There are two main ways of setting up TLS in Linux(R). It can be set when cloning a process using the `clone` syscall or it can call `set_thread_area`. When a process passes `CLONE_SETTLS` flag to `clone`, the kernel expects the memory pointed to by the `%esi` register a Linux(R) user space representation of a segment, which gets translated to the machine representation of a segment and loaded into a GDT slot. The GDT slot can be specified with a number or -1 can be used meaning that the system itself should choose the first free slot. In practice, the vast majority of programs use only one TLS entry and does not care about the number of the entry. We exploit this in the emulation and in fact depend on it." ], "previous_source": "", "target": [ "Hay dos formas principales de establecer TLS en Linux(R). Se puede establecer cuando se clona un proceso con la llamada al sistema `clone` o se puede llamar a `set_thread_area`. Cuando un proceso para el flag `CLONE_SETTLS` a `clone`, el kernel espera que la memoria apuntada por el registro `%esi` sea una representación en espacio de usuario de un segmento Linux(R) que se traduce a la representación máquina de un segmento y se carga en una entrada de la GDT. La entrada de la GDT se puede especificar con un número o se puede usar -1 que significa que el sistema puede escoger la primera entrada que encuentre libre. En la práctica, la gran mayoría de programas utilizan sólo una entrada TLS y no se preocupan acerca del número de la misma. Aprovechamos esto en la emulación y de hecho dependemos de ello." ], "id_hash": 573668554798411945, "content_hash": 573668554798411945, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:1072", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 286, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 130, "source_unit": "https://translate-dev.freebsd.org/api/units/612461/?format=api", "priority": 100, "id": 612462, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=87f61482db9230a9", "url": "https://translate-dev.freebsd.org/api/units/612462/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2021-03-20T20:37:57.292728Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "Loading of TLS for the current thread happens by calling `set_thread_area` while loading TLS for a second process in `clone` is done in the separate block in `clone`. Those two functions are very similar. The only difference being the actual loading of the GDT segment, which happens on the next context switch for the newly created process while `set_thread_area` must load this directly. The code basically does this. It copies the Linux(R) form segment descriptor from the userland. The code checks for the number of the descriptor but because this differs between FreeBSD and Linux(R) we fake it a little. We only support indexes of 6, 3 and -1. The 6 is genuine Linux(R) number, 3 is genuine FreeBSD one and -1 means autoselection. Then we set the descriptor number to constant 3 and copy out this to the userspace. We rely on the userspace process using the number from the descriptor but this works most of the time (have never seen a case where this did not work) as the userspace process typically passes in 1. Then we convert the descriptor from the Linux(R) form to a machine dependant form (i.e. operating system independent form) and copy this to the FreeBSD defined segment descriptor. Finally we can load it. We assign the descriptor to threads PCB (process control block) and load the `%gs` segment using `load_gs`. This loading must be done in a critical section so that nothing can interrupt us. The `CLONE_SETTLS` case works exactly like this just the loading using `load_gs` is not performed. The segment used for this (segment number 3) is shared for this use between FreeBSD processes and Linux(R) processes so the Linux(R) emulation layer does not add any overhead over plain FreeBSD." ], "previous_source": "", "target": [ "La carga del TLS del hilo actual se realiza llamando a `set_thread_area` mientras que la carga del TLS para un segundo proceso en `clone` se realiza en el bloque separado en `clone`. Estas dos funciones son muy parecidas. La única diferencia es la carga del segmento GDT que sucede en el siguiente cambio de contexto para el nuevo proceso creado mientras que `set_thread_area` tiene que cargarlos directamente. El código básicamente hace esto. Copia la forma Linux(R) del descriptor de segmento desde el espacio de usuario. El código comprueba el número del descriptor pero como difieren entre FreeBSD y Linux(R) lo falseamos un poco. Sólo soportamos los índices 6, 3 y -1. El 6 es un número genuino de Linux(R), el tres es genuino de FreeBSD y el -1 significa autoselección. Después establecemos el número del descriptor de forma constante a 3 y lo copiamos de vuelva a espacio de usuario. Dependemos de que el proceso en espacio de usuario use el número del descriptor pero esto funciona casi siempre (no he visto nunca un caso donde no funciones) ya que el proceso de espacio de usuario normalmente pasa -1. Después convertimos el descriptor de la forma Linux(R) a una forma dependiente de la máquina (es decir forma independiente del sistema operativo) y lo copiamos al descriptor de segmento definido en FreeBSD. Finalmente podemos cargarlo. Asignamos el descriptor en los PCB (bloque de control de proceso) de los hilos y cargamos el segmento `%gs` utilizando `load_gs`. Esta carga se tiene que hacer dentro de una sección crítica de forma que nada la interrumpa. El caso `CLONE_SETTLS` funciona exactamente así salvo que no se realiza la carga utilizando `load_gs`. El segmento que se usa para esto (número de segmento 3) se comparte para este uso entre los procesos de FreeBSD y de Linux(R) de forma que la capa de emulación Linux(R) no añade nada de sobrecarga respecto al funcionamiento normal de FreeBSD." ], "id_hash": 5162293539665282276, "content_hash": 5162293539665282276, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:1095", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 289, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 289, "source_unit": "https://translate-dev.freebsd.org/api/units/612463/?format=api", "priority": 100, "id": 612464, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=c7a4269f920b04e4", "url": "https://translate-dev.freebsd.org/api/units/612464/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2021-03-20T20:37:57.590180Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "The amd64 implementation is similar to the i386 one but there was initially no 32bit segment descriptor used for this purpose (hence not even native 32bit TLS users worked) so we had to add such a segment and implement its loading on every context switch (when a flag signaling use of 32bit is set). Apart from this the TLS loading is exactly the same just the segment numbers are different and the descriptor format and the loading differs slightly." ], "previous_source": "", "target": [ "La implementación de amd64 es similar a la de i386, pero inicialmente no se utilizó un descriptor de segmento de 32 bits para este propósito (por lo tanto, ni siquiera los usuarios nativos de TLS de 32 bits funcionaban), por lo que tuvimos que agregar dicho segmento e implementar su carga en cada cambio de contexto (cuando se establece el flag de uso de 32 bits). Aparte de esto, la carga de TLS es exactamente la misma, solo que los números de segmento son diferentes y el formato del descriptor y la carga difieren ligeramente." ], "id_hash": 1283499755840478928, "content_hash": 1283499755840478928, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:1101", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 291, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 79, "source_unit": "https://translate-dev.freebsd.org/api/units/612465/?format=api", "priority": 100, "id": 612466, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=91cfe83a482c1ed0", "url": "https://translate-dev.freebsd.org/api/units/612466/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2021-03-20T20:37:57.683579Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "Threads need some kind of synchronization and POSIX(R) provides some of them: mutexes for mutual exclusion, read-write locks for mutual exclusion with biased ratio of reads and writes and condition variables for signaling a status change. It is interesting to note that POSIX(R) threading API lacks support for semaphores. Those synchronization routines implementations are heavily dependant on the type threading support we have. In pure 1:M (userspace) model the implementation can be solely done in userspace and thus be very fast (the condition variables will probably end up being implemented using signals, i.e. not fast) and simple. In 1:1 model, the situation is also quite clear - the threads must be synchronized using kernel facilities (which is very slow because a syscall must be performed). The mixed M:N scenario just combines the first and second approach or rely solely on kernel. Threads synchronization is a vital part of thread-enabled programming and its performance can affect resulting program a lot. Recent benchmarks on FreeBSD operating system showed that an improved sx_lock implementation yielded 40% speedup in _ZFS_ (a heavy sx user), this is in-kernel stuff but it shows clearly how important the performance of synchronization primitives is." ], "previous_source": "", "target": [ "Los hilos necesitan algún tipo de sincronización y POSIX(R) proporciona algunos de ellos: mutex para exclusión mutua, locks de lectura y escritura para exclusión mutua con una proporción sesgada de lecturas y escrituras y variables de condición para señalar un cambio de estado. Es interesante notar que la API de hilos de POSIX(R) carece de soporte para semáforos. Esas implementaciones de rutinas de sincronización dependen en gran medida del tipo de soporte de hilos que tenemos. En el modelo puro 1:M (espacio de usuario), la implementación se puede realizar únicamente en el espacio de usuario y, por lo tanto, es muy rápida (las variables de condición probablemente terminarán implementándose mediante señales, es decir, no tan rápido) y simple. En el modelo 1:1, la situación también es bastante clara: los hilos deben sincronizarse utilizando las primitivas del kernel (lo cual es muy lento porque se debe realizar una llamada al sistema). El escenario mixto M:N simplemente combina el primer y segundo enfoque o se basa únicamente en el kernel. La sincronización de hilos es una parte vital de la programación habilitada para hilos y su rendimiento puede afectar mucho al programa resultante. Pruebas de rendimiento recientes en el sistema operativo FreeBSD mostraron que una implementación mejorada de sx_lock producía un 40% de aceleración en _ZFS_ (un usuario intensivo de sx), esto es algo dentro del kernel pero muestra claramente cuán importante es el rendimiento de las primitivas de sincronización." ], "id_hash": -8743795890421467416, "content_hash": -8743795890421467416, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:1116", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 294, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 196, "source_unit": "https://translate-dev.freebsd.org/api/units/612467/?format=api", "priority": 100, "id": 612468, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=06a7cbf6dae876e8", "url": "https://translate-dev.freebsd.org/api/units/612468/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2021-03-20T20:37:57.877830Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "Threaded programs should be written with as little contention on locks as possible. Otherwise, instead of doing useful work the thread just waits on a lock. As a result of this, the most well written threaded programs show little locks contention." ], "previous_source": "", "target": [ "Los programas multihilo se deberían escribir con la menor contención posible. De otro modo en lugar de hacer trabajo útil el hilo simplemente espera en un bloqueo. Como resultado los programas mejores escritos muestran poca contención en bloqueos." ], "id_hash": -32682005756357626, "content_hash": -32682005756357626, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:1120", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 295, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 41, "source_unit": "https://translate-dev.freebsd.org/api/units/612469/?format=api", "priority": 100, "id": 612470, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=7f8be3e390585406", "url": "https://translate-dev.freebsd.org/api/units/612470/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2021-03-20T20:37:58.067373Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "Linux(R) implements 1:1 threading, i.e. it has to use in-kernel synchronization primitives. As stated earlier, well written threaded programs have little lock contention. So a typical sequence could be performed as two atomic increase/decrease mutex reference counter, which is very fast, as presented by the following example:" ], "previous_source": "", "target": [ "Linux(R) implementa multihilo 1:1, es decir tiene que utilizar primitivas de sincronización dentro del kernel. Como se ha dicho antes, un programa bien escrito tiene poca contención. Así que una secuencia típica se podría realizar como dos incrementos/decrementos de contadores de referencia mutex atómicos, lo que es muy rápido, como se muestra en el siguiente ejemplo:" ], "id_hash": -6809354267425429611, "content_hash": -6809354267425429611, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:1127", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 297, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 47, "source_unit": "https://translate-dev.freebsd.org/api/units/612471/?format=api", "priority": 100, "id": 612472, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=2180505f0c512795", "url": "https://translate-dev.freebsd.org/api/units/612472/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2021-03-20T20:37:58.259286Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "The solution Linux(R) 2.6 implements is called futexes. Futexes implement the check for contention in userspace and call kernel primitives only in a case of contention. Thus the typical case takes place without any kernel intervention. This yields reasonably fast and flexible synchronization primitives implementation." ], "previous_source": "", "target": [ "La solución que implementa Linux(R) 2.6 se llama futexes. Los futexes implementan la comprobación de la contención en espacio de usuario y llaman al kernel sólo en caso de contención. Por lo tanto el caso típico tiene lugar sin intervención del kernel. Esto ofrece una implementación de primitivas de sincronización razonablemente rápidas y flexibles." ], "id_hash": -85782050329348747, "content_hash": -85782050329348747, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:1141", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 300, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 45, "source_unit": "https://translate-dev.freebsd.org/api/units/612473/?format=api", "priority": 100, "id": 612474, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=7ecf3dae0203b575", "url": "https://translate-dev.freebsd.org/api/units/612474/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2021-03-20T20:37:58.342513Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "This operation verifies that on address `uaddr` the value `val` is written. If not, `EWOULDBLOCK` is returned, otherwise the thread is queued on the futex and gets suspended. If the argument `timeout` is non-zero it specifies the maximum time for the sleeping, otherwise the sleeping is infinite." ], "previous_source": "", "target": [ "Esta operación verifica que se ha escrito el valor `val` en la dirección `uaddr`. Si no, se devuelve `EWOULDBLOCK`, de otro modo el hilo se encola en el futex y se suspende. Si el argumento `timeout` no es cero entonces especifica el tiempo máximo para estar durmiendo, de lo contrario se duerme indefinidamente." ], "id_hash": -9223076146178718800, "content_hash": -9223076146178718800, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:1169", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 313, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 47, "source_unit": "https://translate-dev.freebsd.org/api/units/612475/?format=api", "priority": 100, "id": 612476, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=00010d1c6aa383b0", "url": "https://translate-dev.freebsd.org/api/units/612476/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2021-03-20T20:37:59.000443Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "This operation performs an atomic operation on `val3` (which contains coded some other value) and `uaddr`. Then it wakes up `val` threads on futex at `uaddr` and if the atomic operation returned a positive number it wakes up `val2` threads on futex at `uaddr2`." ], "previous_source": "", "target": [ "Esta operación realiza una operación atómica en `val3` (que contiene otro valor codificado) y `uaddr`. Después despierta `val` hilos en el futex de la dirección `uaddr` y si la operación atómica devolvió un número positivo despierta `val2` hilos en el futex de la dirección `uaddr2`." ], "id_hash": -2191424171296531056, "content_hash": -2191424171296531056, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:1195", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 323, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 44, "source_unit": "https://translate-dev.freebsd.org/api/units/612477/?format=api", "priority": 100, "id": 612478, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=61967f53adaa5d90", "url": "https://translate-dev.freebsd.org/api/units/612478/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2021-03-20T20:37:59.476126Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "There is no `val2` parameter in the futex prototype. The `val2` is taken from the `struct timespec *timeout` parameter for operations `FUTEX_REQUEUE`, `FUTEX_CMP_REQUEUE` and `FUTEX_WAKE_OP`." ], "previous_source": "", "target": [ "No hay parámetro `val2` en el prototipo de futex. `val2` se toma del parámetro `struct timespec *timeout` para las operaciones `FUTEX_REQUEUE`, `FUTEX_CMP_REQUEUE` y `FUTEX_WAKE_OP`." ], "id_hash": 8039321241458356819, "content_hash": 8039321241458356819, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:1208", "context": "", "note": "type: delimited block = 4", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 330, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 25, "source_unit": "https://translate-dev.freebsd.org/api/units/612479/?format=api", "priority": 100, "id": 612480, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=ef9168133060b253", "url": "https://translate-dev.freebsd.org/api/units/612480/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2021-03-20T20:37:59.974242Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "The futex emulation in FreeBSD is taken from NetBSD and further extended by us. It is placed in `linux_futex.c` and [.filename]#linux_futex.h# files. The `futex` structure looks like:" ], "previous_source": "", "target": [ "La emulación de futex en FreeBSD ha sido importada de NetBSD y después extendida por nosotros. Se encuentra en los ficheros `linux_futex.c` y [.filename]#linux_futex.h#. La estructura `futex` tiene este aspecto:" ], "id_hash": -8789590976928365375, "content_hash": -8789590976928365375, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:1216", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 332, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 27, "source_unit": "https://translate-dev.freebsd.org/api/units/612481/?format=api", "priority": 100, "id": 612482, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=060519936334c4c1", "url": "https://translate-dev.freebsd.org/api/units/612482/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2021-03-20T20:38:00.022138Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "A futex is obtained using the `futex_get` function, which searches a linear list of futexes and returns the found one or creates a new futex. When releasing a futex from the use we call the `futex_put` function, which decreases a reference counter of the futex and if the refcount reaches zero it is released." ], "previous_source": "", "target": [ "Un futex se obtiene utilizando la función `futex_get`, que busca en una lista lineal de futexes y devuelve el encontrado o crea un nuevo futex. Cuando liberamos un futex llamamos a la función `futex_put`, que disminuye un contador de referencia del futex y si el refcount llega a cero lo libera." ], "id_hash": 626381773951781664, "content_hash": 626381773951781664, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:1248", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 342, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 54, "source_unit": "https://translate-dev.freebsd.org/api/units/612483/?format=api", "priority": 100, "id": 612484, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=88b15ae79a2ccb20", "url": "https://translate-dev.freebsd.org/api/units/612484/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2021-03-20T20:38:00.541942Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "When a futex queues a thread for sleeping it creates a `working_proc` structure and puts this structure to the list inside the futex structure then it just performs a man:tsleep[9] to suspend the thread. The sleep can be timed out. After man:tsleep[9] returns (the thread was woken up or it timed out) the `working_proc` structure is removed from the list and is destroyed. All this is done in the `futex_sleep` function. If we got woken up from `futex_wake` we have `wp_new_futex` set so we sleep on it. This way the actual requeueing is done in this function." ], "previous_source": "", "target": [ "Cuando un futex encola un hilo para que duerma crea una estructura `working_proc` y la pone en la lista dentro de la estructura del futext, después simplemente llama a man:tsleep[9] para suspender el hilo. El tiempo de suspensión puede finalizar por timeout. Después de volver the man:tsleep[9] (el hilo ha sido despertado o ha ocurrido un timeout) se quita la estructura `working_proc` de la lista y se destruye. Todo esto se hace en la función `futex_sleep`. Si se nos despertó con `futex_wak` tenemos `wp_new_futex` establecido de forma que lo utilizamos para dormir. De este modo el reencolado en realidad se hace en esta función." ], "id_hash": -8962970972949395125, "content_hash": -8962970972949395125, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:1258", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 344, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 97, "source_unit": "https://translate-dev.freebsd.org/api/units/612485/?format=api", "priority": 100, "id": 612486, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=039d21635136c94b", "url": "https://translate-dev.freebsd.org/api/units/612486/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2021-03-20T20:38:00.643059Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "Waking up a thread sleeping on a futex is performed in the `futex_wake` function. First in this function we mimic the strange Linux(R) behavior, where it wakes up N threads for all operations, the only exception is that the REQUEUE operations are performed on N+1 threads. But this usually does not make any difference as we are waking up all threads. Next in the function in the loop we wake up n threads, after this we check if there is a new futex for requeueing. If so, we requeue up to n2 threads on the new futex. This cooperates with `futex_sleep`." ], "previous_source": "", "target": [ "Despertar a un hilo que está durmiendo en un futex se hace con la función `futex_wake`. En esta función lo primero que hacemos es imitar el extraño comportamiento de Linux(R), donde despierta N hilos para todas las operaciones, la únca excepción es que las operaciones REQUEUE se hacen en N+1 hilos. Pero normalmente esto no supone ninguna diferencia ya que estamos despertando todos los hilos. Lo siguiente en la función es el bucle en el que despertamos n hilos, después comprobamos si hay algún futex nuevo para reencolar. Si es así, reencolamos un máximo de n2 hilos en el nuevo futex. Esto coopera con `futex_sleep`." ], "id_hash": -1736167518418197166, "content_hash": -1736167518418197166, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:1268", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 346, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 101, "source_unit": "https://translate-dev.freebsd.org/api/units/612487/?format=api", "priority": 100, "id": 612488, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=67e7e4d7321ca552", "url": "https://translate-dev.freebsd.org/api/units/612488/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2021-03-20T20:38:00.860712Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "The `FUTEX_WAKE_OP` operation is quite complicated. First we obtain two futexes at addresses `uaddr` and `uaddr2` then we perform the atomic operation using `val3` and `uaddr2`. Then `val` waiters on the first futex is woken up and if the atomic operation condition holds we wake up `val2` (i.e. `timeout`) waiter on the second futex." ], "previous_source": "", "target": [ "La operación `FUTEX_WAKE_OP` is bastante complicada. Primero obtenemos dos futex en las direcciones `uaddr` y `uaddr2` después realizamos una operación atómica usando `val3` y `uaddr2`. Después se despierta a `val` hilos que estuvieran durmiendo y si se cumple la condición de la operación atómica despertamos `val2` (es decir `timeout`) hilos durmientes en el segundo futex." ], "id_hash": -8950971339229495244, "content_hash": -8950971339229495244, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:1275", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 348, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 54, "source_unit": "https://translate-dev.freebsd.org/api/units/612489/?format=api", "priority": 100, "id": 612490, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=03c7c2fdc2860034", "url": "https://translate-dev.freebsd.org/api/units/612490/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2021-03-20T20:38:00.970490Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "The atomic operation takes two parameters `encoded_op` and `uaddr`. The encoded operation encodes the operation itself, comparing value, operation argument, and comparing argument. The pseudocode for the operation is like this one:" ], "previous_source": "", "target": [ "La operación atómica toma dos parámetros `encoded_op` y `uaddr`. La operación codificada codifica la operación en sí, comparando valor, argumento de operación y argumento de comparación. El pseudocódigo para la operación es como este:" ], "id_hash": 494149436259844588, "content_hash": 494149436259844588, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:1282", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 350, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 32, "source_unit": "https://translate-dev.freebsd.org/api/units/612491/?format=api", "priority": 100, "id": 612492, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=86db924b4e3a41ec", "url": "https://translate-dev.freebsd.org/api/units/612492/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2021-03-20T20:38:01.145868Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "And this is done atomically. First a copying in of the number at `uaddr` is performed and the operation is done. The code handles page faults and if no page fault occurs `oldval` is compared to `cmparg` argument with cmp comparator." ], "previous_source": "", "target": [ "Y esto se hace automáticamente. Primero se realiza la copia del número en `uaddr` y la operación ha terminado. El código maneja fallos de página y si no ocurre ningún se compara `oldval` con `cmparg` con el comparador cmp." ], "id_hash": 8344314602632216278, "content_hash": 8344314602632216278, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:1291", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 352, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 41, "source_unit": "https://translate-dev.freebsd.org/api/units/612493/?format=api", "priority": 100, "id": 612494, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=f3ccf5ebc7ff7ed6", "url": "https://translate-dev.freebsd.org/api/units/612494/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2021-03-20T20:38:01.282526Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "Futex implementation uses two lock lists protecting `sx_lock` and global locks (either Giant or another `sx_lock`). Every operation is performed locked from the start to the very end." ], "previous_source": "", "target": [ "La implementación de futex utiliza dos listas de bloqueo que protegen `sx_lock` y locks globales (ya sea Giant u otro `sx_lock`). Cada operación se realiza estando bloqueada desde el principio hasta el final." ], "id_hash": -3028108255872644760, "content_hash": -3028108255872644760, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:1297", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 354, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 28, "source_unit": "https://translate-dev.freebsd.org/api/units/612495/?format=api", "priority": 100, "id": 612496, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=55f9ff95bb488968", "url": "https://translate-dev.freebsd.org/api/units/612496/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2021-03-20T20:38:01.529455Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "During development of Linux(R) 2.6.16 kernel, the *at syscalls were added. Those syscalls (`openat` for example) work exactly like their at-less counterparts with the slight exception of the `dirfd` parameter. This parameter changes where the given file, on which the syscall is to be performed, is. When the `filename` parameter is absolute `dirfd` is ignored but when the path to the file is relative, it comes to the play. The `dirfd` parameter is a directory relative to which the relative pathname is checked. The `dirfd` parameter is a file descriptor of some directory or `AT_FDCWD`. So for example the `openat` syscall can be like this:" ], "previous_source": "", "target": [ "Durante el desarrollo del kernel 2.6.16 de Linux(R) se añadieron las llamadas al sistema *at. Esas llamadas (`openat` por ejemplo) funcionan igual que sus pares sin `at` con la pequeña diferencia del parámetro `dirfd`. Este parámetro cambia con el fichero dado sobre el que se va a realizar la llamada al sistema. Cuando el parámetro `filename` es absoluto `dirfd` es ignorado pero cuando la ruta al fichero es relativa, entra en juego. El parámetro `dirfd` es un directorio relativo al cual se comprueba la ruta relativa. El parámetro `dirfd` es un descriptor de fichero de algún directorio o `AT_FDCWD`. Por ejemplo la llamada al sistema `openat` podría ser así:" ], "id_hash": 7441000148816683512, "content_hash": 7441000148816683512, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:1313", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 358, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 105, "source_unit": "https://translate-dev.freebsd.org/api/units/612497/?format=api", "priority": 100, "id": 612498, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=e743be3613d8e1f8", "url": "https://translate-dev.freebsd.org/api/units/612498/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2021-03-20T20:38:01.775053Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "This infrastructure is necessary to avoid races when opening files outside the working directory. Imagine that a process consists of two threads, thread A and thread B. Thread A issues `open(./tmp/foo/bah., flags, mode)` and before returning it gets preempted and thread B runs. Thread B does not care about the needs of thread A and renames or removes [.filename]#/tmp/foo/#. We got a race. To avoid this we can open [.filename]#/tmp/foo# and use it as `dirfd` for `openat` syscall. This also enables user to implement per-thread working directories." ], "previous_source": "", "target": [ "Esta infraestructura es necesaria para evitar condiciones de carrera cuando se abren ficheros fuera del directorio de trabajo actual. Imagina un proceso que consiste en dos hilos, hilo A e hilo B. El hilo A realiza `open(./tmp/foo/bah., flags, mode)` y antes de volver es desalojado y se ejecuta el hilo B. El hilo B no se preocupa por las necesidades del hilo A y renombra o elimina [.filename]#/tmp/foo/#. Tenemos una condición de carrera. Para evitar esto podemos abrir [.filename]#/tmp/foo# y utilizarlo como `dirfd` en la llamada al sistema `openat`. Esto permite al usuario implementar directorios de trabajo por hilo." ], "id_hash": -1760718865690999471, "content_hash": -1760718865690999471, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:1331", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 361, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 87, "source_unit": "https://translate-dev.freebsd.org/api/units/612499/?format=api", "priority": 100, "id": 612500, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=6790ab853528c551", "url": "https://translate-dev.freebsd.org/api/units/612500/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2021-03-20T20:38:01.972312Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "Linux(R) family of *at syscalls contains: `linux_openat`, `linux_mkdirat`, `linux_mknodat`, `linux_fchownat`, `linux_futimesat`, `linux_fstatat64`, `linux_unlinkat`, `linux_renameat`, `linux_linkat`, `linux_symlinkat`, `linux_readlinkat`, `linux_fchmodat` and `linux_faccessat`. All these are implemented using the modified man:namei[9] routine and simple wrapping layer." ], "previous_source": "", "target": [ "La familia *at de llamadas al sistema de Linux(R) contiene: `linux_openat`, `linux_mkdirat`, `linux_mknodat`, `linux_fchownat`, `linux_futimesat`, `linux_fstatat64`, `linux_unlinkat`, `linux_renameat`, `linux_linkat`, `linux_symlinkat`, `linux_readlinkat`, `linux_fchmodat` y `linux_faccessat`. Todas se implementan utilizando la rutina modificada man:nami[9] y una sencilla capa de envoltorio." ], "id_hash": 8848505497996433484, "content_hash": 8848505497996433484, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:1334", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 362, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 33, "source_unit": "https://translate-dev.freebsd.org/api/units/612501/?format=api", "priority": 100, "id": 612502, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=facc34de792b184c", "url": "https://translate-dev.freebsd.org/api/units/612502/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2021-03-20T20:38:02.053012Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "The implementation is done by altering the man:namei[9] routine (described above) to take additional parameter `dirfd` in its `nameidata` structure, which specifies the starting point of the pathname lookup instead of using the current working directory every time. The resolution of `dirfd` from file descriptor number to a vnode is done in native *at syscalls. When `dirfd` is `AT_FDCWD` the `dvp` entry in `nameidata` structure is `NULL` but when `dirfd` is a different number we obtain a file for this file descriptor, check whether this file is valid and if there is vnode attached to it then we get a vnode. Then we check this vnode for being a directory. In the actual man:namei[9] routine we simply substitute the `dvp` vnode for `dp` variable in the man:namei[9] function, which determines the starting point. The man:namei[9] is not used directly but via a trace of different functions on various levels. For example the `openat` goes like this:" ], "previous_source": "", "target": [ "La implementación se hace modificando la rutina man:namei[9] (descrita arriba) para que tenga un parámetro adicional `dirfd` en su estructura `nameidata`, que especifica el punto de comienzo de la búsqueda de la ruta en lugar de utilizar el directorio de trabajo cada vez. La resolución de `dirfd` a vnode a partir del número de descriptor de fichero se hace en las llamadas al sistema *at nativas. Cuando `dirfd` es `AT_FDCWD` la entrada `dvp` en la estructura `nameidata` es `NULL` pero cuando `dirfd` otro número obtenemos el fichero para este descriptor de fichero, comprobamos si el fichero es válido y si tiene un vnode asociado lo obtenemos. Después comprobamos que el vnode sea un directorio. En la rutina man:namei[9] real simplemente sustituimos el vnode `dvp` por la variable `dp` en la función man:namei[9] que determina el punto de comienzo. man:namei[9] no se usa directamente sino mediante una traza de diferentes funciones a diferentes niveles. Por ejemplo `openat` hace esto:" ], "id_hash": -7420896031023348147, "content_hash": -7420896031023348147, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:1344", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 364, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 156, "source_unit": "https://translate-dev.freebsd.org/api/units/612503/?format=api", "priority": 100, "id": 612504, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=1903ae609bbf464d", "url": "https://translate-dev.freebsd.org/api/units/612504/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2021-03-20T20:38:02.274245Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "For this reason `kern_open` and `vn_open` must be altered to incorporate the additional `dirfd` parameter. No compat layer is created for those because there are not many users of this and the users can be easily converted. This general implementation enables FreeBSD to implement their own *at syscalls. This is being discussed right now." ], "previous_source": "", "target": [ "Por esta razón `kern_open` y `vn_open` deben modificarse para incorporar el parámetro adicional `dirfd`. No se crea una capa de compatibilidad para aquellos porque no hay muchos usuarios de esta y los usuarios se pueden convertir fácilmente. Esta implementación general permite a FreeBSD implementar su propio *at llamadas al sistema. Esto está siendo discutido ahora mismo." ], "id_hash": 756326912771740868, "content_hash": 756326912771740868, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:1354", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 366, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 54, "source_unit": "https://translate-dev.freebsd.org/api/units/612505/?format=api", "priority": 100, "id": 612506, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=8a7f0351e9d3d4c4", "url": "https://translate-dev.freebsd.org/api/units/612506/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2021-03-20T20:38:02.519597Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "The ioctl interface is quite fragile due to its generality. We have to bear in mind that devices differ between Linux(R) and FreeBSD so some care must be applied to do ioctl emulation work right. The ioctl handling is implemented in [.filename]#linux_ioctl.c#, where `linux_ioctl` function is defined. This function simply iterates over sets of ioctl handlers to find a handler that implements a given command. The ioctl syscall has three parameters, the file descriptor, command and an argument. The command is a 16-bit number, which in theory is divided into high 8 bits determining class of the ioctl command and low 8 bits, which are the actual command within the given set. The emulation takes advantage of this division. We implement handlers for each set, like `sound_handler` or `disk_handler`. Each handler has a maximum command and a minimum command defined, which is used for determining what handler is used. There are slight problems with this approach because Linux(R) does not use the set division consistently so sometimes ioctls for a different set are inside a set they should not belong to (SCSI generic ioctls inside cdrom set, etc.). FreeBSD currently does not implement many Linux(R) ioctls (compared to NetBSD, for example) but the plan is to port those from NetBSD. The trend is to use Linux(R) ioctls even in the native FreeBSD drivers because of the easy porting of applications." ], "previous_source": "", "target": [ "La interfaz ioctl es bastante frágil debido a su genericidad. Tenemos que tener en cuenta que los dispositivos difieren entre Linux(R) y FreeBSD, por lo que se debe tener cuidado para que la emulación de ioctl funcione correctamente. El manejo de ioctl se implementa en `linux_ioctl.c`, donde se define la función `linux_ioctl`. Esta función simplemente itera sobre conjuntos de manejadores ioctl para encontrar un manejador que implemente un comando dado. La llamada al sistema ioctl tiene tres parámetros, el descriptor de archivo, el comando y un argumento. El comando es un número de 16 bits, que en teoría se divide en 8 bits altos que determinan la clase del comando ioctl y 8 bits bajos, que son el comando real dentro del conjunto dado. La emulación aprovecha esta división. Implementamos controladores para cada conjunto, como `sound_handler` o `disk_handler`.Cada controlador tiene un comando máximo y un comando mínimo definido, que se utiliza para determinar qué controlador se utiliza. Hay leves problemas con este enfoque porque Linux(R) no usa la división de conjuntos de manera consistente, por lo que a veces los ioctls de un conjunto diferente están dentro de un conjunto al que no deberían pertenecer (ioctls genéricos SCSI dentro del conjunto cdrom, etc.). FreeBSD actualmente no implementa muchos ioctls de Linux(R) (en comparación con NetBSD, por ejemplo) pero el plan es portarlos de NetBSD. La tendencia es usar ioctls de Linux(R) incluso en los controladores nativos de FreeBSD debido a la fácil migración de las aplicaciones." ], "id_hash": -1379057792690456037, "content_hash": -1379057792690456037, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:1370", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 368, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 230, "source_unit": "https://translate-dev.freebsd.org/api/units/612507/?format=api", "priority": 100, "id": 612508, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=6cdc9a3e7df37a1b", "url": "https://translate-dev.freebsd.org/api/units/612508/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2021-03-20T20:38:02.718542Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "Every syscall should be debuggable. For this purpose we introduce a small infrastructure. We have the ldebug facility, which tells whether a given syscall should be debugged (settable via a sysctl). For printing we have LMSG and ARGS macros. Those are used for altering a printable string for uniform debugging messages." ], "previous_source": "", "target": [ "Cada llamada al sistema debería ser depurable. Para ello introducimos una pequeña infraestructura. Tenemos la función ldebug, que indica si una llamada al sistema determinada debe depurarse (configurable mediante un sysctl). Para imprimir tenemos macros LMSG y ARGS. Se utilizan para alterar una cadena imprimible para mensajes de depuración uniformes." ], "id_hash": 6004120613388596265, "content_hash": 6004120613388596265, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:1379", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 370, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 51, "source_unit": "https://translate-dev.freebsd.org/api/units/612509/?format=api", "priority": 100, "id": 612510, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=d352ebe2fda0b429", "url": "https://translate-dev.freebsd.org/api/units/612510/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2021-03-20T20:38:02.896128Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "As of April 2007 the Linux(R) emulation layer is capable of emulating the Linux(R) 2.6.16 kernel quite well. The remaining problems concern futexes, unfinished *at family of syscalls, problematic signals delivery, missing `epoll` and `inotify` and probably some bugs we have not discovered yet. Despite this we are capable of running basically all the Linux(R) programs included in FreeBSD Ports Collection with Fedora Core 4 at 2.6.16 and there are some rudimentary reports of success with Fedora Core 6 at 2.6.16. The Fedora Core 6 linux_base was recently committed enabling some further testing of the emulation layer and giving us some more hints where we should put our effort in implementing missing stuff." ], "previous_source": "", "target": [ "A fecha de abril de 2007 la capa de emulación de Linux(R) es capaz de emular el kernel Linux(R) 2.6.16 bastante bien. Los problemas que quedan son sobre futexes, la familia de llamadas al sistema *at sin terminar, problemas con el envío de señales, la ausencia de `epoll` y `inotify` y probablemente algunos bugs que no se han descubierto todavía. A pesar de esto somos capaces de ejecutar básicamente todos los programas Linux(R) incluidos en la colección de ports con Fedora Core 4 en 2.6.16 y hay algunos informes rudimentarios de éxito con Fedora Core 6 en 2.6.16. El linux_base de Fedora Core 6 se añadió al repositorio recientemente permitiendo más pruebas de la capa de emulación y dándonos más pistas sobre dónde debemos poner el esfuerzo para implementar las cosas que faltan." ], "id_hash": -6612982264028953685, "content_hash": -6612982264028953685, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:1390", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 373, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 113, "source_unit": "https://translate-dev.freebsd.org/api/units/612511/?format=api", "priority": 100, "id": 612512, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=2439f7aafe9883ab", "url": "https://translate-dev.freebsd.org/api/units/612512/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2021-03-20T20:38:03.030092Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "We are able to run the most used applications like package:www/linux-firefox[], package:net-im/skype[] and some games from the Ports Collection. Some of the programs exhibit bad behavior under 2.6 emulation but this is currently under investigation and hopefully will be fixed soon. The only big application that is known not to work is the Linux(R) Java(TM) Development Kit and this is because of the requirement of `epoll` facility which is not directly related to the Linux(R) kernel 2.6." ], "previous_source": "", "target": [ "Somos capaces de ejecutar las aplicaciones más usadas como package:www/linux-firefox[], package:net-im/skype[] y algunos juegos de la colección de ports. Algunos programas tienen un mal comportamiento bajo la emulación de 2.6 pero se está investigando y con suerte se solucionará pronto. La única aplicación grande que se sabe que no funciona es el Java(TM) Development Kit de Linux(R). Esto es porque requiere `epoll` el cual no está directamente relacionado con el kernel Linux(R) 2.6." ], "id_hash": 730840471126071835, "content_hash": 730840471126071835, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:1394", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 374, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 77, "source_unit": "https://translate-dev.freebsd.org/api/units/612513/?format=api", "priority": 100, "id": 612514, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=8a2477894cf2da1b", "url": "https://translate-dev.freebsd.org/api/units/612514/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2021-03-20T20:38:03.103669Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "We hope to enable 2.6.16 emulation by default some time after FreeBSD 7.0 is released at least to expose the 2.6 emulation parts for some wider testing. Once this is done we can switch to Fedora Core 6 linux_base, which is the ultimate plan." ], "previous_source": "", "target": [ "Esperamos habilitar la emulación 2.6.16 por defecto algún tiempo después del lanzamiento de FreeBSD 7.0 al menos para exponer las partes de la emulación 2.6 para pruebas más amplias. Una vez hecho esto, podemos cambiar a Fedora Core 6 linux_base, que es el plan definitivo." ], "id_hash": -2983019285113664810, "content_hash": -2983019285113664810, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:1397", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 375, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 44, "source_unit": "https://translate-dev.freebsd.org/api/units/612515/?format=api", "priority": 100, "id": 612516, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=569a2fc3d0a90ad6", "url": "https://translate-dev.freebsd.org/api/units/612516/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2021-03-20T20:38:03.203984Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "The other possible goal is to share our code with NetBSD and DragonflyBSD. NetBSD has some support for 2.6 emulation but its far from finished and not really tested. DragonflyBSD has expressed some interest in porting the 2.6 improvements." ], "previous_source": "", "target": [ "El otro objetivo posible es compartir nuestro código con NetBSD y DragonflyBSD. NetBSD tiene algo de soporte para la emulación 2.6 pero está lejos de estar terminado y no se ha probado realmente. DragonflyBSD ha expresado cierto interés en portar las mejoras 2.6." ], "id_hash": 5264419404362419272, "content_hash": 5264419404362419272, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:1408", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 379, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 39, "source_unit": "https://translate-dev.freebsd.org/api/units/612517/?format=api", "priority": 100, "id": 612518, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=c90ef98e61b20c48", "url": "https://translate-dev.freebsd.org/api/units/612518/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2021-03-20T20:38:03.550983Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "A technical description about the internals of the Linux emulation layer in FreeBSD" ], "previous_source": "", "target": [ "Una descripción técnica acerca del funcionamiento interno de la capa de emulación Linux en FreeBSD" ], "id_hash": -4806794379516982539, "content_hash": -4806794379516982539, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:1", "context": "", "note": "type: YAML Front Matter: description", "flags": "no-wrap", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 1, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 13, "source_unit": "https://translate-dev.freebsd.org/api/units/1176936/?format=api", "priority": 100, "id": 1176938, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=3d4ad5fab48bcaf5", "url": "https://translate-dev.freebsd.org/api/units/1176938/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2021-06-03T21:56:24.535579Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "Generally, as Linux(R) develops we would like to keep up with their development, implementing newly added syscalls. Splice comes to mind first. Some already implemented syscalls are also suboptimal, for example `mremap` and others. Some performance improvements can also be made, finer grained locking and others." ], "previous_source": "", "target": [ "En general, conforme se desarrolla Linux(R) nos gustaría seguir actualizados con su desarrollo, implementando las nuevas llamadas al sistema. Splice se me viene a la cabeza. Algunas de las llamadas al sistema ya implementadas son subóbtimas, por ejemplo `mremap` y otras. Se pueden hacer algunas mejoras de rendimiento, bloqueos más finos y otras cosas." ], "id_hash": 6849135605214007000, "content_hash": 6849135605214007000, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:1413", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 380, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 46, "source_unit": "https://translate-dev.freebsd.org/api/units/1248568/?format=api", "priority": 100, "id": 1248570, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=df0d048b6f42ced8", "url": "https://translate-dev.freebsd.org/api/units/1248570/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2021-07-24T15:11:44.374857Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "heavyweight threads" ], "previous_source": "", "target": [ "hilos pesados" ], "id_hash": 2131448140061764323, "content_hash": 2131448140061764323, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:149", "context": "", "note": "type: Bullet: '- '", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 27, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 2, "source_unit": "https://translate-dev.freebsd.org/api/units/1448255/?format=api", "priority": 100, "id": 1448271, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=9d946cca5d8c6ae3", "url": "https://translate-dev.freebsd.org/api/units/1448271/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2022-08-07T14:46:34.613841Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "the scheduling cannot be altered by the user (slightly mitigated by the POSIX(R) API)" ], "previous_source": "", "target": [ "el usuario no puede alterar la planificación (ligeramente mitigado por el API de POSIX(R))" ], "id_hash": -4463103053929207920, "content_hash": -4463103053929207920, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:150", "context": "", "note": "type: Bullet: '- '", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 28, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 14, "source_unit": "https://translate-dev.freebsd.org/api/units/1448257/?format=api", "priority": 100, "id": 1448272, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=420fdf6b4296a790", "url": "https://translate-dev.freebsd.org/api/units/1448272/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2022-08-07T14:46:34.621916Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "no syscall wrapping necessary" ], "previous_source": "", "target": [ "no es necesario un recubrimiento para la llamada al sistema" ], "id_hash": 7863890615372381580, "content_hash": 7863890615372381580, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:151", "context": "", "note": "type: Bullet: '+ '", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 29, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 4, "source_unit": "https://translate-dev.freebsd.org/api/units/1448259/?format=api", "priority": 100, "id": 1448273, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=ed2226d999cc7d8c", "url": "https://translate-dev.freebsd.org/api/units/1448273/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2022-08-07T14:46:34.652429Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "can utilize multiple CPUs" ], "previous_source": "", "target": [ "puede utilizar varias CPU" ], "id_hash": 3651460901107954031, "content_hash": 3651460901107954031, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:152", "context": "", "note": "type: Bullet: '+ '", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 30, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 4, "source_unit": "https://translate-dev.freebsd.org/api/units/1448261/?format=api", "priority": 100, "id": 1448274, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=b2ac9857e1c4716f", "url": "https://translate-dev.freebsd.org/api/units/1448274/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2022-08-07T14:46:34.661202Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "lightweight threads" ], "previous_source": "", "target": [ "hilos ligeros" ], "id_hash": -3195886534262674600, "content_hash": -3195886534262674600, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:156", "context": "", "note": "type: Bullet: '+ '", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 32, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 2, "source_unit": "https://translate-dev.freebsd.org/api/units/1448263/?format=api", "priority": 100, "id": 1448275, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=53a5ee212ed1ab58", "url": "https://translate-dev.freebsd.org/api/units/1448275/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2022-08-07T14:46:34.668175Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "scheduling can be easily altered by the user" ], "previous_source": "", "target": [ "el usuario puede modificar fácilmente la planificación" ], "id_hash": -6597468440894530277, "content_hash": -6597468440894530277, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:157", "context": "", "note": "type: Bullet: '+ '", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 33, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 8, "source_unit": "https://translate-dev.freebsd.org/api/units/1448265/?format=api", "priority": 100, "id": 1448276, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=247115686ba19d1b", "url": "https://translate-dev.freebsd.org/api/units/1448276/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2022-08-07T14:46:34.678491Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "syscalls must be wrapped" ], "previous_source": "", "target": [ "las llamadas al sistema necesitan estar recubiertas" ], "id_hash": 5501615680580883825, "content_hash": 5501615680580883825, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:158", "context": "", "note": "type: Bullet: '- '", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 34, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 4, "source_unit": "https://translate-dev.freebsd.org/api/units/1448267/?format=api", "priority": 100, "id": 1448277, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=cc59aa500bbe1571", "url": "https://translate-dev.freebsd.org/api/units/1448277/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2022-08-07T14:46:34.686031Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "cannot utilize more than one CPU" ], "previous_source": "", "target": [ "no puede utilizar más de una CPU" ], "id_hash": 1241693181600663880, "content_hash": 1241693181600663880, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:159", "context": "", "note": "type: Bullet: '- '", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 35, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 6, "source_unit": "https://translate-dev.freebsd.org/api/units/1448269/?format=api", "priority": 100, "id": 1448278, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=913b615eb1550948", "url": "https://translate-dev.freebsd.org/api/units/1448278/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2022-08-07T14:46:34.692444Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "Block locks let waiters to be descheduled and blocked until the lock owner does not drop it and wakes up one or more contenders. To avoid starvation issues, blocking locks do priority propagation from the waiters to the owner. Block locks must be implemented through the turnstile interface and are intended to be the most used kind of locks in the kernel, if no particular conditions are met." ], "previous_source": "", "target": [ "Los locks de bloques permiten que los que esperan sean desprogramados y bloqueados hasta que el propietario del lock no lo libere y despierte a uno o más contendientes. Para evitar problemas de inanición, los locks de bloque propagan la prioridad de los que esperan al propietario. Los locks de bloque deben implementarse a través de la interfaz turnstile y están destinados a ser el tipo de bloqueo más utilizado en el núcleo, si no se cumplen condiciones particulares." ], "id_hash": -5251695298691301829, "content_hash": -5251695298691301829, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:522", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 142, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 68, "source_unit": "https://translate-dev.freebsd.org/api/units/1566398/?format=api", "priority": 100, "id": 1566410, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=371e3af354ea7e3b", "url": "https://translate-dev.freebsd.org/api/units/1566410/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2023-05-21T18:01:51.602713Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "Scheduling barriers are intended to be used to drive scheduling of threading. They consist mainly of three different stubs:" ], "previous_source": "", "target": [ "Las barreras de programación están destinadas a utilizarse para impulsar la programación multihilo. Consisten principalmente en tres elementos diferentes:" ], "id_hash": 6720720067887010149, "content_hash": 6720720067887010149, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:553", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 158, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 19, "source_unit": "https://translate-dev.freebsd.org/api/units/1566400/?format=api", "priority": 100, "id": 1566411, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=dd44cb4b393e9165", "url": "https://translate-dev.freebsd.org/api/units/1566411/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2023-05-21T18:01:51.604958Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "The FreeBSD kernel has been made preemptive basically to deal with interrupt threads. In fact, to avoid high interrupt latency, time-sharing priority threads can be preempted by interrupt threads (in this way, they do not need to wait to be scheduled as the normal path previews). Preemption, however, introduces new racing points that need to be handled, as well. Often, to deal with preemption, the simplest thing to do is to completely disable it. A critical section defines a piece of code (borderlined by the pair of functions man:critical_enter[9] and man:critical_exit[9], where preemption is guaranteed to not happen (until the protected code is fully executed). This can often replace a lock effectively but should be used carefully to not lose the whole advantage that preemption brings." ], "previous_source": "", "target": [ "El kernel de FreeBSD se ha hecho preemptivo básicamente para tratar con hilos de interrupción. De hecho, para evitar una latencia de interrupción alta, los hilos de tiempo compartido con prioridad pueden ser reemplazados por hilos de interrupción (de esta manera, no necesitan esperar para ser programados como vistas previas de la ruta normal). Un kernel preemptivo, sin embargo, introduce nuevos puntos de carrera que también deben manejarse. A menudo, para hacer frente a la preemptividad, lo más sencillo es desactivarla por completo. Una sección crítica define un fragmento de código (delimitado por el par de funciones man:critical_enter[9] y man:critical_exit[9], donde se garantiza que la preemptividad no ocurrirá hasta que el código protegido se ejecute por completo). Esto a menudo puede reemplazar un lock de manera efectiva, pero debe usarse con cuidado para no perder toda la ventaja que brinda la preemptividad." ], "id_hash": 6448614166028463281, "content_hash": 6448614166028463281, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:569", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 164, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 126, "source_unit": "https://translate-dev.freebsd.org/api/units/1566402/?format=api", "priority": 100, "id": 1566412, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=d97e146af3adacb1", "url": "https://translate-dev.freebsd.org/api/units/1566412/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2023-05-21T18:01:51.606417Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "`sched_bind` is an API used to bind a thread to a particular CPU for all the time it executes the code, until a `sched_unbind` function call does not unbind it. This feature has a key role in situations where you cannot trust the current state of CPUs (for example, at very early stages of boot), as you want to avoid your thread to migrate on inactive CPUs. Since `sched_bind` and `sched_unbind` manipulate internal scheduler structures, they need to be enclosed in `sched_lock` acquisition/releasing when used." ], "previous_source": "", "target": [ "`sched_bind` es una API que se utiliza para vincular un hilo a una CPU en particular durante todo el tiempo que ejecuta el código, hasta que no lo desvincula la llamada a la función `sched_unbind`. Esta función tiene un papel clave en situaciones en las que no puedes confiar en el estado actual de las CPU (por ejemplo, en las primeras etapas del arranque), ya que deseas evitar que tu hilo migre a CPUs inactivas. Como `sched_bin` y `sched_unbind` manipulan las estructuras internas del planificador, es necesario que estén dentro de la adquisición/liberación `sched_lock` cuando se usan." ], "id_hash": 8560817204724441286, "content_hash": 8560817204724441286, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:584", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 168, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 85, "source_unit": "https://translate-dev.freebsd.org/api/units/1566404/?format=api", "priority": 100, "id": 1566413, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=f6ce21e3faa720c6", "url": "https://translate-dev.freebsd.org/api/units/1566413/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2023-05-21T18:01:51.608359Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "The Linux(R) emulation layer is not complete, as some syscalls are not implemented properly and some are not implemented at all. The emulation layer employs a facility to mark unimplemented syscalls with the `DUMMY` macro. These dummy definitions reside in [.filename]#linux_dummy.c# in a form of `DUMMY(syscall);`, which is then translated to various syscall auxiliary files and the implementation consists of printing a message saying that this syscall is not implemented. The `UNIMPL` prototype is not used because we want to be able to identify the name of the syscall that was called to know what syscalls are more important to implement." ], "previous_source": "", "target": [ "La capa de emulación de Linux(R) no es completa ya que algunas llamadas al sistema no están implementadas de forma adecuada y otras no están implementadas en absoluto. La capa de emulación utiliza un método para marcar las llamadas al sistema no implementadas con la macro `DUMMY`. Estas definiciones dummy se encuentran en [.filename]#linux_dummy.c# en la forma `DUMMY(syscall)`, que luego se traduce a varios ficheros auxiliares de llamadas al sistema y cuya implementación consiste en imprimir un mensaje diciendo que la llamada no está implementada. El prototipo `UNIMPL` no se utiliza porque queremos ser capaces de identificar el nombre de la llamada al sistema que fue invocada con el fin de saber qué llamadas al sistema son importantes de implementar." ], "id_hash": 8627087086411551284, "content_hash": 8627087086411551284, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:745", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 214, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 101, "source_unit": "https://translate-dev.freebsd.org/api/units/1566406/?format=api", "priority": 100, "id": 1566414, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=f7b991ff2feb9234", "url": "https://translate-dev.freebsd.org/api/units/1566414/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2023-05-21T18:01:51.612280Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "Many UNIX(R) derivates implement the man:ptrace[2] syscall to allow various tracking and debugging features. This facility enables the tracing process to obtain various information about the traced process, like register dumps, any memory from the process address space, etc. and also to trace the process like in stepping an instruction or between system entries (syscalls and traps). man:ptrace[2] also lets you set various information in the traced process (registers etc.). man:ptrace[2] is a UNIX(R)-wide standard implemented in most UNIX(R)es around the world." ], "previous_source": "", "target": [ "Muchos derivados de UNIX(R) implementan la llamada al sistema man:ptrace[2] para proporcionar diversas características de depuración y traza. Estas características permiten la traza de un proceso para obtener información valiosa acerca del proceso que es trazado, como volcado de registros, cualquier posición de memoria del espacio de direcciones del proceso, etc. y también para trazar procesos para saltar una instrucción o entre entradas al sistema (llamadas al sistema y traps). man:ptrace[2] también te permite establecer información en los procesos trazados (registros, etc). man:ptrace[2] es un estándar ampliamente disponible e implementado en la mayoría de UNIX(R) en todo el mundo." ], "id_hash": 3486843851922750293, "content_hash": 3486843851922750293, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:782", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 224, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 82, "source_unit": "https://translate-dev.freebsd.org/api/units/1566408/?format=api", "priority": 100, "id": 1566415, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=b063c2025d1c3b55", "url": "https://translate-dev.freebsd.org/api/units/1566415/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2023-05-21T18:01:51.614306Z" }, { "translation": "https://translate-dev.freebsd.org/api/translations/documentation/articleslinux-emulation_index/es/?format=api", "source": [ "Common UNIX(R) API defines a syscall as a way to issue commands from a user space process to the kernel. The most common implementation is either by using an interrupt or specialized instruction (think of `SYSENTER`/`SYSCALL` instructions for ia32). Syscalls are defined by a number. For example in FreeBSD, the syscall number 85 is the man:swapon[2] syscall and the syscall number 132 is man:mkfifo[2]. Some syscalls need parameters, which are passed from the user-space to the kernel-space in various ways (implementation dependent). Syscalls are synchronous." ], "previous_source": "Common UNIX(R) API defines a syscall as a way to issue commands from a user space process to the kernel. The most common implementation is either by using an interrupt or specialized instruction (think of `SYSENTER`/`SYSCALL` instructions for ia32). Syscalls are defined by a number. For example in FreeBSD, the syscall number 85 is the man:swapon[2] syscall and the syscall number 132 is man:mkfifo[2]. Some syscalls need parameters, which are passed from the user-space to the kernel-space in various ways (implementation dependant). Syscalls are synchronous.", "target": [ "La API común de UNIX(R) define una syscall como una forma de emitir órdenes desde un proceso del espacio de usuario al kernel. La implementación más común es mediante el uso de una interrupción o una instrucción especializada (piense en las instrucciones `SYSENTER`/`SYSCALL` para ia32). Las syscalls se definen mediante un número. Por ejemplo en FreeBSD, la llamada al sistema número 85 es la llamada al sistema man:swapon[2] y la llamada al sistema número 132 es man:mkfifo[2]. Algunas syscalls necesitan parámetros, que se pasan del espacio de usuario al espacio del núcleo de varias maneras (dependiendo de la implementación). Las syscalls son síncronas." ], "id_hash": -8415593137560220904, "content_hash": -8415593137560220904, "location": "documentation/content/en/articles/linux-emulation/_index.adoc:114", "context": "", "note": "type: Plain text", "flags": "", "labels": [], "state": 20, "fuzzy": false, "translated": true, "approved": false, "position": 18, "has_suggestion": false, "has_comment": false, "has_failing_check": false, "num_words": 85, "source_unit": "https://translate-dev.freebsd.org/api/units/1614915/?format=api", "priority": 100, "id": 1614917, "web_url": "https://translate-dev.freebsd.org/translate/documentation/articleslinux-emulation_index/es/?checksum=0b35cea10d820b18", "url": "https://translate-dev.freebsd.org/api/units/1614917/?format=api", "explanation": "", "extra_flags": "", "pending": false, "timestamp": "2024-01-18T00:08:07.970104Z" } ] }