Temas

Buenas, estoy programando un módulo propio para el kernel de linux (Estoy trabajando sobre debian 6 con kernel 2.6.39.4) que interactúa con una llamada al sistema. Son dos muy sencillos. La llamada funciona perfectamente y exporta funcionalidad que permite a un módulo insertarse en una lista de entradas y registrar en ella dos funciones, una de escritura y otra de lectura.

El módulo es un contador, y las funciones de lectura y escritura son la suma del contador y la consulta del número actual. Su escritura sólo suma si todo va bien, y su lectura devuelve en el buffer del usuario la copia del valor. El problema es que al hacer el makefile del módulo recibo el error:

"insmod: error inserting 'ModuloUsaKifs.ko': -1 Unknown symbol in module"

Y no sé exáctamente por qué no reconoce Kifs, que según creo, está integrado en el sistema correctamente (Incluidas las fuentes, modificado el planificador, añadido a la tabla de llamadas, incluida la cabecera, compilado el kernel, instalado el nuevo, y probado con un programa aparte, aunque sólo pruebo sys_kifs, mi llamada al sistema, exporto también create_kifs_entry y remove_kifs_entry mediante <linux/kifs.h>)
Este es mi makefile, es muy estándar y no contemplo nada especial, porque se supone que kifs ya está en las fuentes de linux y así lo incluyo en el módulo.
¿Podría alguien orientarme hacia dónde está mi fallo?

obj-m = ModuloUsaKifs.o

all :
   make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules

clean :
   make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

Este es el módulo. Siento la falta de comentarios, todavía no lo he acabado y está un poco guarro(Esto es como tener visita con la casa sucia) Tengo algunos includes de más porque aún no los he borrado, he reutilizado algo de código de aquí y allá.

Código (c) [Seleccionar] Expandir


#ifdef __KERNEL__
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/proc_fs.h>
#include <linux/string.h>
#include <linux/vmalloc.h>
#include <linux/kifs.h>
#include <asm-generic/uaccess.h>
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("List Kernel Module para DSO");
MODULE_LICENSE("GPL");
#else
//#include <iostream>
//#include <linux/list.h>
#include <string.h>
#include "list.h"
#include <stdio.h>
#include <stdlib.h>
#include "kifs.h"
#endif
int counter;
//typedef int (read_kifs_t)(char *user_buffer, unsigned int maxchars, void *data);
//typedef int (write_kifs_t)(const char *user_buffer, unsigned int maxchars, void *data);
//initialices the module
int sum(char *user_buffer, unsigned int maxchars, void *data){
counter++;
return maxchars;
}
int lect(const char *user_buffer, unsigned int maxchars, void *data){
char buf[32];
int len=sprintf(buf,"%d\n",counter);
if (len> maxchars)
{
return -EINVAL;
}
if(copy_to_user(buf, user_buffer, len)){
printk(KERN_ALERT) "problemas en lect";
return -EINVAL;
}
return len;

}

int metodoInicial(void){

counter = 0;
if(create_kifs_entry("counter",sum,lect,NULL))
{
counter = 0;
printk(KERNEL_ALERT "modulo abierto correctamente");
}
printk(KERNEL_ALERT "Error, módulo counter incorrectamente agregado a kifs");
}

void metodoFinal(void){

if(remove_kifs_entry("counter")){
printk(KERNEL_ALERT "modulo cerrado correctamente");
}
printk(KERNEL_ALERT "Error, módulo counter incorrectamente borrado de kifs");
}

module_init(metodoInicial);
module_exit(metodoFinal);



Esta es la llamada al sistema, por si pudiese ser algo relacionado con esto, sinceramente ya no sé qué puede ser porque me estoy volviendo loco.

Código (c) [Seleccionar] Expandir


#include <linux/kifs.h>
#include <linux/string.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <asm-generic/errno-base.h>
#include <asm-generic/errno.h>
#include <asm-generic/uaccess.h>
/*
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Modulo KIFS para DSO");
MODULE_AUTHOR("Ismel Gonjal Montero");
*/
/* Callback prototypes for kifs entries */

