Gracias por tu respuesta dato000

remove_kifs_entry devuelve -EINVAL cuando no se encuentra el dato o la lista está vacía, es un valor de la librería errno.h (Creo), echale un ojo y lo verás

kifs_entry_t* te devuelve un puntero a la propia entrada de kifs que yo he creado (No me gusta mucho, yo devolvería un entero pero las indicaciones me obligan a ello). kifs_entry_t es una estructura, puedes comprobar su forma en el .h que está subido.

ModuloUsaKifs es el .c primero que he subido. Consta de dos métodos, sum y lect:
-sum
Lo único que hace es incrementar un contador que se inicializa en 0 en la carga del módulo
-Escritura
Devuelve en el buffer del usuario el valor del contador en una cadena de caracteres y devuelve el número de caracteres de la cadena


Muchas gracias por tu tiempo

Por si a alguien más le sirve de guía, dmesg | tail me da la siguiente info

---

¿Podría ser algo relacionado con la siguiente línea? ¿Cómo paso la función por parámetro? (*read_kifs o write_kifs)?

kifs_entry_t* create_kifs_entry(const char* entryname,
				read_kifs_t *read_kifs, 
				write_kifs_t *write_kifs, 
				void* data);

Yo la paso así:

create_kifs_entry("counter",sum,lect,NULL)

Y la declaración es la siguiente:

int sum(char *user_buffer, unsigned int maxchars, void *data)

¿Puede alguien con más experiencia que yo orientarme?

---

Gracias por la respuesta. Investigando y preguntando en otros foros, alguien me dio la solución al problema, y es añadir las siguientes dos líneas al final del todo de mi llamada al sistema, "kifs.c":

EXPORT_SYMBOL(create_kifs_entry); 
EXPORT_SYMBOL(remove_kifs_entry);
 

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:


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?



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á.

#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.

#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.

#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:

Sin embargo es un punto avanzando a lo largo de un vector. No se mantiene fijo, sino que avanza de forma contínua hasta toparse con un segmento (O no), lo que quería saber era la intersección. De todos modos he conseguido resolverlo. Muchas gracias.

Acabo de darme cuenta de que con un punto y un vector puedo calcular un segundo punto, entonces el problema quedaría en la intersección de dos segmentos dados los puntos a y b, aunque de todas formas no sé hacerlo, pero al menos he encontrado una nueva perspectiva.

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

También es posible que el problema esté en la redimensión del área visible de la escena. He de decir que el área visible y el puerto de vista son proporcionales.

Tenía un par de problemas con punteros, nada importante, gracias de todas formas. Si a alguien le interesa la resolución la cuelgo.

No, eso no funciona. De momento selecciona bien si no se redimensiona ni mueve, pero selecciona unos píxeles por debajo de donde debería, pero si se cambia eso, ya empieza la locura.

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:


Gracias.