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_ */
|
