Cleanup: Use bool for attribute flags

Use bool instead of uint8_t for attribute flags.

No (intended) functional change.

Signed-off-by: Petr Tesarik <[email protected]>

Author: ptesarik

src/kdumpfile/attr.c

@@ -389,7 +389,7 @@ discard_attr_value(struct attr_data *attr)
 
 	discard_value(attr_value(attr), attr->template->type,
 		      attr->flags);
-	attr->flags.dynstr = 0;
+	attr->flags.dynstr = false;
 }
 
 /**  Clear (unset) a single attribute.
@@ -407,7 +407,7 @@ clear_single_attr(kdump_ctx_t *ctx, struct attr_data *attr)
 		ops->pre_clear(ctx, attr);
 
 	discard_attr_value(attr);
-	attr->flags.isset = 0;
+	attr->flags.isset = false;
 }
 
 /**  Clear (unset) any attribute and its children recursively.
@@ -429,18 +429,18 @@ clear_attr(kdump_ctx_t *ctx, struct attr_data *attr)
 /**  Clear (unset) a volatile attribute and its children recursively.
  * @param ctx   Dump file object.
  * @param attr  Attribute to be cleared.
- * @returns     Non-zero if the entry could not be cleared.
+ * @returns     @c true if the entry could not be cleared.
  *
  * This function clears only volatile attributes, i.e. those that were
  * set automatically and should not be preserved when re-opening a dump.
  * Persistent attributes (e.g. those that have been set explicitly) are
  * kept. The complete path to each persistent attributes is also kept.
  */
