Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
gendwarfksyms: Clean up kABI rule look-ups
Reduce code duplication by moving kABI rule look-ups to separate
functions.
Signed-off-by: Sami Tolvanen <samitolvanen@google.com>
Reviewed-by: Petr Pavlu <petr.pavlu@suse.com>
Signed-off-by: Masahiro Yamada <masahiroy@kernel.org>
authored by
Sami Tolvanen
and committed by
Masahiro Yamada
ff2c5f5a
707f853d
+49
-62
+49
-62
scripts/gendwarfksyms/kabi.c
+49
-62
scripts/gendwarfksyms/kabi.c
···
222
222
check(elf_end(elf));
223
223
}
224
224
225
-
bool kabi_is_declonly(const char *fqn)
226
-
{
227
-
struct rule *rule;
228
-
229
-
if (!stable)
230
-
return false;
231
-
if (!fqn || !*fqn)
232
-
return false;
233
-
234
-
hash_for_each_possible(rules, rule, hash,
235
-
rule_values_hash(KABI_RULE_TYPE_DECLONLY, fqn)) {
236
-
if (rule->type == KABI_RULE_TYPE_DECLONLY &&
237
-
!strcmp(fqn, rule->target))
238
-
return true;
239
-
}
240
-
241
-
return false;
242
-
}
243
-
244
225
static char *get_enumerator_target(const char *fqn, const char *field)
245
226
{
246
227
char *target = NULL;
···
230
249
error("asprintf failed for '%s %s'", fqn, field);
231
250
232
251
return target;
252
+
}
253
+
254
+
static struct rule *find_rule(enum kabi_rule_type type, const char *target)
255
+
{
256
+
struct rule *rule;
257
+
258
+
if (!stable)
259
+
return NULL;
260
+
if (!target || !*target)
261
+
return NULL;
262
+
263
+
hash_for_each_possible(rules, rule, hash,
264
+
rule_values_hash(type, target)) {
265
+
if (rule->type == type && !strcmp(target, rule->target))
266
+
return rule;
267
+
}
268
+
269
+
return NULL;
270
+
}
271
+
272
+
static struct rule *find_enumerator_rule(enum kabi_rule_type type,
273
+
const char *fqn, const char *field)
274
+
{
275
+
struct rule *rule;
276
+
char *target;
277
+
278
+
if (!stable)
279
+
return NULL;
280
+
if (!fqn || !*fqn || !field || !*field)
281
+
return NULL;
282
+
283
+
target = get_enumerator_target(fqn, field);
284
+
rule = find_rule(type, target);
285
+
286
+
free(target);
287
+
return rule;
288
+
}
289
+
290
+
bool kabi_is_declonly(const char *fqn)
291
+
{
292
+
return !!find_rule(KABI_RULE_TYPE_DECLONLY, fqn);
233
293
}
234
294
235
295
static unsigned long get_ulong_value(const char *value)
···
289
267
290
268
bool kabi_is_enumerator_ignored(const char *fqn, const char *field)
291
269
{
292
-
bool match = false;
293
-
struct rule *rule;
294
-
char *target;
295
-
296
-
if (!stable)
297
-
return false;
298
-
if (!fqn || !*fqn || !field || !*field)
299
-
return false;
300
-
301
-
target = get_enumerator_target(fqn, field);
302
-
303
-
hash_for_each_possible(
304
-
rules, rule, hash,
305
-
rule_values_hash(KABI_RULE_TYPE_ENUMERATOR_IGNORE, target)) {
306
-
if (rule->type == KABI_RULE_TYPE_ENUMERATOR_IGNORE &&
307
-
!strcmp(target, rule->target)) {
308
-
match = true;
309
-
break;
310
-
}
311
-
}
312
-
313
-
free(target);
314
-
return match;
270
+
return !!find_enumerator_rule(KABI_RULE_TYPE_ENUMERATOR_IGNORE, fqn,
271
+
field);
315
272
}
316
273
317
274
bool kabi_get_enumerator_value(const char *fqn, const char *field,
318
275
unsigned long *value)
319
276
{
320
-
bool match = false;
321
277
struct rule *rule;
322
-
char *target;
323
278
324
-
if (!stable)
325
-
return false;
326
-
if (!fqn || !*fqn || !field || !*field)
327
-
return false;
328
-
329
-
target = get_enumerator_target(fqn, field);
330
-
331
-
hash_for_each_possible(rules, rule, hash,
332
-
rule_values_hash(KABI_RULE_TYPE_ENUMERATOR_VALUE,
333
-
target)) {
334
-
if (rule->type == KABI_RULE_TYPE_ENUMERATOR_VALUE &&
335
-
!strcmp(target, rule->target)) {
336
-
*value = get_ulong_value(rule->value);
337
-
match = true;
338
-
break;
339
-
}
279
+
rule = find_enumerator_rule(KABI_RULE_TYPE_ENUMERATOR_VALUE, fqn,
280
+
field);
281
+
if (rule) {
282
+
*value = get_ulong_value(rule->value);
283
+
return true;
340
284
}
341
285
342
-
free(target);
343
-
return match;
286
+
return false;
344
287
}
345
288
346
289
void kabi_free(void)