/*
typedef int (read_kifs_t)(char *user_buffer, unsigned int maxchars, void *data);
typedef int (write_kifs_t)(const char *user_buffer, unsigned int maxchars, void *data);
*/

/*     Valores de lectura y escritura */

/*
enum {
KIFS_READ_OP=0,
KIFS_WRITE_OP,
KIFS_NR_OPS};
*/
/***********************************/
/*      Declaraciones de kifs      */
/***********************************/
#define MAX_KIFS_ENTRIES 10
LIST_HEAD(entry_list);
LIST_HEAD(free_list);
kifs_entry_t pool[MAX_KIFS_ENTRIES];

/***********************************/
/*   Declaraciones de clipboard    */
/***********************************/
#define MAX_KIFS_CHARS 512
char clipboard[MAX_KIFS_CHARS];
/************************************/
/*    Declaracion de funciones    */
/************************************/
int read_list (char *user_buffer, unsigned int maxchars, void *data);


/******************************************************************************/
/*                           CLIPBOARD                                        */
/******************************************************************************/


int read_clipboard (char *user_buffer, unsigned int maxchars, void *data){
int total = strlen(clipboard);

if (total>maxchars)
{
return  -EINVAL;
}

if (copy_to_user(user_buffer, clipboard, total))
{
printk(KERN_ALERT "Fallo en copy_to_user()");
return  -EINVAL;
}
return total;
}

int write_clipboard (const char *user_buffer, unsigned int maxchars, void *data){

if (maxchars>MAX_KIFS_CHARS-1)
{
printk(KERN_ALERT "Excede tamanio");
return  -EINVAL;
}

if (copy_from_user(clipboard, user_buffer, maxchars))
{
printk(KERN_ALERT "Fallo en copy_from_user()");
return  -EINVAL;
}
clipboard[maxchars]='\0';

return  maxchars;
}



/****************************************************/
/*     Código de KIFS    */
/****************************************************/


/* KIFS's global initialization */
void init_kifs_entry_set(void){
int i = 0;
//añade a la lista todas las entradas de freelist
for(i =0; i<MAX_KIFS_ENTRIES;i++){
list_add_tail(&pool[i].links,&free_list);
}
clipboard[0]='\0';
create_kifs_entry("list", read_list,NULL,NULL);
create_kifs_entry("clipboard", read_clipboard,write_clipboard ,NULL);
printk(KERN_ALERT "Inicializado kifs");
}

/*
* Recibe un buffer de usuario, que llenará con una lista de las entradas
* de la lista entry_list
*/
int read_list (char *user_buffer, unsigned int maxchars, void *data){
int total = 0;
char buf[512];
struct list_head* pos = entry_list.next;
kifs_entry_t* item;

printk(KERN_ALERT "Entra en read_list");

list_for_each(pos, &entry_list){
item = list_entry(pos, kifs_entry_t, links);
total+= sprintf(&buf[total],"%s\n",item->entryname);
}

if (copy_to_user(user_buffer,buf,total))
{
printk(KERN_ALERT "Fallo en copy_to_user()");
return -EINVAL;
}

printk(KERN_ALERT "Sale de read_list por las buenas");
return total;
}

/* This fuction must ensure that no entry will be created as long as another entry with the same name already exists.
* == Return Value ==
* NULL Entry name already exists or No space is availables
* Pointer to the kifs entry
* */
kifs_entry_t* create_kifs_entry(const char* entryname,
read_kifs_t *read_kifs,
write_kifs_t *write_kifs,
void* data){
kifs_entry_t* item;
struct list_head* pos = entry_list.next;
kifs_entry_t* itemFound = NULL;

printk(KERN_ALERT "Creando entrada %s en Kifs",entryname);

//Si la lista no está vacía
list_for_each(pos, &entry_list){
item = list_entry(pos, kifs_entry_t, links);
if (strcmp(item->entryname,entryname) ==0){
itemFound = item;
break;
}
}
if (itemFound != NULL) {
printk(KERN_ALERT "El item existe");
return NULL;
}

//No hay espacio
if(free_list.next == &free_list) {
printk(KERN_ALERT "Error, lista llena");
return NULL;
}
pos = free_list.next;
item = list_entry(pos, kifs_entry_t, links);
item->read_kifs = read_kifs;
item->write_kifs = write_kifs;
item->data = NULL;
strcpy(item->entryname, entryname);

list_del(pos);
list_add_tail(pos,&entry_list);
printk(KERN_ALERT "Entrada %s creada correctamente", entryname);
return item;
}


