ndmpd/tlm/tlm_info.c

/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * BSD 3 Clause License
 *
 * Copyright (c) 2007, The Storage Networking Industry Association.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  - Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 *  - Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 *  - Neither the name of The Storage Networking Industry Association (SNIA)
 *    nor the names of its contributors may be used to endorse or promote
 *    products derived from this software without specific prior written
 *    permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
#include <stdlib.h>
#include "tlm.h"
#include "tlm_proto.h"
#include <sys/errno.h>


extern  tlm_chain_link_t *tlm_un_ref(tlm_chain_link_t *old_top,
    tlm_chain_link_t *link);

static  tlm_info_t tlm_info;

/*
 * Mutex for concurrent access to job_stats
 */
mutex_t jstat_mtx;


/*
 * get the number of libraries
 */
int
tlm_library_count(void)
{
    int lib;
    tlm_library_t   *library;

    for (lib = 1; lib <= tlm_info.ti_library_count; lib++) {
        library = tlm_library(lib);
        if (library != NULL &&
            library->tl_drive_count == 0) {
            return (0);
        }
    }
    return (tlm_info.ti_library_count);
}

/*
 * get the library whose number matches
 */
tlm_library_t *
tlm_library(int lib)
{
    tlm_library_t   *library = tlm_info.ti_library;
    while (library != NULL) {
        if (library->tl_number == lib) {
            return (library);
        }
        library = library->tl_next;
    }
    errno = TLM_ERROR_RANGE;
    return (NULL);
}

/*
 * get the info about this drive
 */
tlm_drive_t *
tlm_drive(int lib, int drv)
{
    tlm_drive_t *drive;
    tlm_library_t   *library = tlm_library(lib);

    if (library == NULL) {
        return (NULL);
    }
    drive = library->tl_drive;
    while (drive != NULL) {
        if (drv == drive->td_number) {
            return (drive);
        }
        drive = drive->td_next;
    }
    return (NULL);
}

/*
 * get the info about this slot
 */
tlm_slot_t *
tlm_slot(int lib, int slt)
{
    tlm_slot_t  *slot = NULL;
    tlm_library_t   *library = tlm_library(lib);

    if (library != NULL)
        slot = library->tl_slot;
    while (slot != NULL) {
        if (slt == slot->ts_number) {
            return (slot);
        }
        slot = slot->ts_next;
    }
    return (NULL);
}

/*
 * add a link to the INFO chain
 */
tlm_job_stats_t *
tlm_new_job_stats(char *name)
{
    tlm_chain_link_t *new_link;
    tlm_job_stats_t *job_stats;

    new_link = ndmp_malloc(sizeof (tlm_chain_link_t));
    if (new_link == 0)
        return (0);

    job_stats = ndmp_malloc(sizeof (tlm_job_stats_t));
    if (job_stats == 0) {
        free(new_link);
        return (0);
    }

    new_link->tc_ref_count = 1;
    new_link->tc_data = (void *)job_stats;
    (void) strlcpy(job_stats->js_job_name, name, TLM_MAX_BACKUP_JOB_NAME);

    (void) mutex_lock(&jstat_mtx);
    if (tlm_info.ti_job_stats == 0) {
        new_link->tc_next = new_link;
        new_link->tc_prev = new_link;
    } else {
        tlm_chain_link_t *next_link = tlm_info.ti_job_stats;
        tlm_chain_link_t *prev_link = next_link->tc_prev;

        new_link->tc_next = next_link;
        new_link->tc_prev = prev_link;
        prev_link->tc_next = new_link;
        next_link->tc_prev = new_link;
    }
    tlm_info.ti_job_stats = new_link;
    (void) mutex_unlock(&jstat_mtx);

    return (job_stats);
}

/*
 * make sure this Job Stats buffer is not deleted while we use it
 */
tlm_job_stats_t *
tlm_ref_job_stats(char *name)
{
    static  tlm_job_stats_t fake_job_stats;
    tlm_chain_link_t    *link;

    (void) mutex_lock(&jstat_mtx);
    link = tlm_info.ti_job_stats;
    if (link == 0) {
        /*
         * our tables are empty
         */
        (void) mutex_unlock(&jstat_mtx);
        return (&fake_job_stats);
    }

    do {
        tlm_job_stats_t *job_stats;
        job_stats = (tlm_job_stats_t *)link->tc_data;

        if (strcmp(job_stats->js_job_name, name) == 0) {
            link->tc_ref_count++;
            (void) mutex_unlock(&jstat_mtx);
            return (job_stats);
        }
        link = link->tc_next;
    } while (link != tlm_info.ti_job_stats);
    NDMP_LOG(LOG_DEBUG,
        "TAPE BACKUP> Ref for job [%s] was not found", name);
    (void) mutex_unlock(&jstat_mtx);

    return (&fake_job_stats);
}

/*
 * remove a link to the INFO chain
 */
