es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

  • es.davy.ai/
  • Programación /
  • Implementación de la Caché del Sistema Operativo: Error de segmentación al utilizar malloc.

Implementación de la Caché del Sistema Operativo: Error de segmentación al utilizar malloc.

15 Jul, 2023 Programación

Estoy escribiendo un código que maneja las solicitudes de caché realizadas por el sistema operativo y cuando intento asignar memoria para mi caché, obtengo un error de segmentación y no sé por qué. Cualquier ayuda con esto será muy apreciada.

struct item {
    char *key;
    struct file_data *value;
    int ref_count;
    int size;
    struct item *next;
};

struct wc {
    int capacity;
    struct item **table;
};

struct cache {
    struct wc *cache_table;
    struct queue *cache_queue;
    int size;
};

struct server {
    int nr_threads;
    int max_requests;
    int max_cache_size;
    int exiting;
    /* agregar cualquier otro parámetro que necesite */
    pthread_t *thread_array;
    int *buffer;
    int buffer_in;
    int buffer_out;
    struct cache *cache;
};


/* creación e inicialización de una tabla hash */
struct cache *cache_init(void)
{
    struct cache *initialized_cache = (struct cache *)malloc(sizeof(struct cache));

    /* segfault en la siguiente línea */
    if ((initialized_cache->cache_table->table = malloc(MAX_CACHE_TABLE_SIZE * sizeof(struct item**))) == NULL) {
        return NULL;
    }
}
Tags:  , ,

Answer

  1. Avatar for davy.ai
    davy.ai

    Basándonos en el código proporcionado, el problema podría ser que se está asignando memoria a la estructura initialized_cache, pero no a su miembro cache_table.

    La línea que está causando el error de segmentación intenta acceder al miembro table dentro de la estructura cache_table, pero cache_table no ha sido asignada memoria en sí misma, por lo que está apuntando a una ubicación de memoria desconocida.

    Para solucionar este problema, asegúrate de asignar memoria a cache_table antes de acceder a sus miembros. Puede hacerse de la siguiente manera:

    struct cache *cache_init(void)
{
    struct cache *initialized_cache = (struct cache *)malloc(sizeof(struct cache)); 

    if(initialized_cache == NULL) {
        return NULL;
    }

    initialized_cache->cache_table = (struct item **)malloc(MAX_CACHE_TABLE_SIZE * sizeof(struct item**));
    if(initialized_cache->cache_table == NULL){
        free(initialized_cache);
        return NULL; 
    }

    return initialized_cache;
}

    En este código actualizado, el miembro initialized_cache->cache_table se asigna memoria por separado después de que se haya asignado memoria a la estructura initialized_cache. Esto permitirá que el miembro table se acceda correctamente sin causar un error de segmentación.

Comments are closed.