/*  Implementation of kifs() system call
* == Return Value ==
* -EINVAL Unsupported operation (NULL callback) or Entry not exists
* -EFAULT Any other error (e.g: copy_from_user(), copy_to_user(),...)
* otherwise: Number of chars read/written (Usually maxchars value)
*/

asmlinkage long sys_kifs(const char* entry_name,unsigned int op_mode, char* user_buffer,unsigned int maxchars){

struct list_head* pos;// = entry_list.next;
kifs_entry_t* item;// = list_entry(pos, kifs_entry_t, links);
kifs_entry_t* itemFound = NULL;
int ret = 0;
//char usrBfr[512];

printk(KERN_ALERT "Entrado a sys_kifs");
/* Se comprueba que la llamada has sido correcta */
list_for_each(pos, &entry_list){
item = list_entry(pos, kifs_entry_t, links);
if (strcmp(item->entryname,entry_name) ==0){
itemFound = item;
break;
}
}

if (itemFound == NULL){
printk(KERN_ALERT "La entrada %s no existe", entry_name);
return -EINVAL;
}

/* copy_from_user(usrBfr, user_buffer, maxchars);
usrBfr[maxchars]='\0';

printk(KERN_ALERT "Se ha copiado el parametro %s de la entrada %s",usrBfr, entry_name);

printk(KERN_ALERT "Hay items en la lista");
*/
/* llamadas que dependen del valor de lectura/escritura */
if(op_mode == KIFS_READ_OP &&  item->read_kifs!=NULL ){
ret = itemFound->read_kifs(user_buffer,maxchars,NULL);
//printk(KERN_ALERT "El item utilizado es %s, en el método de lectura",user_buffer);
}else if(op_mode == KIFS_WRITE_OP &&  item->write_kifs!=NULL ){
ret = itemFound->write_kifs(user_buffer,maxchars,NULL); //No sé qué pasar de valor aquí
//printk(KERN_ALERT "El item utilizado es %s, en el método de escritura",usrBfr);
}else{
ret=-EINVAL;
printk(KERN_ALERT "Algo va mal");
}
return ret;
}

/* Remove kifs entry
* == Return Value ==
* -1 Entry does not exist
*  0 success
* */
int remove_kifs_entry(const char* entry_name){

struct list_head* pos = entry_list.next;
kifs_entry_t* item = list_entry(pos, kifs_entry_t, links);
kifs_entry_t* itemFound = NULL;
printk(KERN_ALERT "Intentando eliminar entrada de Kifs");

list_for_each(pos, &entry_list){
item = list_entry(pos, kifs_entry_t, links);
if (strcmp(item->entryname,entry_name) ==0){
itemFound = item;
break;
}
}
if (itemFound == NULL) {
printk(KERN_ALERT "La lista de kifs está vacía");
return -EINVAL;
}

list_del(pos);
item->data = NULL;
strcpy(item->entryname,"");
item->read_kifs = NULL;
item->write_kifs = NULL;
list_add_tail(pos,&free_list);
printk(KERN_ALERT "Entrada eliminada correctamente");
return 0;
}


Y por si acaso también subo el .h de kifs, mi llamada al sistema.

Código (c) [Seleccionar] Expandir

#ifndef KIFS_H
#define KIFS_H
#include <linux/list.h> /* list_head */

#define MAX_KIFS_ENTRY_NAME_SIZE 50

/* Callback prototypes for kifs entries */
typedef int (read_kifs_t)(char *user_buffer, unsigned int maxchars, void *data);
typedef int (write_kifs_t)(const char *user_buffer, unsigned int maxchars, void *data);


/* Descriptor interface for the entries */
typedef struct
{
char entryname[MAX_KIFS_ENTRY_NAME_SIZE];
read_kifs_t *read_kifs;
write_kifs_t *write_kifs;
void *data;
struct list_head links; /* Set of links in kifs */
}kifs_entry_t;

