1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177
|
/*
* Copyright (c) 2008, Intel Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU Lesser General Public License,
* version 2.1, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
* for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
*
*/
#ifndef _UTILS_H_
#define _UTILS_H_
#define _GNU_SOURCE
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/param.h>
#include <sys/types.h>
#include <ctype.h>
#include <stdlib.h>
#include <stddef.h>
#include <stdio.h>
#include <stdarg.h>
#include <errno.h>
#include <unistd.h>
#include <dirent.h>
#include <string.h>
#include <time.h>
#include <fcntl.h>
#include <malloc.h>
#include <pthread.h>
#include <limits.h>
#include <scsi/sg.h>
#include <hbaapi.h>
#include <vendorhbaapi.h>
#include "fc_types.h"
/*
* Structure for tables encoding and decoding name-value pairs such as enums.
*/
struct sa_nameval {
char *nv_name;
u_int32_t nv_val;
};
/*
* Structure for integer-indexed tables that can grow.
*/
struct sa_table {
u_int32_t st_size; /* number of entries in table */
u_int32_t st_limit; /* end of valid entries in table (public) */
void **st_table; /* re-allocatable array of pointers */
};
/*
* Function prototypes
*/
extern int sa_sys_read_line(const char *, const char *, char *, size_t);
extern int sa_sys_write_line(const char *, const char *, const char *);
extern int sa_sys_read_u32(const char *, const char *, u_int32_t *);
extern int sa_sys_read_u64(const char *, const char *, u_int64_t *);
extern int sa_dir_read(char *, int (*)(struct dirent *, void *), void *);
extern char *sa_strncpy_safe(char *dest, size_t len,
const char *src, size_t src_len);
extern const char *sa_enum_decode(char *, size_t,
const struct sa_nameval *, u_int32_t);
extern int sa_enum_encode(const struct sa_nameval *tp,
const char *, u_int32_t *);
extern const char *sa_flags_decode(char *, size_t,
const struct sa_nameval *, u_int32_t);
extern int sa_table_grow(struct sa_table *, u_int32_t index);
extern void sa_table_destroy_all(struct sa_table *);
extern void sa_table_destroy(struct sa_table *);
extern void sa_table_iterate(struct sa_table *tp,
void (*handler)(void *ep, void *arg), void *arg);
extern void *sa_table_search(struct sa_table *tp,
void *(*match)(void *ep, void *arg), void *arg);
/** sa_table_init(tp) - initialize a table.
* @param tp table pointer.
*
* This just clears a table structure that was allocated by the caller.
*/
static inline void sa_table_init(struct sa_table *tp)
{
memset(tp, 0, sizeof(*tp));
}
/** sa_table_lookup(tp, index) - lookup an entry in the table.
* @param tp table pointer.
* @param index the index in the table to access
* @returns the entry, or NULL if the index wasn't valid.
*/
static inline void *sa_table_lookup(const struct sa_table *tp, u_int32_t index)
{
void *ep = NULL;
if (index < tp->st_limit)
ep = tp->st_table[index];
return ep;
}
/** sa_table_lookup_n(tp, n) - find Nth non-empty entry in a table.
* @param tp table pointer.
* @param n is the entry number, the first non-empty entry is 0.
* @returns the entry, or NULL if the end of the table reached first.
*/
static inline void *sa_table_lookup_n(const struct sa_table *tp, u_int32_t n)
{
void *ep = NULL;
u_int32_t i;
for (i = 0; i < tp->st_limit; i++) {
ep = tp->st_table[i];
if (ep != NULL && n-- == 0)
return ep;
}
return NULL;
}
/** sa_table_insert(tp, index, ep) - Replace or insert an entry in the table.
* @param tp table pointer.
* @param index the index for the new entry.
* @param ep entry pointer.
* @returns index on success, or -1 if the insert failed.
*
* Note: if the table has never been used, and is still all zero, this works.
*
* Note: perhaps not safe for multithreading. Caller can lock the table
* externally, but reallocation can take a while, during which time the
* caller may not wish to hold the lock.
*/
static inline int sa_table_insert(struct sa_table *tp,
u_int32_t index, void *ep)
{
if (index >= tp->st_limit && sa_table_grow(tp, index) < 0)
return -1;
tp->st_table[index] = ep;
return index;
}
/** sa_table_append(tp, ep) - add entry to table and return index.
*
* @param tp pointer to sa_table structure.
* @param ep pointer to new entry, to be added at the end of the table.
* @returns new index, or -1 if table couldn't be grown.
*
* See notes on sa_table_insert().
*/
static inline int
sa_table_append(struct sa_table *tp, void *ep)
{
return sa_table_insert(tp, tp->st_limit, ep);
}
/** sa_table_sort(tp, compare) - sort table in place
*
* @param tp pointer to sa_table structure.
* @param compare function to compare two entries. It is called with pointers
* to the pointers to the entries to be compared. See qsort(3).
*/
static inline void
sa_table_sort(struct sa_table *tp, int (*compare)(const void **, const void **))
{
qsort(tp->st_table, tp->st_limit, sizeof(void *),
(int (*)(const void *, const void *)) compare);
}
#endif /* _UTILS_H_ */
|