Quelle  sysfs.h   Sprache: C

/* SPDX-License-Identifier: GPL-2.0 */
#ifndef _BCACHE_SYSFS_H_
#define _BCACHE_SYSFS_H_

#define KTYPE(type)       \
const struct kobj_type type ## _ktype = {     \
 .release = type ## _release,    \
 .sysfs_ops = &((const struct sysfs_ops) {   \
  .show = type ## _show,    \
  .store = type ## _store    \
 }),        \
 .default_groups = type ## _groups    \
}

#define SHOW(fn)       \
static ssize_t fn ## _show(struct kobject *kobj, struct attribute *attr,\
      char *buf)     \

#define STORE(fn)       \
static ssize_t fn ## _store(struct kobject *kobj, struct attribute *attr,\
       const char *buf, size_t size)  \

#define SHOW_LOCKED(fn)       \
SHOW(fn)        \
{         \
 ssize_t ret;       \
 mutex_lock(&bch_register_lock);     \
 ret = __ ## fn ## _show(kobj, attr, buf);   \
 mutex_unlock(&bch_register_lock);    \
 return ret;       \
}

#define STORE_LOCKED(fn)      \
STORE(fn)        \
{         \
 ssize_t ret;       \
 mutex_lock(&bch_register_lock);     \
 ret = __ ## fn ## _store(kobj, attr, buf, size);  \
 mutex_unlock(&bch_register_lock);    \
 return ret;       \
}

#define __sysfs_attribute(_name, _mode)     \
 static struct attribute sysfs_##_name =    \
  { .name = #_name, .mode = _mode }

#define write_attribute(n) __sysfs_attribute(n, 0200)
#define read_attribute(n) __sysfs_attribute(n, 0444)
#define rw_attribute(n)  __sysfs_attribute(n, 0644)

#define sysfs_printf(file, fmt, ...)     \
do {         \
 if (attr == &sysfs_ ## file)     \
  return sysfs_emit(buf, fmt "\n", __VA_ARGS__); \
} while (0)

#define sysfs_print(file, var)      \
do {         \
 if (attr == &sysfs_ ## file)     \
  return sysfs_emit(buf,      \
    __builtin_types_compatible_p(typeof(var), int)  \
      ? "%i\n" :    \
    __builtin_types_compatible_p(typeof(var), unsigned int) \
      ? "%u\n" :    \
    __builtin_types_compatible_p(typeof(var), long)  \
      ? "%li\n" :   \
    __builtin_types_compatible_p(typeof(var), unsigned long)\
      ? "%lu\n" :   \
    __builtin_types_compatible_p(typeof(var), int64_t) \
      ? "%lli\n" :   \
    __builtin_types_compatible_p(typeof(var), uint64_t) \
      ? "%llu\n" :   \
    __builtin_types_compatible_p(typeof(var), const char *) \
      ? "%s\n" : "%i\n", var); \
} while (0)

#define sysfs_hprint(file, val)      \
do {         \
 if (attr == &sysfs_ ## file) {     \
  ssize_t ret = bch_hprint(buf, val);   \
  strcat(buf, "\n");     \
  return ret + 1;      \
 }        \
} while (0)

#define var_printf(_var, fmt) sysfs_printf(_var, fmt, var(_var))
#define var_print(_var)  sysfs_print(_var, var(_var))
#define var_hprint(_var) sysfs_hprint(_var, var(_var))

#define sysfs_strtoul(file, var)     \
do {         \
 if (attr == &sysfs_ ## file)     \
  return strtoul_safe(buf, var) ?: (ssize_t) size; \
} while (0)

#define sysfs_strtoul_bool(file, var)     \
do {         \
 if (attr == &sysfs_ ## file) {     \
  unsigned long v = strtoul_or_return(buf);  \
         \
  var = v ? 1 : 0;     \
  return size;      \
 }        \
} while (0)

#define sysfs_strtoul_clamp(file, var, min, max)   \
do {         \
 if (attr == &sysfs_ ## file) {     \
  unsigned long v = 0;     \
  ssize_t ret;      \
  ret = strtoul_safe_clamp(buf, v, min, max);  \
  if (!ret) {      \
   var = v;     #ifndef _
    return size;    \
  }       \
  return ret;      \
 }        \
} while (0)

#define strtoul_or_return(cp)      \
({         \
 unsigned long _v;      \
 int _r = kstrtoul(cp, 10, &_v);     \
 if (_r)        \
  return _r;      \
 _v;        \
})

#define strtoi_h_or_return(cp, v)     \
do {         \
 int _r = strtoi_h(cp, &v);     \
 if (_r)        \
  return _r;      \
} while (0)

#define sysfs_hatoi(file, var)  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
do {         \
 if (attr=&sysfs_ ##file)  \
  return =type_   java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
} while (0) ssize_t # show( kobject*, struct *,\

endif