enum {
KIFS_READ_OP=0,
KIFS_WRITE_OP,
KIFS_NR_OPS};


/* This fuction must ensure that no entry will be created as long as another entry with the same name already exists.
* == Return Value ==
* NULL Entry name already exists or No space is availables
* Pointer to the kifs entry
* */
kifs_entry_t* create_kifs_entry(const char* entryname,
read_kifs_t *read_kifs,
write_kifs_t *write_kifs,
void* data);


/* Remove kifs entry
* == Return Value ==
* -1 Entry does not exist
*  0 success
* */
int remove_kifs_entry(const char* entry_name);

/*  Implementation of kifs() system call
* == Return Value ==
* -EINVAL Unsupported operation (NULL callback) or Entry not exists
* -EFAULT Any other error (e.g: copy_from_user(), copy_to_user(),...)
* otherwise: Number of chars read/written (Usually maxchars value)
*/
asmlinkage long sys_kifs(const char* entry_name,unsigned int op_mode, char* user_buffer,unsigned int maxchars);

/* KIFS's global initialization */
void init_kifs_entry_set(void);


#endif

Muchas gracias por vuestro tiempo



Para ser concretos el mensaje del sistema es:

make -C /lib/modules/2.6.39.4.mikernel/build M=/home/dsouser/Escritorio/FuturaEntrega/ModuloUsaKifs modules
make[1]: se ingresa al directorio `/usr/src/linux-headers-2.6.39.4.mikernel'
 Building modules, stage 2.
 MODPOST 1 modules
WARNING: "create_kifs_entry" [/home/dsouser/Escritorio/FuturaEntrega/ModuloUsaKifs/ModuloUsaKifs.ko] undefined!
WARNING: "remove_kifs_entry" [/home/dsouser/Escritorio/FuturaEntrega/ModuloUsaKifs/ModuloUsaKifs.ko] undefined!
make[1]: se sale del directorio `/usr/src/linux-headers-2.6.39.4.mikernel'

Buenas, estoy trabajando en informática gráfica, concretamente usando OpenGL aunque eso da igual. Tengo un vector bidimensional (i,j) y puntos bidimensionales(x,y). con ellos genero un triángulo de tres puntos (ABC), que también indican cuál es la cara externa (El vector perpendicular hacia fuera de los puntos AB, BC y CA), aparte tengo un punto que avanza por la escena con una velocidad que marca un tercer vector (vec).

Necesito calcular:

a) Si vec interseca con alguna de las aristas del triángulo ABC

b) Si interseca, en qué punto se produce la intersección.

Muchas gracias

Buenas, estoy haciendo un programa que crea un objeto, y cuando se pulsa una tecla, anida dos objetos por cada uno de los objetos creados en el último anidamiento, de modo que en el nivel 1 tendré 1 objeto, en el 2, 3 objetos, en el 3, tendré 7...

de modo que cada iteración tiene (iteraciónAnterior*2) objetos, y tengo un problema, pues a la hora de desanidar habiendo objetos, me salta un error

El error que me da es
Debug Assertion Failed!

Program: [archivoPrograma]\Debug\freeglut project 2D.exe(mi archivo)
File: c:\visual studio 2010\vc\include\list (cuando yo utilizo 2012, aunque tengo instalado el 2010)
line 256

Expression: list iterator not decrementable


[...]

El código es el siguiente

Código [Seleccionar] Expandir


void Arbol::desanidar(void){
int i = -1;
while(!poranidar.empty()){
poranidar.pop_front();
i++;
}
if (i!= -1){
for (int j=0;j<=i/2;i++){
poranidar.push_front(archivados.back());
archivados.pop_back();
}
}
}


Buenas, estoy haciendo un proyecto 2d en FreeGlut con C++ y tengo un problema, cuando hago click en una zona, las coordenadas que coge no son las que debería, son de unos 10 píxeles más abajo, pero la cosa es que cuando redimensiono el área visible de la escena haciendo zoom, se descuadra la selección. Estoy calculándola mediante porcentajes, pero no doy con ello, mi código es este:

Código [Seleccionar] Expandir


