Mensajes

El problema de los break es que en ocasiones hacen mucho más compleja la lectura del código, y el código tiene que ser escrito para que sea óptimo, pero también para que sea leído

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

Si los números que utilizas pueden repetirse y tienen alta tendencia a hacerlo, puedes crear una tabla hash que vaya guardando los resultados para cada número, la primera vez que lo ejecutes siempre hará el cálculo, pero a partir de ahí el acceso tiene coste constante.

Pero no todo depende de las salidas profesionales que pretendas darle al asunto, también tiene que gustarte obviamente y algo también a pensar si vives en España en los tiempos que corren.

Yo hice un grado superior, no pretendía seguir estudiando, pero me apasionó el mundo de la programación y me metí en el grado de ingeniería informática (Y ya ando por 3º), pero tienes que tener mucha cabeza, porque es más conveniente hacer bachillerato, grado superior y carrera que no hacer bachillerato. Créeme que en primero de carrera lo agradecerás.

Muchísimas gracias, era justo lo que andaba buscando. Ahora sólo me queda aclararme las ideas con las declaraciones estáticas que no me dejan compilar y punto.

En este caso una alternativa a strcmp es sscanf (prototipo en <stdio.h>) para verificar si coincide la primera palabra y al mismo tiempo extraer el numero entero. Esa función opera de forma similar a scanf pero en lugar de obtener los caracteres de la entrada estándar utiliza la cadena indicada como su primer argumento.

Por ejemplo:

Código (c) [Seleccionar] Expandir

char linea[ALGUN_VALOR];
int numero;

/* ... */

if (sscanf(linea, "add %d", &numero) == 1){
   /* comando add */
}else if (sscanf(linea, "mul %d", &numero) == 1){
   /* comando mul */
}

Un saludo

Gracias a todos. De momento me lo intento apañar con este script, sólo tengo el problema de que atoi no está en kernel, y no sé cómo parsear un entero a dígito en kernel.

Código [Seleccionar] Expandir


int reconocedor(char* str, int* dig){
if(strncmp(str, "add ", 4)==1){
*dig = atoi(str[4]);
return 1;
}else if(strncmp(str,"remove ", 7)==1){
*dig = atoi(str[7]);
return 2;
}else if(strcmp(str,"cat") == 1) {
*dig = -1;
return 3;
}
if(strcmp(str, "sort") == 1) {
*dig = -1;
return 4;
}
*dig = -1;
return -1;
}


Es cierto, lo que yo quería era encontrar algo de ese tipo (He puesto strcmp por poner algo) que pueda comparar que el formato de la cadena se ajuste a eso "add+número" y me devuelva el número.

Un profesor me comentó que existía una macro del tipo

char* str = "add 134";

int aux;
strcmp(str, "add %d",aux)

Que devuelve un número igual a 1 si las cadenas son iguales, y guarda en aux el dígito %d, pero por mucho que busco no logro encontrarlo

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.