subsistema - linea de comandos ubuntu

Cómo escribir llamadas al sistema en debian/ubuntu

Question

Estoy tratando de escribir una llamada al sistema por mi cuenta. Simplemente devolvería la hora actual. Conozco el concepto de lo que debería hacer y atravesé un par de enlaces como estos:

• Implementación de una llamada al sistema en Linux 2.6 para i386

• Otra de las implementaciones de llamadas al sistema

Pero todavía estoy confundido y no he obtenido el resultado deseado. El núcleo no se está compilando y se está bloqueando debido a problemas. Lo he probado en Debian, la última versión estable de 3.XX

¿Podría alguien indicarme un tipo de programa limpio para desarrollar llamadas al sistema?

EDITAR

A la respuesta a continuación , aquí están mis problemas:

1. File 3: linux-xxx/arch/x86/kernel/syscall_table_32.S no se encuentra en mi carpeta de Linux. Tuve que improvisar y modifiqué el siguiente archivo: linux-xxx/arch/x86/syscalls/syscall_64.tbl

2. El anterior (1) nuevo archivo mencionado tenía un patrón diferente de <number> <64/x32/common> <name> <entry point> y mi entrada era `313 common

3. La imagen del núcleo se compiló con éxito, pero no pude llamar a la función. Da un undefined reference" error cuando lo compilo con gcc. ¿Por qué?

Answer 1

Esto es solo un ejemplo de cómo escribir una simple llamada al sistema kernel. Considere la siguiente función C system_strcpy () que simplemente copia una cadena en otra: similar a lo que strcpy () hace.

#include<stdio.h>
long system_strcpy(char* dest, const char* src)
{
int i=0;
while(src[i]!=0)
dest[i]=src[i++];
dest[i]=0;
return i;
}

Antes de escribir, obtenga un tar de fuente kernel y descomprímalo para obtener un directorio linux-xxx.

Archivo 1: linux-xxx / test / system_strcpy.c Cree un directorio dentro de linux-xxx, test nombrada y guarde este código como el archivo system_strcpy.c en él.

#include<linux/linkage.h>
#include<linux/kernel.h>
asmlinkage long system_strcpy(char*dest, const char* src)
{
int i=0;
while(src[i]!=0)
dest[i]=src[i++];
dest[i]=0;
return i;
}

Archivo 2: linux-xxx / test / Makefile Crea un Makefile dentro del mismo directorio de test que creaste arriba y pon esta línea en él:

obj-y := system_strcpy.o

Archivo 3: linux-xxx / arch / x86 / kernel / syscall_table_32.S Ahora, debe agregar su llamada al sistema a la tabla de llamadas del sistema. Adjunte al archivo la siguiente línea:

.long system_strcpy

NOTA: Para Kernel 3.3 y versiones superiores.

* Consulte: linux-3.3.xx / arch / x86 / syscalls / syscall_64.tbl *

Y allí, ahora agregue al final de la siguiente serie de líneas:

310 64 process_vm_readv sys_process_vm_readv

311 64 process_vm_writev sys_process_vm_writev

312 64 kcmp sys_kcmp

313 64 system_strcpy system_strcpy

El formato para la versión 3.3 está en: number abi name entry point

Archivo 4: linux-xxx / arch / x86 / include / asm / unistd_32.h

NOTA: Esta sección es redundante para 3.3 y versiones de kernel más altas

En este archivo, los nombres de todas las llamadas al sistema se asociarán con un número único. Después del último par de número de llamada del sistema, agregue una línea

#define __NR_system_strcpy 338

(si 337 fue el número asociado con la última llamada al sistema en el par de número de llamada del sistema).

Luego reemplace NR_syscalls value, indicando el número total de llamadas al sistema con (el número existente incrementado en 1), es decir, en este caso NR_syscalls debería haber sido 338 y el nuevo valor es 339.

#define NR_syscalls 339

Archivo 5: linux-xxx / include / linux / syscalls.h

Adjunte al archivo el prototipo de nuestra función.

asmlinkage long system_strcpy(char *dest,char *src);

justo antes de la línea #endif en el archivo.

Archivo 6: Makefile en la raíz del directorio de origen.

Abra Makefile y busque la línea donde se define core-y agregue la test directorio al final de esa línea.

core-y += kernel/ mm/ fs/ test/

Ahora compila el kernel. Problema: make bzImage -j4

Instale el kernel ejecutando el siguiente comando como root (o con permisos de root): make install

Reinicia el sistema.

Para usar el uso de llamadas al sistema recientemente creado, use:

syscall(338,dest,src); (o syscall(313,dest,src); para kernel 3.3+) en lugar de la función regular de biblioteca strcpy .

#include "unistd.h"
#include "sys/syscall.h"
int main()
{
char *dest=NULL,*src="Hello";
dest=(char*)malloc(strlen(src)+1);
syscall(338,dest,src);//syscall(313,dest,src); for kernel 3.3+
printf("%s /n %s/n",src,dest);
return 0;
}

En lugar de números como 313, etc. en syscall , también puede usar directamente __NR_system_strcpy

Este es un ejemplo genérico. Tendrá que hacer un poco de experimentación para ver qué funciona para su versión de kernel específica.

Answer 2

La respuesta anterior no funciona para kernel 3.5.0 y 3.7.6, produciendo un error de compilación de referencia indefinido. Para solucionar el problema, linux / syscalls.h debe incluirse en system_strcpy.c en lugar de linux / linkage.h. Además, es mejor usar SYSCALL_DEFINE2 (strcpy, dest, src) para definir una llamada al sistema.