void mouse(int button, int state, int x, int y) {
    if (button==GLUT_LEFT_BUTTON && state==GLUT_DOWN) {
// trasladarEscena('N',10);
//repaint();
//Si no había iniciado, se inicia
if (!started){
  pintarInicial(x,y);
  repaint();
//   glutPostRedisplay();

} else{
square_x = xLeft + (x)*(abs(xRight)+abs(xLeft))/WIDTH;
square_y = yBot + (HEIGHT-y)* abs(yTop)+abs(yBot))/HEIGHT;
selection = Punto(square_x,square_y);
selection_enabled = true;
}
}
   
}


Gracias.

Buenas, estoy haciendo un módulo que sea una lista de enteros que se actualice cada vez que se actualiza una entrada en proc en concreto /proc/mimod. El caso es que compila y lo instalo en el kernel, y cuando quiero utilizar un comando, (Sólo acepta dos, add y remove), de la forma

Código [Seleccionar] Expandir

echo add 10 > /proc/mimod

Estalla(NullPointerException). No sé muy bien cómo funciona aún. Aquí asigno los callback

Código [Seleccionar] Expandir


static int addProcEditor(void){
   clipboard = (char *)vmalloc( BUFFER_LENGTH );
   if (!clipboard) {
     ret = -ENOMEM;
   } else {
     memset( clipboard, 0, BUFFER_LENGTH );
     proc_entry = create_proc_entry("mimod",0777, NULL);
     if (proc_entry == NULL) {
       ret = -ENOMEM;
       vfree(clipboard);
       printk(KERN_INFO "modlist: No puedo crear la entrada en proc\n");
     } else {
       posicionactual=0;
      [glow=red,2,300] proc_entry->read_proc = procWritten;
       proc_entry->write_proc = procIsRead;[/glow]
       printk(KERN_INFO "modlist: Cargado el Modulo.\n");
     }
   }
   return 0;
}


Aquí hago las lecturas y escrituras:

Código [Seleccionar] Expandir


//Reconoce el cambio del proc y ejecuta este programa
int procWritten( struct file *punterofichero, const char __user *bufferusuario,
unsigned long longitud, void *data){
 char* str;
 int espaciodisponible = (BUFFER_LENGTH-posicionactual)+1;

 if (longitud > espaciodisponible) {
   printk(KERN_INFO "mimod: el buffer esta lleno!\n");
   return -ENOSPC;
 }
 if (copy_from_user( &str[0], bufferusuario, longitud )) {
   return -EFAULT;
 }
 clipboard[longitud] = 0;
 int num;
 int i = reconocedor(clipboard,&num);
 switch(i){
 case 1://add
 add(num);
 break;
 case 2://remove
 myremove(num);
 break;
 }

 return longitud;

}
//Escribe en proc lo que deseemos
int procIsRead( char *buffer, char **bufferlocation, off_t offset,
                  int buffer_lenghth, int *eof, void *data )

{
 int len;

 if (offset > 0) {
   /* hemos llegado al final */
   *eof = 1;
   len =0;
 } else {
 len = cats(buffer);
 int num;
 }
 return len;
}


Cuando va a utilizar cats (lo único que hace es copiar una lista al buffer, peta) y cuando tiene que añadir también. No sé muy bien qué falla. ¿Alguna idea? Lo que puedo suponer es que la cadena recibida no se pasa bien o algo así, pero no tengo ni idea.

Gracias

Buenas, este es mi primero mensaje y espero que no el último. Llevo tiempo programando en java y me pasé hace muy poco  a c++ y c, por que mi carrera me lo exigía, así que ahora estoy haciendo mi primer módulo para el kernel de un debian 6, Es una práctica para la universidad y se trata de una lista que guarde y borre elementos de proc y en la que, si se modifica un archivo de  /proc  tiene que reconocerlo y ejecutar el código correspondiente, digamos que se debe añadir un número a la lista, pues el usuario escribirá: echo add 10 > /proc/mymodule. Aún soy muy inexperto con C y tengo un error que seguro es de principiante.

¿Cómo puedo estar seguro de que el formato de una cadena es del tipo: "add 144" o "remove 4"?

Gracias.