void
tlm_un_ref_job_stats(char *name)
{
    tlm_chain_link_t *link;

    (void) mutex_lock(&jstat_mtx);
    link = tlm_info.ti_job_stats;
    if (link == 0) {
        NDMP_LOG(LOG_DEBUG, "TAPE BACKUP>"
            " Internal error for job [%s], could not delete", name);
        return;
    }
    do {
        tlm_job_stats_t *job_stats;
        job_stats = (tlm_job_stats_t *)link->tc_data;

        if (strcmp(job_stats->js_job_name, name) == 0) {
            tlm_info.ti_job_stats =
                tlm_un_ref(tlm_info.ti_job_stats, link);
            (void) mutex_unlock(&jstat_mtx);
            return;
        }
        link = link->tc_next;
    } while (link != tlm_info.ti_job_stats);
    (void) mutex_unlock(&jstat_mtx);
    NDMP_LOG(LOG_DEBUG,
        "TAPE BACKUP> Delete for job [%s] was not found", name);
}

/*
 * one party does not care about this blob, can we let it go?
 */
tlm_chain_link_t *
tlm_un_ref(tlm_chain_link_t *old_top, tlm_chain_link_t *link)
{
    tlm_chain_link_t *chain_link = old_top;
    tlm_chain_link_t *new_top;

    /*
     * count down the number of
     * interested parties for this blob
     */
    link->tc_ref_count--;
    if (link->tc_ref_count > 0) {
        /*
         * there is still interest in this blob,
         * no change yet
         *
         * returning "old_top" means there is no change in the links
         */
        return (old_top);
    }

    /*
     * no one cares about this data anymore
     * find out how to delete it
     */
    do {
        if (chain_link == link) {
            tlm_chain_link_t *next;
            tlm_chain_link_t *prev;

            /*
             * If there are one or two elements in the list, then
             * the prev and next pointers point to one element in
             * the list, the element itself and the other element
             * correspondingly.  So we must distinguish if there
             * are only one or two elements in the list.  If
             * either of the 'prev' or 'next' pointers point to
             * the link itself, then we have only one element in
             * the list.
             */
            if (link->tc_next == link->tc_prev &&
                link->tc_next == link) {
                /*
                 * there is only this one link in the chain
                 * delete this and the chain is empty
                 */
                new_top = 0;
            } else {
                new_top = link->tc_next;
            }
            next = link->tc_next;
            prev = link->tc_prev;
            prev->tc_next = next;
            next->tc_prev = prev;
            free(link->tc_data);
            free(link);
            return (new_top);
        }
        chain_link = chain_link->tc_next;
    } while (chain_link != old_top);
    NDMP_LOG(LOG_DEBUG, "TAPE BACKUP> un_ref target not found.");
    return (old_top);
}

/*
 * the following section is global, but not really part of the
 * public interface.  Use of this outside of the tlm_*.c files
 * is for special cases only.
 */

/*
 * add a new tape library data blob to the list of libraries
 * returns the new tape library data blob just created
 */
int
tlm_insert_new_library(scsi_link_t *slink)
{
    tlm_library_t **p_library = &tlm_info.ti_library;
    tlm_library_t *library = ndmp_malloc(sizeof (tlm_library_t));

    while (*p_library != NULL) {
        p_library = &(*p_library)->tl_next;
    }
    tlm_info.ti_library_count++;
    library->tl_number = tlm_info.ti_library_count;
    library->tl_slink = slink;
    library->tl_capability_robot = TRUE;
    *p_library = library;
    return (library->tl_number);
}

/*
 * add a new tape drive data blob to the list of drives in a library
 * returns the new tape drive data blob just created
 */
int
tlm_insert_new_drive(int lib)
{
    tlm_library_t *library = tlm_library(lib);
    tlm_drive_t *drive = ndmp_malloc(sizeof (tlm_drive_t));
    tlm_drive_t **p_drive = &library->tl_drive;

    while (*p_drive != NULL) {
        p_drive = &(*p_drive)->td_next;
    }
    library->tl_drive_count++;
    library->tl_capability_drives = TRUE;

    drive->td_library = library;
    drive->td_number = library->tl_drive_count;
    *p_drive = drive;
    return (drive->td_number);
}

/*
 * add a new tape slot data blob to the list of slots in a library
 * returns the new tape slot data blob just created
 */
int
tlm_insert_new_slot(int lib)
{
    tlm_library_t *library = tlm_library(lib);
    tlm_slot_t *slot = ndmp_malloc(sizeof (tlm_slot_t));
    tlm_slot_t **p_slot = &library->tl_slot;

    while (*p_slot != NULL) {
        p_slot = &(*p_slot)->ts_next;
    }
    library->tl_slot_count++;
    library->tl_capability_slots = TRUE;

    slot->ts_library = library;
    slot->ts_number = library->tl_slot_count;
    *p_slot = slot;
    return (slot->ts_number);
}