-static unsigned
+static bool
 clear_volatile(kdump_ctx_t *ctx, struct attr_data *attr)
 {
 	struct attr_data *child;
-	unsigned persist;
+	bool persist;
 
 	persist = attr->flags.persist;
 	if (attr->template->type == KDUMP_DIRECTORY)
@@ -615,7 +615,7 @@ create_attr_path(struct attr_dict *dict, struct attr_data *dir,
 static bool
 copy_data(struct attr_data *dest, const struct attr_data *src)
 {
-	dest->flags.isset = 1;
+	dest->flags.isset = true;
 	dest->flags.persist = src->flags.persist;
 
 	switch (src->template->type) {
@@ -769,7 +769,7 @@ static void
 instantiate_path(struct attr_data *attr)
 {
 	while (!attr_isset(attr)) {
-		attr->flags.isset = 1;
+		attr->flags.isset = true;
 		if (!attr->parent)
 			break;
 		attr = attr->parent;
@@ -822,7 +822,7 @@ attr_dict_new(struct kdump_shared *shared)
 		dict->global_attrs[i] = attr;
 
 		if (i >= GKI_static_first && i <= GKI_static_last) {
-			attr->flags.indirect = 1;
+			attr->flags.indirect = true;
 			attr->pval = static_attr_value(shared, i);
 		}
 	}
@@ -944,7 +944,7 @@ set_attr(kdump_ctx_t *ctx, struct attr_data *attr,
 		const struct attr_ops *ops = attr->template->ops;
 		if (ops && ops->pre_set &&
 		    (res = ops->pre_set(ctx, attr, pval)) != KDUMP_OK) {
-			flags.indirect = 0;
+			flags.indirect = false;
 			discard_value(pval, attr->template->type, flags);
 			return res;
 		}
@@ -958,12 +958,12 @@ set_attr(kdump_ctx_t *ctx, struct attr_data *attr,
 		if (flags.indirect)
 			attr->pval = pval;
 		else if (attr->flags.indirect) {
-			flags.indirect = 1;
+			flags.indirect = true;
 			*attr->pval = *pval;
 		} else
 			attr->val = *pval;
 	}
-	flags.isset = 1;
+	flags.isset = true;
 	attr->flags = flags;
 
 	if (!skiphooks) {
@@ -1029,7 +1029,7 @@ set_attr_string(kdump_ctx_t *ctx, struct attr_data *attr,
 				 "Cannot allocate string");
 
 	val.string = dynstr;
-	flags.dynstr = 1;
+	flags.dynstr = true;
 	return set_attr(ctx, attr, flags, &val);
 }
 
@@ -1059,7 +1059,7 @@ set_attr_sized_string(kdump_ctx_t *ctx, struct attr_data *attr,
 	dynstr[dynlen-1] = '\0';
 
 	val.string = dynstr;
-	flags.dynstr = 1;
+	flags.dynstr = true;
 	return set_attr(ctx, attr, flags, &val);
 }
 

src/kdumpfile/diskdump.c

@@ -989,7 +989,7 @@ mem_pagemap_revalidate(kdump_ctx_t *ctx, struct attr_data *attr)
 		status = parent_revalidate(ctx, attr);
 	if (status == KDUMP_OK) {
 		ddp->mem_pagemap_override.ops.revalidate = parent_revalidate;
-		attr->flags.invalid = 0;
+		attr->flags.invalid = false;
 	}
 	return status;
 }

src/kdumpfile/kdumpfile-priv.h

@@ -455,11 +455,11 @@ struct attr_template {
 /**  Attribute value flags.
  */
 struct attr_flags {
-	uint8_t isset : 1;	/**< Zero if attribute has no value */
-	uint8_t persist : 1;	/**< Persistent (not cleared on re-open) */
-	uint8_t dynstr : 1;	/**< Dynamically allocated string */
-	uint8_t indirect : 1;	/**< Actual value is at @c *pval */
-	uint8_t invalid : 1;	/**< Value needs revalidation */
+	bool isset : 1;		/**< Zero if attribute has no value */
+	bool persist : 1;	/**< Persistent (not cleared on re-open) */
+	bool dynstr : 1;	/**< Dynamically allocated string */
+	bool indirect : 1;	/**< Actual value is at @c *pval */
+	bool invalid : 1;	/**< Value needs revalidation */
 };
 
 /**  Default attribute flags. */
@@ -468,19 +468,19 @@ struct attr_flags {
 
 /**  Persistent attribute flags. */
 #define ATTR_PERSIST	\
-	((struct attr_flags){ .persist = 1 })
+	((struct attr_flags){ .persist = true })
 
 /**  Indirect attribute flags. */
 #define ATTR_INDIRECT	\
-	((struct attr_flags){ .indirect = 1 })
+	((struct attr_flags){ .indirect = true })
 
 /**  Invalid attribute flags. */
 #define ATTR_INVALID	\
-	((struct attr_flags){ .invalid = 1 })
+	((struct attr_flags){ .invalid = true })
 
 /**  Persistent indirect attribute flags. */
 #define ATTR_PERSIST_INDIRECT	\
-	((struct attr_flags){ .persist = 1, .indirect = 1 })
+	((struct attr_flags){ .persist = true, .indirect = true })
 
 
 /**  Attribute template flags.
@@ -1102,9 +1102,9 @@ gattr(const kdump_ctx_t *ctx, enum global_keyidx idx)
 
 /**  Check if an attribute is set.
  * @param data  Pointer to the attribute data.
- * @returns     Non-zero if attribute data is valid.
+ * @returns     @c true if attribute data is valid.
  */
-static inline int
+static inline bool
 attr_isset(const struct attr_data *data)
 {
 	return data->flags.isset;
@@ -1133,7 +1133,7 @@ attr_embed_value(struct attr_data *attr)
 {
 	if (attr->flags.indirect) {
 		attr->val = *attr->pval;
-		attr->flags.indirect = 0;
+		attr->flags.indirect = false;
 	}
 }
 

src/kdumpfile/open.c

@@ -193,7 +193,7 @@ num_files_pre_hook(kdump_ctx_t *ctx, struct attr_data *attr,
 			break;
 		}
 		if (i == 0) {
-			fdattr->flags.indirect = 1;
+			fdattr->flags.indirect = true;
 			fdattr->pval = attr_mut_value(gattr(ctx, GKI_file_fd));
 		}
 	}

src/kdumpfile/sadump.c

@@ -516,7 +516,7 @@ mem_pagemap_revalidate(kdump_ctx_t *ctx, struct attr_data *attr)
 		ret = parent_revalidate(ctx, attr);
 	if (ret == KDUMP_OK) {
 		sp->mem_pagemap_override.ops.revalidate = parent_revalidate;
-		attr->flags.invalid = 0;
+		attr->flags.invalid = false;
 	}
 	return ret;
 }

src/kdumpfile/util.c

@@ -1158,7 +1158,7 @@ derived_attr_update(kdump_ctx_t *ctx, struct attr_data *attr,
 				   "Writing %hu-byte values not implemented",
 				   def->length);
 	}
-	attr->flags.invalid = 1;
+	attr->flags.invalid = true;
 
  unpin:
 	internal_blob_unpin(blob);

src/kdumpfile/vtop.c

@@ -99,7 +99,7 @@ create_addrxlat_dir(struct attr_dict *dict, enum global_keyidx dirkey)
 	struct attr_data *dir, *attr;
 
 	dir = dgattr(dict, dirkey);
-	dir->flags.isset = 1;
+	dir->flags.isset = true;
 
 	for (tmpl = options; tmpl < &options[ARRAY_SIZE(options)]; ++tmpl) {
 		attr = new_attr(dict, dir, tmpl);