/* * 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); }