Clean up CSTYLEDs

69 CSTYLED BEGINs remain, appx. 30 of which can be removed if cstyle(1)
had a useful policy regarding
  CALL(ARG1,
  	ARG2,
  	ARG3);
above 2 lines. As it stands, it spits out *both*
  sysctl_os.c: 385: continuation line should be indented by 4 spaces
  sysctl_os.c: 385: indent by spaces instead of tabs
which is very cool

Another >10 could be fixed by removing "ulong" &al. handling.
I don't foresee anyone actually using it intentionally
(does it even exist in modern headers? why did it in the first place?).

Reviewed-by: Brian Behlendorf <behlendorf1@llnl.gov>
Signed-off-by: Ahelenia Ziemiańska <nabijaczleweli@nabijaczleweli.xyz>
Closes #12993
This commit is contained in:
наб 2022-01-21 17:07:15 +01:00 committed by Brian Behlendorf
parent a3fecf4f10
commit 7ada752a93
127 changed files with 522 additions and 748 deletions

View File

@ -126,6 +126,8 @@ cstyle:
! -name 'zfs_config.*' ! -name '*.mod.c' \ ! -name 'zfs_config.*' ! -name '*.mod.c' \
! -name 'opt_global.h' ! -name '*_if*.h' \ ! -name 'opt_global.h' ! -name '*_if*.h' \
! -path './module/zstd/lib/*' \ ! -path './module/zstd/lib/*' \
! -path './include/sys/lua/*' \
! -path './module/lua/l*.[ch]' \
! -path './module/zfs/lz4.c' \ ! -path './module/zfs/lz4.c' \
$(cstyle_line) $(cstyle_line)

View File

@ -82,18 +82,17 @@ typedef struct {
volatile int counter; volatile int counter;
} atomic_t; } atomic_t;
/* BEGIN CSTYLED */
#define hlist_for_each(p, head) \ #define hlist_for_each(p, head) \
for (p = (head)->first; p; p = (p)->next) for (p = (head)->first; p; p = (p)->next)
#define hlist_entry(ptr, type, field) container_of(ptr, type, field) #define hlist_entry(ptr, type, field) container_of(ptr, type, field)
#define container_of(ptr, type, member) \ #define container_of(ptr, type, member) \
/* CSTYLED */ \
({ \ ({ \
const __typeof(((type *)0)->member) *__p = (ptr); \ const __typeof(((type *)0)->member) *__p = (ptr); \
(type *)((uintptr_t)__p - offsetof(type, member)); \ (type *)((uintptr_t)__p - offsetof(type, member)); \
}) })
/* END CSTYLED */
static inline void static inline void
hlist_add_head(struct hlist_node *n, struct hlist_head *h) hlist_add_head(struct hlist_node *n, struct hlist_head *h)

View File

@ -34,12 +34,10 @@
#define isalnum(ch) (isalpha(ch) || isdigit(ch)) #define isalnum(ch) (isalpha(ch) || isdigit(ch))
#define iscntrl(C) (uchar(C) <= 0x1f || uchar(C) == 0x7f) #define iscntrl(C) (uchar(C) <= 0x1f || uchar(C) == 0x7f)
#define isgraph(C) ((C) >= 0x21 && (C) <= 0x7E) #define isgraph(C) ((C) >= 0x21 && (C) <= 0x7E)
/* BEGIN CSTYLED */
#define ispunct(C) \ #define ispunct(C) \
(((C) >= 0x21 && (C) <= 0x2F) || \ (((C) >= 0x21 && (C) <= 0x2F) || \
((C) >= 0x3A && (C) <= 0x40) || \ ((C) >= 0x3A && (C) <= 0x40) || \
((C) >= 0x5B && (C) <= 0x60) || \ ((C) >= 0x5B && (C) <= 0x60) || \
((C) >= 0x7B && (C) <= 0x7E)) ((C) >= 0x7B && (C) <= 0x7E))
/* END CSTYLED */
#endif #endif

View File

@ -64,7 +64,6 @@ void spl_dumpstack(void);
#define likely(expr) expect((expr) != 0, 1) #define likely(expr) expect((expr) != 0, 1)
#define unlikely(expr) expect((expr) != 0, 0) #define unlikely(expr) expect((expr) != 0, 0)
/* BEGIN CSTYLED */
#define PANIC(fmt, a...) \ #define PANIC(fmt, a...) \
spl_panic(__FILE__, __FUNCTION__, __LINE__, fmt, ## a) spl_panic(__FILE__, __FUNCTION__, __LINE__, fmt, ## a)
@ -75,13 +74,13 @@ void spl_dumpstack(void);
#define VERIFY3B(LEFT, OP, RIGHT) do { \ #define VERIFY3B(LEFT, OP, RIGHT) do { \
const boolean_t _verify3_left = (boolean_t)(LEFT); \ const boolean_t _verify3_left = (boolean_t)(LEFT); \
const boolean_t _verify3_right = (boolean_t)(RIGHT);\ const boolean_t _verify3_right = (boolean_t)(RIGHT); \
if (unlikely(!(_verify3_left OP _verify3_right))) \ if (unlikely(!(_verify3_left OP _verify3_right))) \
spl_panic(__FILE__, __FUNCTION__, __LINE__, \ spl_panic(__FILE__, __FUNCTION__, __LINE__, \
"VERIFY3(" #LEFT " " #OP " " #RIGHT ") " \ "VERIFY3(" #LEFT " " #OP " " #RIGHT ") " \
"failed (%d " #OP " %d)\n", \ "failed (%d " #OP " %d)\n", \
(boolean_t) (_verify3_left), \ (boolean_t)(_verify3_left), \
(boolean_t) (_verify3_right)); \ (boolean_t)(_verify3_right)); \
} while (0) } while (0)
#define VERIFY3S(LEFT, OP, RIGHT) do { \ #define VERIFY3S(LEFT, OP, RIGHT) do { \
@ -108,7 +107,7 @@ void spl_dumpstack(void);
#define VERIFY3P(LEFT, OP, RIGHT) do { \ #define VERIFY3P(LEFT, OP, RIGHT) do { \
const uintptr_t _verify3_left = (uintptr_t)(LEFT); \ const uintptr_t _verify3_left = (uintptr_t)(LEFT); \
const uintptr_t _verify3_right = (uintptr_t)(RIGHT);\ const uintptr_t _verify3_right = (uintptr_t)(RIGHT); \
if (unlikely(!(_verify3_left OP _verify3_right))) \ if (unlikely(!(_verify3_left OP _verify3_right))) \
spl_panic(__FILE__, __FUNCTION__, __LINE__, \ spl_panic(__FILE__, __FUNCTION__, __LINE__, \
"VERIFY3(" #LEFT " " #OP " " #RIGHT ") " \ "VERIFY3(" #LEFT " " #OP " " #RIGHT ") " \
@ -167,7 +166,6 @@ void spl_dumpstack(void);
((void)(likely(!!(A) == !!(B)) || \ ((void)(likely(!!(A) == !!(B)) || \
spl_panic(__FILE__, __FUNCTION__, __LINE__, \ spl_panic(__FILE__, __FUNCTION__, __LINE__, \
"(" #A ") is equivalent to (" #B ")"))) "(" #A ") is equivalent to (" #B ")")))
/* END CSTYLED */
#endif /* NDEBUG */ #endif /* NDEBUG */

View File

@ -43,10 +43,10 @@
#define ZMOD_RW CTLFLAG_RWTUN #define ZMOD_RW CTLFLAG_RWTUN
#define ZMOD_RD CTLFLAG_RDTUN #define ZMOD_RD CTLFLAG_RDTUN
/* BEGIN CSTYLED */
#define ZFS_MODULE_PARAM(scope_prefix, name_prefix, name, type, perm, desc) \ #define ZFS_MODULE_PARAM(scope_prefix, name_prefix, name, type, perm, desc) \
SYSCTL_DECL(_vfs_ ## scope_prefix); \ SYSCTL_DECL(_vfs_ ## scope_prefix); \
SYSCTL_##type(_vfs_ ## scope_prefix, OID_AUTO, name, perm, &name_prefix ## name, 0, desc) SYSCTL_##type(_vfs_ ## scope_prefix, OID_AUTO, name, perm, \
&name_prefix ## name, 0, desc)
#define ZFS_MODULE_PARAM_ARGS SYSCTL_HANDLER_ARGS #define ZFS_MODULE_PARAM_ARGS SYSCTL_HANDLER_ARGS
@ -54,8 +54,10 @@
SYSCTL_DECL(parent); \ SYSCTL_DECL(parent); \
SYSCTL_PROC(parent, OID_AUTO, name, perm | args, desc) SYSCTL_PROC(parent, OID_AUTO, name, perm | args, desc)
#define ZFS_MODULE_PARAM_CALL(scope_prefix, name_prefix, name, func, _, perm, desc) \ #define ZFS_MODULE_PARAM_CALL( \
ZFS_MODULE_PARAM_CALL_IMPL(_vfs_ ## scope_prefix, name, perm, func ## _args(name_prefix ## name), desc) scope_prefix, name_prefix, name, func, _, perm, desc) \
ZFS_MODULE_PARAM_CALL_IMPL(_vfs_ ## scope_prefix, name, perm, \
func ## _args(name_prefix ## name), desc)
#define ZFS_MODULE_VIRTUAL_PARAM_CALL ZFS_MODULE_PARAM_CALL #define ZFS_MODULE_VIRTUAL_PARAM_CALL ZFS_MODULE_PARAM_CALL
@ -119,6 +121,5 @@ wrap_ ## fn(void *dummy __unused) \
fn(); \ fn(); \
} \ } \
SYSUNINIT(zfs_ ## fn, SI_SUB_LAST, SI_ORDER_FIRST, wrap_ ## fn, NULL) SYSUNINIT(zfs_ ## fn, SI_SUB_LAST, SI_ORDER_FIRST, wrap_ ## fn, NULL)
/* END CSTYLED */
#endif /* SPL_MOD_H */ #endif /* SPL_MOD_H */

View File

@ -57,13 +57,12 @@ typedef struct sx krwlock_t;
#define RW_WRITE_HELD(x) (rw_write_held((x))) #define RW_WRITE_HELD(x) (rw_write_held((x)))
#define RW_LOCK_HELD(x) (rw_lock_held((x))) #define RW_LOCK_HELD(x) (rw_lock_held((x)))
#define RW_ISWRITER(x) (rw_iswriter(x)) #define RW_ISWRITER(x) (rw_iswriter(x))
/* BEGIN CSTYLED */
#define rw_init(lock, desc, type, arg) do { \ #define rw_init(lock, desc, type, arg) do { \
const char *_name; \ const char *_name; \
ASSERT((type) == 0 || (type) == RW_DEFAULT); \ ASSERT((type) == 0 || (type) == RW_DEFAULT); \
KASSERT(((lock)->lock_object.lo_flags & LO_ALLMASK) != \ KASSERT(((lock)->lock_object.lo_flags & LO_ALLMASK) != \
LO_EXPECTED, ("lock %s already initialized", #lock)); \ LO_EXPECTED, ("lock %s already initialized", #lock)); \
bzero((lock), sizeof(struct sx)); \ bzero((lock), sizeof (struct sx)); \
for (_name = #lock; *_name != '\0'; _name++) { \ for (_name = #lock; *_name != '\0'; _name++) { \
if (*_name >= 'a' && *_name <= 'z') \ if (*_name >= 'a' && *_name <= 'z') \
break; \ break; \
@ -93,5 +92,4 @@ typedef struct sx krwlock_t;
#define rw_iswriter(lock) sx_xlocked(lock) #define rw_iswriter(lock) sx_xlocked(lock)
#define rw_owner(lock) sx_xholder(lock) #define rw_owner(lock) sx_xholder(lock)
/* END CSTYLED */
#endif /* _OPENSOLARIS_SYS_RWLOCK_H_ */ #endif /* _OPENSOLARIS_SYS_RWLOCK_H_ */

View File

@ -30,8 +30,8 @@
#define _OPENSOLARIS_SYS_SDT_H_ #define _OPENSOLARIS_SYS_SDT_H_
#include_next <sys/sdt.h> #include_next <sys/sdt.h>
/* BEGIN CSTYLED */
#ifdef KDTRACE_HOOKS #ifdef KDTRACE_HOOKS
/* CSTYLED */
SDT_PROBE_DECLARE(sdt, , , set__error); SDT_PROBE_DECLARE(sdt, , , set__error);
#define SET_ERROR(err) \ #define SET_ERROR(err) \

View File

@ -64,8 +64,8 @@ typedef u_int uint_t;
typedef u_char uchar_t; typedef u_char uchar_t;
typedef u_short ushort_t; typedef u_short ushort_t;
typedef u_long ulong_t; typedef u_long ulong_t;
typedef int minor_t;
/* END CSTYLED */ /* END CSTYLED */
typedef int minor_t;
#ifndef _OFF64_T_DECLARED #ifndef _OFF64_T_DECLARED
#define _OFF64_T_DECLARED #define _OFF64_T_DECLARED
typedef off_t off64_t; typedef off_t off64_t;

View File

@ -40,13 +40,13 @@ typedef struct kernel_param zfs_kernel_param_t;
#define ZMOD_RW 0644 #define ZMOD_RW 0644
#define ZMOD_RD 0444 #define ZMOD_RD 0444
/* BEGIN CSTYLED */
#define INT int #define INT int
#define LONG long
/* BEGIN CSTYLED */
#define UINT uint #define UINT uint
#define ULONG ulong #define ULONG ulong
#define LONG long
#define STRING charp
/* END CSTYLED */ /* END CSTYLED */
#define STRING charp
enum scope_prefix_types { enum scope_prefix_types {
zfs, zfs,
@ -108,12 +108,11 @@ enum scope_prefix_types {
* on Linux: * on Linux:
* dmu_prefetch_max * dmu_prefetch_max
*/ */
/* BEGIN CSTYLED */
#define ZFS_MODULE_PARAM(scope_prefix, name_prefix, name, type, perm, desc) \ #define ZFS_MODULE_PARAM(scope_prefix, name_prefix, name, type, perm, desc) \
CTASSERT_GLOBAL((sizeof (scope_prefix) == sizeof (enum scope_prefix_types))); \ CTASSERT_GLOBAL( \
sizeof (scope_prefix) == sizeof (enum scope_prefix_types)); \
module_param(name_prefix ## name, type, perm); \ module_param(name_prefix ## name, type, perm); \
MODULE_PARM_DESC(name_prefix ## name, desc) MODULE_PARM_DESC(name_prefix ## name, desc)
/* END CSTYLED */
/* /*
* Declare a module parameter / sysctl node * Declare a module parameter / sysctl node
@ -137,23 +136,24 @@ enum scope_prefix_types {
* on Linux: * on Linux:
* spa_slop_shift * spa_slop_shift
*/ */
/* BEGIN CSTYLED */ #define ZFS_MODULE_PARAM_CALL( \
#define ZFS_MODULE_PARAM_CALL(scope_prefix, name_prefix, name, setfunc, getfunc, perm, desc) \ scope_prefix, name_prefix, name, setfunc, getfunc, perm, desc) \
CTASSERT_GLOBAL((sizeof (scope_prefix) == sizeof (enum scope_prefix_types))); \ CTASSERT_GLOBAL( \
module_param_call(name_prefix ## name, setfunc, getfunc, &name_prefix ## name, perm); \ sizeof (scope_prefix) == sizeof (enum scope_prefix_types)); \
module_param_call(name_prefix ## name, setfunc, getfunc, \
&name_prefix ## name, perm); \
MODULE_PARM_DESC(name_prefix ## name, desc) MODULE_PARM_DESC(name_prefix ## name, desc)
/* END CSTYLED */
/* /*
* As above, but there is no variable with the name name_prefix ## name, * As above, but there is no variable with the name name_prefix ## name,
* so NULL is passed to module_param_call instead. * so NULL is passed to module_param_call instead.
*/ */
/* BEGIN CSTYLED */ #define ZFS_MODULE_VIRTUAL_PARAM_CALL( \
#define ZFS_MODULE_VIRTUAL_PARAM_CALL(scope_prefix, name_prefix, name, setfunc, getfunc, perm, desc) \ scope_prefix, name_prefix, name, setfunc, getfunc, perm, desc) \
CTASSERT_GLOBAL((sizeof (scope_prefix) == sizeof (enum scope_prefix_types))); \ CTASSERT_GLOBAL(\
sizeof (scope_prefix) == sizeof (enum scope_prefix_types)); \
module_param_call(name_prefix ## name, setfunc, getfunc, NULL, perm); \ module_param_call(name_prefix ## name, setfunc, getfunc, NULL, perm); \
MODULE_PARM_DESC(name_prefix ## name, desc) MODULE_PARM_DESC(name_prefix ## name, desc)
/* END CSTYLED */
#define ZFS_MODULE_PARAM_ARGS const char *buf, zfs_kernel_param_t *kp #define ZFS_MODULE_PARAM_ARGS const char *buf, zfs_kernel_param_t *kp

View File

@ -102,13 +102,11 @@ typedef struct ace_object {
#define ACE_TYPE_FLAGS (ACE_OWNER|ACE_GROUP|ACE_EVERYONE|ACE_IDENTIFIER_GROUP) #define ACE_TYPE_FLAGS (ACE_OWNER|ACE_GROUP|ACE_EVERYONE|ACE_IDENTIFIER_GROUP)
/* BEGIN CSTYLED */
#define ACE_ALL_PERMS (ACE_READ_DATA|ACE_LIST_DIRECTORY|ACE_WRITE_DATA| \ #define ACE_ALL_PERMS (ACE_READ_DATA|ACE_LIST_DIRECTORY|ACE_WRITE_DATA| \
ACE_ADD_FILE|ACE_APPEND_DATA|ACE_ADD_SUBDIRECTORY|ACE_READ_NAMED_ATTRS| \ ACE_ADD_FILE|ACE_APPEND_DATA|ACE_ADD_SUBDIRECTORY|ACE_READ_NAMED_ATTRS|\
ACE_WRITE_NAMED_ATTRS|ACE_EXECUTE|ACE_DELETE_CHILD|ACE_READ_ATTRIBUTES| \ ACE_WRITE_NAMED_ATTRS|ACE_EXECUTE|ACE_DELETE_CHILD|ACE_READ_ATTRIBUTES|\
ACE_WRITE_ATTRIBUTES|ACE_DELETE|ACE_READ_ACL|ACE_WRITE_ACL| \ ACE_WRITE_ATTRIBUTES|ACE_DELETE|ACE_READ_ACL|ACE_WRITE_ACL| \
ACE_WRITE_OWNER|ACE_SYNCHRONIZE) ACE_WRITE_OWNER|ACE_SYNCHRONIZE)
/* END CSTYLED */
#define VSA_ACE 0x0010 #define VSA_ACE 0x0010
#define VSA_ACECNT 0x0020 #define VSA_ACECNT 0x0020

View File

@ -58,7 +58,6 @@ int spl_panic(const char *file, const char *func, int line,
const char *fmt, ...); const char *fmt, ...);
void spl_dumpstack(void); void spl_dumpstack(void);
/* BEGIN CSTYLED */
#define PANIC(fmt, a...) \ #define PANIC(fmt, a...) \
spl_panic(__FILE__, __FUNCTION__, __LINE__, fmt, ## a) spl_panic(__FILE__, __FUNCTION__, __LINE__, fmt, ## a)
@ -69,13 +68,13 @@ void spl_dumpstack(void);
#define VERIFY3B(LEFT, OP, RIGHT) do { \ #define VERIFY3B(LEFT, OP, RIGHT) do { \
const boolean_t _verify3_left = (boolean_t)(LEFT); \ const boolean_t _verify3_left = (boolean_t)(LEFT); \
const boolean_t _verify3_right = (boolean_t)(RIGHT);\ const boolean_t _verify3_right = (boolean_t)(RIGHT); \
if (unlikely(!(_verify3_left OP _verify3_right))) \ if (unlikely(!(_verify3_left OP _verify3_right))) \
spl_panic(__FILE__, __FUNCTION__, __LINE__, \ spl_panic(__FILE__, __FUNCTION__, __LINE__, \
"VERIFY3(" #LEFT " " #OP " " #RIGHT ") " \ "VERIFY3(" #LEFT " " #OP " " #RIGHT ") " \
"failed (%d " #OP " %d)\n", \ "failed (%d " #OP " %d)\n", \
(boolean_t) (_verify3_left), \ (boolean_t)(_verify3_left), \
(boolean_t) (_verify3_right)); \ (boolean_t)(_verify3_right)); \
} while (0) } while (0)
#define VERIFY3S(LEFT, OP, RIGHT) do { \ #define VERIFY3S(LEFT, OP, RIGHT) do { \
@ -85,8 +84,8 @@ void spl_dumpstack(void);
spl_panic(__FILE__, __FUNCTION__, __LINE__, \ spl_panic(__FILE__, __FUNCTION__, __LINE__, \
"VERIFY3(" #LEFT " " #OP " " #RIGHT ") " \ "VERIFY3(" #LEFT " " #OP " " #RIGHT ") " \
"failed (%lld " #OP " %lld)\n", \ "failed (%lld " #OP " %lld)\n", \
(long long) (_verify3_left), \ (long long)(_verify3_left), \
(long long) (_verify3_right)); \ (long long)(_verify3_right)); \
} while (0) } while (0)
#define VERIFY3U(LEFT, OP, RIGHT) do { \ #define VERIFY3U(LEFT, OP, RIGHT) do { \
@ -96,13 +95,13 @@ void spl_dumpstack(void);
spl_panic(__FILE__, __FUNCTION__, __LINE__, \ spl_panic(__FILE__, __FUNCTION__, __LINE__, \
"VERIFY3(" #LEFT " " #OP " " #RIGHT ") " \ "VERIFY3(" #LEFT " " #OP " " #RIGHT ") " \
"failed (%llu " #OP " %llu)\n", \ "failed (%llu " #OP " %llu)\n", \
(unsigned long long) (_verify3_left), \ (unsigned long long)(_verify3_left), \
(unsigned long long) (_verify3_right)); \ (unsigned long long)(_verify3_right)); \
} while (0) } while (0)
#define VERIFY3P(LEFT, OP, RIGHT) do { \ #define VERIFY3P(LEFT, OP, RIGHT) do { \
const uintptr_t _verify3_left = (uintptr_t)(LEFT); \ const uintptr_t _verify3_left = (uintptr_t)(LEFT); \
const uintptr_t _verify3_right = (uintptr_t)(RIGHT);\ const uintptr_t _verify3_right = (uintptr_t)(RIGHT); \
if (unlikely(!(_verify3_left OP _verify3_right))) \ if (unlikely(!(_verify3_left OP _verify3_right))) \
spl_panic(__FILE__, __FUNCTION__, __LINE__, \ spl_panic(__FILE__, __FUNCTION__, __LINE__, \
"VERIFY3(" #LEFT " " #OP " " #RIGHT ") " \ "VERIFY3(" #LEFT " " #OP " " #RIGHT ") " \
@ -125,7 +124,7 @@ void spl_dumpstack(void);
#define CTASSERT(x) { _CTASSERT(x, __LINE__); } #define CTASSERT(x) { _CTASSERT(x, __LINE__); }
#define _CTASSERT(x, y) __CTASSERT(x, y) #define _CTASSERT(x, y) __CTASSERT(x, y)
#define __CTASSERT(x, y) \ #define __CTASSERT(x, y) \
typedef char __attribute__ ((unused)) \ typedef char __attribute__((unused)) \
__compile_time_assertion__ ## y[(x) ? 1 : -1] __compile_time_assertion__ ## y[(x) ? 1 : -1]
/* /*
@ -167,7 +166,6 @@ void spl_dumpstack(void);
((void)(likely(!!(A) == !!(B)) || \ ((void)(likely(!!(A) == !!(B)) || \
spl_panic(__FILE__, __FUNCTION__, __LINE__, \ spl_panic(__FILE__, __FUNCTION__, __LINE__, \
"(" #A ") is equivalent to (" #B ")"))) "(" #A ") is equivalent to (" #B ")")))
/* END CSTYLED */
#endif /* NDEBUG */ #endif /* NDEBUG */

View File

@ -113,8 +113,8 @@ spl_mutex_lockdep_on_maybe(kmutex_t *mp) \
VERIFY3P(mutex_owner(mp), ==, NULL); \ VERIFY3P(mutex_owner(mp), ==, NULL); \
} }
/* BEGIN CSTYLED */
#define mutex_tryenter(mp) \ #define mutex_tryenter(mp) \
/* CSTYLED */ \
({ \ ({ \
int _rc_; \ int _rc_; \
\ \
@ -125,7 +125,6 @@ spl_mutex_lockdep_on_maybe(kmutex_t *mp) \
\ \
_rc_; \ _rc_; \
}) })
/* END CSTYLED */
#define NESTED_SINGLE 1 #define NESTED_SINGLE 1

View File

@ -116,8 +116,7 @@ RW_READ_HELD(krwlock_t *rwp)
* will be correctly located in the users code which is important * will be correctly located in the users code which is important
* for the built in kernel lock analysis tools * for the built in kernel lock analysis tools
*/ */
/* BEGIN CSTYLED */ #define rw_init(rwp, name, type, arg) /* CSTYLED */ \
#define rw_init(rwp, name, type, arg) \
({ \ ({ \
static struct lock_class_key __key; \ static struct lock_class_key __key; \
ASSERT(type == RW_DEFAULT || type == RW_NOLOCKDEP); \ ASSERT(type == RW_DEFAULT || type == RW_NOLOCKDEP); \
@ -138,7 +137,7 @@ RW_READ_HELD(krwlock_t *rwp)
*/ */
#define rw_tryupgrade(rwp) RW_WRITE_HELD(rwp) #define rw_tryupgrade(rwp) RW_WRITE_HELD(rwp)
#define rw_tryenter(rwp, rw) \ #define rw_tryenter(rwp, rw) /* CSTYLED */ \
({ \ ({ \
int _rc_ = 0; \ int _rc_ = 0; \
\ \
@ -158,7 +157,7 @@ RW_READ_HELD(krwlock_t *rwp)
_rc_; \ _rc_; \
}) })
#define rw_enter(rwp, rw) \ #define rw_enter(rwp, rw) /* CSTYLED */ \
({ \ ({ \
spl_rw_lockdep_off_maybe(rwp); \ spl_rw_lockdep_off_maybe(rwp); \
switch (rw) { \ switch (rw) { \
@ -175,7 +174,7 @@ RW_READ_HELD(krwlock_t *rwp)
spl_rw_lockdep_on_maybe(rwp); \ spl_rw_lockdep_on_maybe(rwp); \
}) })
#define rw_exit(rwp) \ #define rw_exit(rwp) /* CSTYLED */ \
({ \ ({ \
spl_rw_lockdep_off_maybe(rwp); \ spl_rw_lockdep_off_maybe(rwp); \
if (RW_WRITE_HELD(rwp)) { \ if (RW_WRITE_HELD(rwp)) { \
@ -188,13 +187,12 @@ RW_READ_HELD(krwlock_t *rwp)
spl_rw_lockdep_on_maybe(rwp); \ spl_rw_lockdep_on_maybe(rwp); \
}) })
#define rw_downgrade(rwp) \ #define rw_downgrade(rwp) /* CSTYLED */ \
({ \ ({ \
spl_rw_lockdep_off_maybe(rwp); \ spl_rw_lockdep_off_maybe(rwp); \
spl_rw_clear_owner(rwp); \ spl_rw_clear_owner(rwp); \
downgrade_write(SEM(rwp)); \ downgrade_write(SEM(rwp)); \
spl_rw_lockdep_on_maybe(rwp); \ spl_rw_lockdep_on_maybe(rwp); \
}) })
/* END CSTYLED */
#endif /* _SPL_RWLOCK_H */ #endif /* _SPL_RWLOCK_H */

View File

@ -49,11 +49,9 @@ typedef void (*thread_func_t)(void *);
__thread_create(stk, stksize, (thread_func_t)func, \ __thread_create(stk, stksize, (thread_func_t)func, \
name, arg, len, pp, state, pri) name, arg, len, pp, state, pri)
/* BEGIN CSTYLED */
#define thread_create(stk, stksize, func, arg, len, pp, state, pri) \ #define thread_create(stk, stksize, func, arg, len, pp, state, pri) \
__thread_create(stk, stksize, (thread_func_t)func, \ __thread_create(stk, stksize, (thread_func_t)func, #func, \
#func, arg, len, pp, state, pri) arg, len, pp, state, pri)
/* END CSTYLED */
#define thread_exit() __thread_exit() #define thread_exit() __thread_exit()
#define thread_join(t) VERIFY(0) #define thread_join(t) VERIFY(0)

View File

@ -40,26 +40,20 @@
* DTRACE_PROBE1(..., * DTRACE_PROBE1(...,
* taskq_ent_t *, ...); * taskq_ent_t *, ...);
*/ */
/* BEGIN CSTYLED */
DECLARE_EVENT_CLASS(zfs_taskq_ent_class, DECLARE_EVENT_CLASS(zfs_taskq_ent_class,
TP_PROTO(taskq_ent_t *taskq_ent), TP_PROTO(taskq_ent_t *taskq_ent),
TP_ARGS(taskq_ent), TP_ARGS(taskq_ent),
TP_STRUCT__entry( TP_STRUCT__entry(__field(taskq_ent_t *, taskq_ent)),
__field(taskq_ent_t *, taskq_ent)
),
TP_fast_assign( TP_fast_assign(
__entry->taskq_ent = taskq_ent; __entry->taskq_ent = taskq_ent;
), ),
TP_printk("taskq_ent %p", __entry->taskq_ent) TP_printk("taskq_ent %p", __entry->taskq_ent)
); );
/* END CSTYLED */
/* BEGIN CSTYLED */
#define DEFINE_TASKQ_EVENT(name) \ #define DEFINE_TASKQ_EVENT(name) \
DEFINE_EVENT(zfs_taskq_ent_class, name, \ DEFINE_EVENT(zfs_taskq_ent_class, name, \
TP_PROTO(taskq_ent_t *taskq_ent), \ TP_PROTO(taskq_ent_t *taskq_ent), \
TP_ARGS(taskq_ent)) TP_ARGS(taskq_ent))
/* END CSTYLED */
DEFINE_TASKQ_EVENT(zfs_taskq_ent__birth); DEFINE_TASKQ_EVENT(zfs_taskq_ent__birth);
DEFINE_TASKQ_EVENT(zfs_taskq_ent__start); DEFINE_TASKQ_EVENT(zfs_taskq_ent__start);
DEFINE_TASKQ_EVENT(zfs_taskq_ent__finish); DEFINE_TASKQ_EVENT(zfs_taskq_ent__finish);

View File

@ -135,12 +135,10 @@ DECLARE_EVENT_CLASS(zfs_ace_class,
); );
/* END CSTYLED */ /* END CSTYLED */
/* BEGIN CSTYLED */
#define DEFINE_ACE_EVENT(name) \ #define DEFINE_ACE_EVENT(name) \
DEFINE_EVENT(zfs_ace_class, name, \ DEFINE_EVENT(zfs_ace_class, name, \
TP_PROTO(znode_t *zn, zfs_ace_hdr_t *ace, uint32_t mask_matched), \ TP_PROTO(znode_t *zn, zfs_ace_hdr_t *ace, uint32_t mask_matched), \
TP_ARGS(zn, ace, mask_matched)) TP_ARGS(zn, ace, mask_matched))
/* END CSTYLED */
DEFINE_ACE_EVENT(zfs_zfs__ace__denies); DEFINE_ACE_EVENT(zfs_zfs__ace__denies);
DEFINE_ACE_EVENT(zfs_zfs__ace__allows); DEFINE_ACE_EVENT(zfs_zfs__ace__allows);

View File

@ -98,12 +98,10 @@ DECLARE_EVENT_CLASS(zfs_arc_buf_hdr_class,
); );
/* END CSTYLED */ /* END CSTYLED */
/* BEGIN CSTYLED */
#define DEFINE_ARC_BUF_HDR_EVENT(name) \ #define DEFINE_ARC_BUF_HDR_EVENT(name) \
DEFINE_EVENT(zfs_arc_buf_hdr_class, name, \ DEFINE_EVENT(zfs_arc_buf_hdr_class, name, \
TP_PROTO(arc_buf_hdr_t *ab), \ TP_PROTO(arc_buf_hdr_t *ab), \
TP_ARGS(ab)) TP_ARGS(ab))
/* END CSTYLED */
DEFINE_ARC_BUF_HDR_EVENT(zfs_arc__hit); DEFINE_ARC_BUF_HDR_EVENT(zfs_arc__hit);
DEFINE_ARC_BUF_HDR_EVENT(zfs_arc__evict); DEFINE_ARC_BUF_HDR_EVENT(zfs_arc__evict);
DEFINE_ARC_BUF_HDR_EVENT(zfs_arc__delete); DEFINE_ARC_BUF_HDR_EVENT(zfs_arc__delete);
@ -143,12 +141,10 @@ DECLARE_EVENT_CLASS(zfs_l2arc_rw_class,
); );
/* END CSTYLED */ /* END CSTYLED */
/* BEGIN CSTYLED */
#define DEFINE_L2ARC_RW_EVENT(name) \ #define DEFINE_L2ARC_RW_EVENT(name) \
DEFINE_EVENT(zfs_l2arc_rw_class, name, \ DEFINE_EVENT(zfs_l2arc_rw_class, name, \
TP_PROTO(vdev_t *vd, zio_t *zio), \ TP_PROTO(vdev_t *vd, zio_t *zio), \
TP_ARGS(vd, zio)) TP_ARGS(vd, zio))
/* END CSTYLED */
DEFINE_L2ARC_RW_EVENT(zfs_l2arc__read); DEFINE_L2ARC_RW_EVENT(zfs_l2arc__read);
DEFINE_L2ARC_RW_EVENT(zfs_l2arc__write); DEFINE_L2ARC_RW_EVENT(zfs_l2arc__write);
@ -170,12 +166,10 @@ DECLARE_EVENT_CLASS(zfs_l2arc_iodone_class,
); );
/* END CSTYLED */ /* END CSTYLED */
/* BEGIN CSTYLED */
#define DEFINE_L2ARC_IODONE_EVENT(name) \ #define DEFINE_L2ARC_IODONE_EVENT(name) \
DEFINE_EVENT(zfs_l2arc_iodone_class, name, \ DEFINE_EVENT(zfs_l2arc_iodone_class, name, \
TP_PROTO(zio_t *zio, l2arc_write_callback_t *cb), \ TP_PROTO(zio_t *zio, l2arc_write_callback_t *cb), \
TP_ARGS(zio, cb)) TP_ARGS(zio, cb))
/* END CSTYLED */
DEFINE_L2ARC_IODONE_EVENT(zfs_l2arc__iodone); DEFINE_L2ARC_IODONE_EVENT(zfs_l2arc__iodone);
@ -284,13 +278,11 @@ DECLARE_EVENT_CLASS(zfs_arc_miss_class,
); );
/* END CSTYLED */ /* END CSTYLED */
/* BEGIN CSTYLED */
#define DEFINE_ARC_MISS_EVENT(name) \ #define DEFINE_ARC_MISS_EVENT(name) \
DEFINE_EVENT(zfs_arc_miss_class, name, \ DEFINE_EVENT(zfs_arc_miss_class, name, \
TP_PROTO(arc_buf_hdr_t *hdr, \ TP_PROTO(arc_buf_hdr_t *hdr, \
const blkptr_t *bp, uint64_t size, const zbookmark_phys_t *zb), \ const blkptr_t *bp, uint64_t size, const zbookmark_phys_t *zb), \
TP_ARGS(hdr, bp, size, zb)) TP_ARGS(hdr, bp, size, zb))
/* END CSTYLED */
DEFINE_ARC_MISS_EVENT(zfs_arc__miss); DEFINE_ARC_MISS_EVENT(zfs_arc__miss);
/* /*
@ -345,13 +337,10 @@ DECLARE_EVENT_CLASS(zfs_l2arc_evict_class,
); );
/* END CSTYLED */ /* END CSTYLED */
/* BEGIN CSTYLED */
#define DEFINE_L2ARC_EVICT_EVENT(name) \ #define DEFINE_L2ARC_EVICT_EVENT(name) \
DEFINE_EVENT(zfs_l2arc_evict_class, name, \ DEFINE_EVENT(zfs_l2arc_evict_class, name, \
TP_PROTO(l2arc_dev_t *dev, \ TP_PROTO(l2arc_dev_t *dev, list_t *buflist, uint64_t taddr, boolean_t all),\
list_t *buflist, uint64_t taddr, boolean_t all), \
TP_ARGS(dev, buflist, taddr, all)) TP_ARGS(dev, buflist, taddr, all))
/* END CSTYLED */
DEFINE_L2ARC_EVICT_EVENT(zfs_l2arc__evict); DEFINE_L2ARC_EVICT_EVENT(zfs_l2arc__evict);
/* /*
@ -381,12 +370,10 @@ DECLARE_EVENT_CLASS(zfs_arc_wait_for_eviction_class,
); );
/* END CSTYLED */ /* END CSTYLED */
/* BEGIN CSTYLED */
#define DEFINE_ARC_WAIT_FOR_EVICTION_EVENT(name) \ #define DEFINE_ARC_WAIT_FOR_EVICTION_EVENT(name) \
DEFINE_EVENT(zfs_arc_wait_for_eviction_class, name, \ DEFINE_EVENT(zfs_arc_wait_for_eviction_class, name, \
TP_PROTO(uint64_t amount, uint64_t arc_evict_count, uint64_t aew_count), \ TP_PROTO(uint64_t amount, uint64_t arc_evict_count, uint64_t aew_count), \
TP_ARGS(amount, arc_evict_count, aew_count)) TP_ARGS(amount, arc_evict_count, aew_count))
/* END CSTYLED */
DEFINE_ARC_WAIT_FOR_EVICTION_EVENT(zfs_arc__wait__for__eviction); DEFINE_ARC_WAIT_FOR_EVICTION_EVENT(zfs_arc__wait__for__eviction);
#endif /* _TRACE_ARC_H */ #endif /* _TRACE_ARC_H */

View File

@ -65,12 +65,10 @@ DECLARE_EVENT_CLASS(zfs_dprintf_class,
); );
/* END CSTYLED */ /* END CSTYLED */
/* BEGIN CSTYLED */
#define DEFINE_DPRINTF_EVENT(name) \ #define DEFINE_DPRINTF_EVENT(name) \
DEFINE_EVENT(zfs_dprintf_class, name, \ DEFINE_EVENT(zfs_dprintf_class, name, \
TP_PROTO(const char *msg), \ TP_PROTO(const char *msg), \
TP_ARGS(msg)) TP_ARGS(msg))
/* END CSTYLED */
DEFINE_DPRINTF_EVENT(zfs_zfs__dprintf); DEFINE_DPRINTF_EVENT(zfs_zfs__dprintf);
#endif /* _TRACE_DBGMSG_H */ #endif /* _TRACE_DBGMSG_H */

View File

@ -117,20 +117,16 @@ DECLARE_EVENT_CLASS(zfs_dbuf_state_class,
); );
/* END CSTYLED */ /* END CSTYLED */
/* BEGIN CSTYLED */
#define DEFINE_DBUF_EVENT(name) \ #define DEFINE_DBUF_EVENT(name) \
DEFINE_EVENT(zfs_dbuf_class, name, \ DEFINE_EVENT(zfs_dbuf_class, name, \
TP_PROTO(dmu_buf_impl_t *db, zio_t *zio), \ TP_PROTO(dmu_buf_impl_t *db, zio_t *zio), \
TP_ARGS(db, zio)) TP_ARGS(db, zio))
/* END CSTYLED */
DEFINE_DBUF_EVENT(zfs_blocked__read); DEFINE_DBUF_EVENT(zfs_blocked__read);
/* BEGIN CSTYLED */
#define DEFINE_DBUF_STATE_EVENT(name) \ #define DEFINE_DBUF_STATE_EVENT(name) \
DEFINE_EVENT(zfs_dbuf_state_class, name, \ DEFINE_EVENT(zfs_dbuf_state_class, name, \
TP_PROTO(dmu_buf_impl_t *db, const char *why), \ TP_PROTO(dmu_buf_impl_t *db, const char *why), \
TP_ARGS(db, why)) TP_ARGS(db, why))
/* END CSTYLED */
DEFINE_DBUF_STATE_EVENT(zfs_dbuf__state_change); DEFINE_DBUF_STATE_EVENT(zfs_dbuf__state_change);
/* BEGIN CSTYLED */ /* BEGIN CSTYLED */
@ -143,12 +139,10 @@ DECLARE_EVENT_CLASS(zfs_dbuf_evict_one_class,
); );
/* END CSTYLED */ /* END CSTYLED */
/* BEGIN CSTYLED */
#define DEFINE_DBUF_EVICT_ONE_EVENT(name) \ #define DEFINE_DBUF_EVICT_ONE_EVENT(name) \
DEFINE_EVENT(zfs_dbuf_evict_one_class, name, \ DEFINE_EVENT(zfs_dbuf_evict_one_class, name, \
TP_PROTO(dmu_buf_impl_t *db, multilist_sublist_t *mls), \ TP_PROTO(dmu_buf_impl_t *db, multilist_sublist_t *mls), \
TP_ARGS(db, mls)) TP_ARGS(db, mls))
/* END CSTYLED */
DEFINE_DBUF_EVICT_ONE_EVENT(zfs_dbuf__evict__one); DEFINE_DBUF_EVICT_ONE_EVENT(zfs_dbuf__evict__one);
#endif /* _TRACE_DBUF_H */ #endif /* _TRACE_DBUF_H */

View File

@ -81,12 +81,10 @@ DECLARE_EVENT_CLASS(zfs_delay_mintime_class,
); );
/* END CSTYLED */ /* END CSTYLED */
/* BEGIN CSTYLED */
#define DEFINE_DELAY_MINTIME_EVENT(name) \ #define DEFINE_DELAY_MINTIME_EVENT(name) \
DEFINE_EVENT(zfs_delay_mintime_class, name, \ DEFINE_EVENT(zfs_delay_mintime_class, name, \
TP_PROTO(dmu_tx_t *tx, uint64_t dirty, uint64_t min_tx_time), \ TP_PROTO(dmu_tx_t *tx, uint64_t dirty, uint64_t min_tx_time), \
TP_ARGS(tx, dirty, min_tx_time)) TP_ARGS(tx, dirty, min_tx_time))
/* END CSTYLED */
DEFINE_DELAY_MINTIME_EVENT(zfs_delay__mintime); DEFINE_DELAY_MINTIME_EVENT(zfs_delay__mintime);
/* BEGIN CSTYLED */ /* BEGIN CSTYLED */
@ -110,13 +108,11 @@ DECLARE_EVENT_CLASS(zfs_free_long_range_class,
); );
/* END CSTYLED */ /* END CSTYLED */
/* BEGIN CSTYLED */
#define DEFINE_FREE_LONG_RANGE_EVENT(name) \ #define DEFINE_FREE_LONG_RANGE_EVENT(name) \
DEFINE_EVENT(zfs_free_long_range_class, name, \ DEFINE_EVENT(zfs_free_long_range_class, name, \
TP_PROTO(uint64_t long_free_dirty_all_txgs, \ TP_PROTO(uint64_t long_free_dirty_all_txgs, \
uint64_t chunk_len, uint64_t txg), \ uint64_t chunk_len, uint64_t txg), \
TP_ARGS(long_free_dirty_all_txgs, chunk_len, txg)) TP_ARGS(long_free_dirty_all_txgs, chunk_len, txg))
/* END CSTYLED */
DEFINE_FREE_LONG_RANGE_EVENT(zfs_free__long__range); DEFINE_FREE_LONG_RANGE_EVENT(zfs_free__long__range);
#endif /* _TRACE_DMU_H */ #endif /* _TRACE_DMU_H */

View File

@ -105,12 +105,10 @@ DECLARE_EVENT_CLASS(zfs_dnode_move_class,
); );
/* END CSTYLED */ /* END CSTYLED */
/* BEGIN CSTYLED */
#define DEFINE_DNODE_MOVE_EVENT(name) \ #define DEFINE_DNODE_MOVE_EVENT(name) \
DEFINE_EVENT(zfs_dnode_move_class, name, \ DEFINE_EVENT(zfs_dnode_move_class, name, \
TP_PROTO(dnode_t *dn, int64_t refcount, uint32_t dbufs), \ TP_PROTO(dnode_t *dn, int64_t refcount, uint32_t dbufs), \
TP_ARGS(dn, refcount, dbufs)) TP_ARGS(dn, refcount, dbufs))
/* END CSTYLED */
DEFINE_DNODE_MOVE_EVENT(zfs_dnode__move); DEFINE_DNODE_MOVE_EVENT(zfs_dnode__move);
#endif /* _TRACE_DNODE_H */ #endif /* _TRACE_DNODE_H */

View File

@ -63,12 +63,10 @@ DECLARE_EVENT_CLASS(zfs_multilist_insert_remove_class,
); );
/* END CSTYLED */ /* END CSTYLED */
/* BEGIN CSTYLED */
#define DEFINE_MULTILIST_INSERT_REMOVE_EVENT(name) \ #define DEFINE_MULTILIST_INSERT_REMOVE_EVENT(name) \
DEFINE_EVENT(zfs_multilist_insert_remove_class, name, \ DEFINE_EVENT(zfs_multilist_insert_remove_class, name, \
TP_PROTO(multilist_t *ml, unsigned int sublist_idx, void *obj), \ TP_PROTO(multilist_t *ml, unsigned int sublist_idx, void *obj), \
TP_ARGS(ml, sublist_idx, obj)) TP_ARGS(ml, sublist_idx, obj))
/* END CSTYLED */
DEFINE_MULTILIST_INSERT_REMOVE_EVENT(zfs_multilist__insert); DEFINE_MULTILIST_INSERT_REMOVE_EVENT(zfs_multilist__insert);
DEFINE_MULTILIST_INSERT_REMOVE_EVENT(zfs_multilist__remove); DEFINE_MULTILIST_INSERT_REMOVE_EVENT(zfs_multilist__remove);

View File

@ -55,12 +55,10 @@ DECLARE_EVENT_CLASS(zfs_txg_class,
); );
/* END CSTYLED */ /* END CSTYLED */
/* BEGIN CSTYLED */
#define DEFINE_TXG_EVENT(name) \ #define DEFINE_TXG_EVENT(name) \
DEFINE_EVENT(zfs_txg_class, name, \ DEFINE_EVENT(zfs_txg_class, name, \
TP_PROTO(dsl_pool_t *dp, uint64_t txg), \ TP_PROTO(dsl_pool_t *dp, uint64_t txg), \
TP_ARGS(dp, txg)) TP_ARGS(dp, txg))
/* END CSTYLED */
DEFINE_TXG_EVENT(zfs_dsl_pool_sync__done); DEFINE_TXG_EVENT(zfs_dsl_pool_sync__done);
DEFINE_TXG_EVENT(zfs_txg__quiescing); DEFINE_TXG_EVENT(zfs_txg__quiescing);
DEFINE_TXG_EVENT(zfs_txg__opened); DEFINE_TXG_EVENT(zfs_txg__opened);

View File

@ -68,12 +68,10 @@ DECLARE_EVENT_CLASS(zfs_removing_class_3,
); );
/* END CSTYLED */ /* END CSTYLED */
/* BEGIN CSTYLED */
#define DEFINE_REMOVE_FREE_EVENT(name) \ #define DEFINE_REMOVE_FREE_EVENT(name) \
DEFINE_EVENT(zfs_removing_class_3, name, \ DEFINE_EVENT(zfs_removing_class_3, name, \
TP_PROTO(spa_t *spa, uint64_t offset, uint64_t size), \ TP_PROTO(spa_t *spa, uint64_t offset, uint64_t size), \
TP_ARGS(spa, offset, size)) TP_ARGS(spa, offset, size))
/* END CSTYLED */
DEFINE_REMOVE_FREE_EVENT(zfs_remove__free__synced); DEFINE_REMOVE_FREE_EVENT(zfs_remove__free__synced);
DEFINE_REMOVE_FREE_EVENT(zfs_remove__free__unvisited); DEFINE_REMOVE_FREE_EVENT(zfs_remove__free__unvisited);
@ -107,12 +105,10 @@ DECLARE_EVENT_CLASS(zfs_removing_class_4,
__entry->vdev_size, __entry->vdev_txg) __entry->vdev_size, __entry->vdev_txg)
); );
/* BEGIN CSTYLED */
#define DEFINE_REMOVE_FREE_EVENT_TXG(name) \ #define DEFINE_REMOVE_FREE_EVENT_TXG(name) \
DEFINE_EVENT(zfs_removing_class_4, name, \ DEFINE_EVENT(zfs_removing_class_4, name, \
TP_PROTO(spa_t *spa, uint64_t offset, uint64_t size,uint64_t txg), \ TP_PROTO(spa_t *spa, uint64_t offset, uint64_t size,uint64_t txg), \
TP_ARGS(spa, offset, size, txg)) TP_ARGS(spa, offset, size, txg))
/* END CSTYLED */
DEFINE_REMOVE_FREE_EVENT_TXG(zfs_remove__free__inflight); DEFINE_REMOVE_FREE_EVENT_TXG(zfs_remove__free__inflight);
#endif /* _TRACE_VDEV_H */ #endif /* _TRACE_VDEV_H */

View File

@ -170,14 +170,12 @@ DECLARE_EVENT_CLASS(zfs_zil_process_itx_class,
); );
/* END CSTYLED */ /* END CSTYLED */
/* BEGIN CSTYLED */
#define DEFINE_ZIL_PROCESS_ITX_EVENT(name) \ #define DEFINE_ZIL_PROCESS_ITX_EVENT(name) \
DEFINE_EVENT(zfs_zil_process_itx_class, name, \ DEFINE_EVENT(zfs_zil_process_itx_class, name, \
TP_PROTO(zilog_t *zilog, itx_t *itx), \ TP_PROTO(zilog_t *zilog, itx_t *itx), \
TP_ARGS(zilog, itx)) TP_ARGS(zilog, itx))
DEFINE_ZIL_PROCESS_ITX_EVENT(zfs_zil__process__commit__itx); DEFINE_ZIL_PROCESS_ITX_EVENT(zfs_zil__process__commit__itx);
DEFINE_ZIL_PROCESS_ITX_EVENT(zfs_zil__process__normal__itx); DEFINE_ZIL_PROCESS_ITX_EVENT(zfs_zil__process__normal__itx);
/* END CSTYLED */
/* /*
* Generic support for two argument tracepoints of the form: * Generic support for two argument tracepoints of the form:
@ -203,13 +201,11 @@ DECLARE_EVENT_CLASS(zfs_zil_commit_io_error_class,
ZILOG_TP_PRINTK_ARGS, ZCW_TP_PRINTK_ARGS) ZILOG_TP_PRINTK_ARGS, ZCW_TP_PRINTK_ARGS)
); );
/* BEGIN CSTYLED */
#define DEFINE_ZIL_COMMIT_IO_ERROR_EVENT(name) \ #define DEFINE_ZIL_COMMIT_IO_ERROR_EVENT(name) \
DEFINE_EVENT(zfs_zil_commit_io_error_class, name, \ DEFINE_EVENT(zfs_zil_commit_io_error_class, name, \
TP_PROTO(zilog_t *zilog, zil_commit_waiter_t *zcw), \ TP_PROTO(zilog_t *zilog, zil_commit_waiter_t *zcw), \
TP_ARGS(zilog, zcw)) TP_ARGS(zilog, zcw))
DEFINE_ZIL_COMMIT_IO_ERROR_EVENT(zfs_zil__commit__io__error); DEFINE_ZIL_COMMIT_IO_ERROR_EVENT(zfs_zil__commit__io__error);
/* END CSTYLED */
#endif /* _TRACE_ZIL_H */ #endif /* _TRACE_ZIL_H */

View File

@ -70,7 +70,7 @@ DECLARE_EVENT_CLASS(zfs_zrlock_class,
__entry->refcount, __entry->n) __entry->refcount, __entry->n)
#endif #endif
); );
/* END_CSTYLED */ /* END CSTYLED */
#define DEFINE_ZRLOCK_EVENT(name) \ #define DEFINE_ZRLOCK_EVENT(name) \
DEFINE_EVENT(zfs_zrlock_class, name, \ DEFINE_EVENT(zfs_zrlock_class, name, \

View File

@ -1185,11 +1185,9 @@ typedef struct vdev_stat {
uint64_t vs_noalloc; /* allocations halted? */ uint64_t vs_noalloc; /* allocations halted? */
} vdev_stat_t; } vdev_stat_t;
/* BEGIN CSTYLED */
#define VDEV_STAT_VALID(field, uint64_t_field_count) \ #define VDEV_STAT_VALID(field, uint64_t_field_count) \
((uint64_t_field_count * sizeof (uint64_t)) >= \ ((uint64_t_field_count * sizeof (uint64_t)) >= \
(offsetof(vdev_stat_t, field) + sizeof (((vdev_stat_t *)NULL)->field))) (offsetof(vdev_stat_t, field) + sizeof (((vdev_stat_t *)NULL)->field)))
/* END CSTYLED */
/* /*
* Extended stats * Extended stats

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: lauxlib.h,v 1.120.1.1 2013/04/12 18:48:47 roberto Exp $ ** $Id: lauxlib.h,v 1.120.1.1 2013/04/12 18:48:47 roberto Exp $
** Auxiliary functions for building Lua libraries ** Auxiliary functions for building Lua libraries
@ -171,5 +170,3 @@ LUALIB_API void (luaL_openlib) (lua_State *L, const char *libname,
#endif #endif
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: lua.h,v 1.285.1.4 2015/02/21 14:04:50 roberto Exp $ ** $Id: lua.h,v 1.285.1.4 2015/02/21 14:04:50 roberto Exp $
** Lua - A Scripting Language ** Lua - A Scripting Language
@ -442,4 +441,3 @@ struct lua_Debug {
#endif #endif
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: luaconf.h,v 1.176.1.2 2013/11/21 17:26:16 roberto Exp $ ** $Id: luaconf.h,v 1.176.1.2 2013/11/21 17:26:16 roberto Exp $
** Configuration file for Lua ** Configuration file for Lua
@ -555,4 +554,3 @@ extern int lcompat_hashnum(int64_t);
#endif #endif
#endif #endif
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: lualib.h,v 1.43.1.1 2013/04/12 18:48:47 roberto Exp $ ** $Id: lualib.h,v 1.43.1.1 2013/04/12 18:48:47 roberto Exp $
** Lua standard libraries ** Lua standard libraries
@ -54,4 +53,3 @@ LUALIB_API void (luaL_openlibs) (lua_State *L);
#endif #endif
/* END CSTYLED */

View File

@ -29,21 +29,22 @@
/* /*
* These are the void returning variants * These are the void returning variants
*/ */
/* BEGIN CSTYLED */
#define ATOMIC_INC(name, type) \ #define ATOMIC_INC(name, type) \
void atomic_inc_##name(volatile type *target) \ void atomic_inc_##name(volatile type *target) \
{ \ { \
(void) __atomic_add_fetch(target, 1, __ATOMIC_SEQ_CST); \ (void) __atomic_add_fetch(target, 1, __ATOMIC_SEQ_CST); \
} }
/* BEGIN CSTYLED */
ATOMIC_INC(8, uint8_t) ATOMIC_INC(8, uint8_t)
ATOMIC_INC(uchar, uchar_t)
ATOMIC_INC(16, uint16_t) ATOMIC_INC(16, uint16_t)
ATOMIC_INC(ushort, ushort_t)
ATOMIC_INC(32, uint32_t) ATOMIC_INC(32, uint32_t)
ATOMIC_INC(64, uint64_t)
ATOMIC_INC(uchar, uchar_t)
ATOMIC_INC(ushort, ushort_t)
ATOMIC_INC(uint, uint_t) ATOMIC_INC(uint, uint_t)
ATOMIC_INC(ulong, ulong_t) ATOMIC_INC(ulong, ulong_t)
ATOMIC_INC(64, uint64_t) /* END CSTYLED */
#define ATOMIC_DEC(name, type) \ #define ATOMIC_DEC(name, type) \
@ -52,14 +53,16 @@ ATOMIC_INC(64, uint64_t)
(void) __atomic_sub_fetch(target, 1, __ATOMIC_SEQ_CST); \ (void) __atomic_sub_fetch(target, 1, __ATOMIC_SEQ_CST); \
} }
/* BEGIN CSTYLED */
ATOMIC_DEC(8, uint8_t) ATOMIC_DEC(8, uint8_t)
ATOMIC_DEC(uchar, uchar_t)
ATOMIC_DEC(16, uint16_t) ATOMIC_DEC(16, uint16_t)
ATOMIC_DEC(ushort, ushort_t)
ATOMIC_DEC(32, uint32_t) ATOMIC_DEC(32, uint32_t)
ATOMIC_DEC(64, uint64_t)
ATOMIC_DEC(uchar, uchar_t)
ATOMIC_DEC(ushort, ushort_t)
ATOMIC_DEC(uint, uint_t) ATOMIC_DEC(uint, uint_t)
ATOMIC_DEC(ulong, ulong_t) ATOMIC_DEC(ulong, ulong_t)
ATOMIC_DEC(64, uint64_t) /* END CSTYLED */
#define ATOMIC_ADD(name, type1, type2) \ #define ATOMIC_ADD(name, type1, type2) \
@ -68,21 +71,23 @@ ATOMIC_DEC(64, uint64_t)
(void) __atomic_add_fetch(target, bits, __ATOMIC_SEQ_CST); \ (void) __atomic_add_fetch(target, bits, __ATOMIC_SEQ_CST); \
} }
ATOMIC_ADD(8, uint8_t, int8_t)
ATOMIC_ADD(char, uchar_t, signed char)
ATOMIC_ADD(16, uint16_t, int16_t)
ATOMIC_ADD(short, ushort_t, short)
ATOMIC_ADD(32, uint32_t, int32_t)
ATOMIC_ADD(int, uint_t, int)
ATOMIC_ADD(long, ulong_t, long)
ATOMIC_ADD(64, uint64_t, int64_t)
void void
atomic_add_ptr(volatile void *target, ssize_t bits) atomic_add_ptr(volatile void *target, ssize_t bits)
{ {
(void) __atomic_add_fetch((void **)target, bits, __ATOMIC_SEQ_CST); (void) __atomic_add_fetch((void **)target, bits, __ATOMIC_SEQ_CST);
} }
/* BEGIN CSTYLED */
ATOMIC_ADD(8, uint8_t, int8_t)
ATOMIC_ADD(16, uint16_t, int16_t)
ATOMIC_ADD(32, uint32_t, int32_t)
ATOMIC_ADD(64, uint64_t, int64_t)
ATOMIC_ADD(char, uchar_t, signed char)
ATOMIC_ADD(short, ushort_t, short)
ATOMIC_ADD(int, uint_t, int)
ATOMIC_ADD(long, ulong_t, long)
/* END CSTYLED */
#define ATOMIC_SUB(name, type1, type2) \ #define ATOMIC_SUB(name, type1, type2) \
void atomic_sub_##name(volatile type1 *target, type2 bits) \ void atomic_sub_##name(volatile type1 *target, type2 bits) \
@ -90,21 +95,23 @@ atomic_add_ptr(volatile void *target, ssize_t bits)
(void) __atomic_sub_fetch(target, bits, __ATOMIC_SEQ_CST); \ (void) __atomic_sub_fetch(target, bits, __ATOMIC_SEQ_CST); \
} }
ATOMIC_SUB(8, uint8_t, int8_t)
ATOMIC_SUB(char, uchar_t, signed char)
ATOMIC_SUB(16, uint16_t, int16_t)
ATOMIC_SUB(short, ushort_t, short)
ATOMIC_SUB(32, uint32_t, int32_t)
ATOMIC_SUB(int, uint_t, int)
ATOMIC_SUB(long, ulong_t, long)
ATOMIC_SUB(64, uint64_t, int64_t)
void void
atomic_sub_ptr(volatile void *target, ssize_t bits) atomic_sub_ptr(volatile void *target, ssize_t bits)
{ {
(void) __atomic_sub_fetch((void **)target, bits, __ATOMIC_SEQ_CST); (void) __atomic_sub_fetch((void **)target, bits, __ATOMIC_SEQ_CST);
} }
/* BEGIN CSTYLED */
ATOMIC_SUB(8, uint8_t, int8_t)
ATOMIC_SUB(16, uint16_t, int16_t)
ATOMIC_SUB(32, uint32_t, int32_t)
ATOMIC_SUB(64, uint64_t, int64_t)
ATOMIC_SUB(char, uchar_t, signed char)
ATOMIC_SUB(short, ushort_t, short)
ATOMIC_SUB(int, uint_t, int)
ATOMIC_SUB(long, ulong_t, long)
/* END CSTYLED */
#define ATOMIC_OR(name, type) \ #define ATOMIC_OR(name, type) \
void atomic_or_##name(volatile type *target, type bits) \ void atomic_or_##name(volatile type *target, type bits) \
@ -112,14 +119,16 @@ atomic_sub_ptr(volatile void *target, ssize_t bits)
(void) __atomic_or_fetch(target, bits, __ATOMIC_SEQ_CST); \ (void) __atomic_or_fetch(target, bits, __ATOMIC_SEQ_CST); \
} }
/* BEGIN CSTYLED */
ATOMIC_OR(8, uint8_t) ATOMIC_OR(8, uint8_t)
ATOMIC_OR(uchar, uchar_t)
ATOMIC_OR(16, uint16_t) ATOMIC_OR(16, uint16_t)
ATOMIC_OR(ushort, ushort_t)
ATOMIC_OR(32, uint32_t) ATOMIC_OR(32, uint32_t)
ATOMIC_OR(64, uint64_t)
ATOMIC_OR(uchar, uchar_t)
ATOMIC_OR(ushort, ushort_t)
ATOMIC_OR(uint, uint_t) ATOMIC_OR(uint, uint_t)
ATOMIC_OR(ulong, ulong_t) ATOMIC_OR(ulong, ulong_t)
ATOMIC_OR(64, uint64_t) /* END CSTYLED */
#define ATOMIC_AND(name, type) \ #define ATOMIC_AND(name, type) \
@ -128,14 +137,16 @@ ATOMIC_OR(64, uint64_t)
(void) __atomic_and_fetch(target, bits, __ATOMIC_SEQ_CST); \ (void) __atomic_and_fetch(target, bits, __ATOMIC_SEQ_CST); \
} }
/* BEGIN CSTYLED */
ATOMIC_AND(8, uint8_t) ATOMIC_AND(8, uint8_t)
ATOMIC_AND(uchar, uchar_t)
ATOMIC_AND(16, uint16_t) ATOMIC_AND(16, uint16_t)
ATOMIC_AND(ushort, ushort_t)
ATOMIC_AND(32, uint32_t) ATOMIC_AND(32, uint32_t)
ATOMIC_AND(64, uint64_t)
ATOMIC_AND(uchar, uchar_t)
ATOMIC_AND(ushort, ushort_t)
ATOMIC_AND(uint, uint_t) ATOMIC_AND(uint, uint_t)
ATOMIC_AND(ulong, ulong_t) ATOMIC_AND(ulong, ulong_t)
ATOMIC_AND(64, uint64_t) /* END CSTYLED */
/* /*
@ -148,14 +159,16 @@ ATOMIC_AND(64, uint64_t)
return (__atomic_add_fetch(target, 1, __ATOMIC_SEQ_CST)); \ return (__atomic_add_fetch(target, 1, __ATOMIC_SEQ_CST)); \
} }
/* BEGIN CSTYLED */
ATOMIC_INC_NV(8, uint8_t) ATOMIC_INC_NV(8, uint8_t)
ATOMIC_INC_NV(uchar, uchar_t)
ATOMIC_INC_NV(16, uint16_t) ATOMIC_INC_NV(16, uint16_t)
ATOMIC_INC_NV(ushort, ushort_t)
ATOMIC_INC_NV(32, uint32_t) ATOMIC_INC_NV(32, uint32_t)
ATOMIC_INC_NV(64, uint64_t)
ATOMIC_INC_NV(uchar, uchar_t)
ATOMIC_INC_NV(ushort, ushort_t)
ATOMIC_INC_NV(uint, uint_t) ATOMIC_INC_NV(uint, uint_t)
ATOMIC_INC_NV(ulong, ulong_t) ATOMIC_INC_NV(ulong, ulong_t)
ATOMIC_INC_NV(64, uint64_t) /* END CSTYLED */
#define ATOMIC_DEC_NV(name, type) \ #define ATOMIC_DEC_NV(name, type) \
@ -164,14 +177,16 @@ ATOMIC_INC_NV(64, uint64_t)
return (__atomic_sub_fetch(target, 1, __ATOMIC_SEQ_CST)); \ return (__atomic_sub_fetch(target, 1, __ATOMIC_SEQ_CST)); \
} }
/* BEGIN CSTYLED */
ATOMIC_DEC_NV(8, uint8_t) ATOMIC_DEC_NV(8, uint8_t)
ATOMIC_DEC_NV(uchar, uchar_t)
ATOMIC_DEC_NV(16, uint16_t) ATOMIC_DEC_NV(16, uint16_t)
ATOMIC_DEC_NV(ushort, ushort_t)
ATOMIC_DEC_NV(32, uint32_t) ATOMIC_DEC_NV(32, uint32_t)
ATOMIC_DEC_NV(64, uint64_t)
ATOMIC_DEC_NV(uchar, uchar_t)
ATOMIC_DEC_NV(ushort, ushort_t)
ATOMIC_DEC_NV(uint, uint_t) ATOMIC_DEC_NV(uint, uint_t)
ATOMIC_DEC_NV(ulong, ulong_t) ATOMIC_DEC_NV(ulong, ulong_t)
ATOMIC_DEC_NV(64, uint64_t) /* END CSTYLED */
#define ATOMIC_ADD_NV(name, type1, type2) \ #define ATOMIC_ADD_NV(name, type1, type2) \
@ -180,21 +195,23 @@ ATOMIC_DEC_NV(64, uint64_t)
return (__atomic_add_fetch(target, bits, __ATOMIC_SEQ_CST)); \ return (__atomic_add_fetch(target, bits, __ATOMIC_SEQ_CST)); \
} }
ATOMIC_ADD_NV(8, uint8_t, int8_t)
ATOMIC_ADD_NV(char, uchar_t, signed char)
ATOMIC_ADD_NV(16, uint16_t, int16_t)
ATOMIC_ADD_NV(short, ushort_t, short)
ATOMIC_ADD_NV(32, uint32_t, int32_t)
ATOMIC_ADD_NV(int, uint_t, int)
ATOMIC_ADD_NV(long, ulong_t, long)
ATOMIC_ADD_NV(64, uint64_t, int64_t)
void * void *
atomic_add_ptr_nv(volatile void *target, ssize_t bits) atomic_add_ptr_nv(volatile void *target, ssize_t bits)
{ {
return (__atomic_add_fetch((void **)target, bits, __ATOMIC_SEQ_CST)); return (__atomic_add_fetch((void **)target, bits, __ATOMIC_SEQ_CST));
} }
/* BEGIN CSTYLED */
ATOMIC_ADD_NV(8, uint8_t, int8_t)
ATOMIC_ADD_NV(16, uint16_t, int16_t)
ATOMIC_ADD_NV(32, uint32_t, int32_t)
ATOMIC_ADD_NV(64, uint64_t, int64_t)
ATOMIC_ADD_NV(char, uchar_t, signed char)
ATOMIC_ADD_NV(short, ushort_t, short)
ATOMIC_ADD_NV(int, uint_t, int)
ATOMIC_ADD_NV(long, ulong_t, long)
/* END CSTYLED */
#define ATOMIC_SUB_NV(name, type1, type2) \ #define ATOMIC_SUB_NV(name, type1, type2) \
type1 atomic_sub_##name##_nv(volatile type1 *target, type2 bits) \ type1 atomic_sub_##name##_nv(volatile type1 *target, type2 bits) \
@ -202,6 +219,13 @@ atomic_add_ptr_nv(volatile void *target, ssize_t bits)
return (__atomic_sub_fetch(target, bits, __ATOMIC_SEQ_CST)); \ return (__atomic_sub_fetch(target, bits, __ATOMIC_SEQ_CST)); \
} }
void *
atomic_sub_ptr_nv(volatile void *target, ssize_t bits)
{
return (__atomic_sub_fetch((void **)target, bits, __ATOMIC_SEQ_CST));
}
/* BEGIN CSTYLED */
ATOMIC_SUB_NV(8, uint8_t, int8_t) ATOMIC_SUB_NV(8, uint8_t, int8_t)
ATOMIC_SUB_NV(char, uchar_t, signed char) ATOMIC_SUB_NV(char, uchar_t, signed char)
ATOMIC_SUB_NV(16, uint16_t, int16_t) ATOMIC_SUB_NV(16, uint16_t, int16_t)
@ -210,12 +234,7 @@ ATOMIC_SUB_NV(32, uint32_t, int32_t)
ATOMIC_SUB_NV(int, uint_t, int) ATOMIC_SUB_NV(int, uint_t, int)
ATOMIC_SUB_NV(long, ulong_t, long) ATOMIC_SUB_NV(long, ulong_t, long)
ATOMIC_SUB_NV(64, uint64_t, int64_t) ATOMIC_SUB_NV(64, uint64_t, int64_t)
/* END CSTYLED */
void *
atomic_sub_ptr_nv(volatile void *target, ssize_t bits)
{
return (__atomic_sub_fetch((void **)target, bits, __ATOMIC_SEQ_CST));
}
#define ATOMIC_OR_NV(name, type) \ #define ATOMIC_OR_NV(name, type) \
@ -224,14 +243,16 @@ atomic_sub_ptr_nv(volatile void *target, ssize_t bits)
return (__atomic_or_fetch(target, bits, __ATOMIC_SEQ_CST)); \ return (__atomic_or_fetch(target, bits, __ATOMIC_SEQ_CST)); \
} }
/* BEGIN CSTYLED */
ATOMIC_OR_NV(8, uint8_t) ATOMIC_OR_NV(8, uint8_t)
ATOMIC_OR_NV(uchar, uchar_t)
ATOMIC_OR_NV(16, uint16_t) ATOMIC_OR_NV(16, uint16_t)
ATOMIC_OR_NV(ushort, ushort_t)
ATOMIC_OR_NV(32, uint32_t) ATOMIC_OR_NV(32, uint32_t)
ATOMIC_OR_NV(64, uint64_t)
ATOMIC_OR_NV(uchar, uchar_t)
ATOMIC_OR_NV(ushort, ushort_t)
ATOMIC_OR_NV(uint, uint_t) ATOMIC_OR_NV(uint, uint_t)
ATOMIC_OR_NV(ulong, ulong_t) ATOMIC_OR_NV(ulong, ulong_t)
ATOMIC_OR_NV(64, uint64_t) /* END CSTYLED */
#define ATOMIC_AND_NV(name, type) \ #define ATOMIC_AND_NV(name, type) \
@ -240,14 +261,16 @@ ATOMIC_OR_NV(64, uint64_t)
return (__atomic_and_fetch(target, bits, __ATOMIC_SEQ_CST)); \ return (__atomic_and_fetch(target, bits, __ATOMIC_SEQ_CST)); \
} }
/* BEGIN CSTYLED */
ATOMIC_AND_NV(8, uint8_t) ATOMIC_AND_NV(8, uint8_t)
ATOMIC_AND_NV(uchar, uchar_t)
ATOMIC_AND_NV(16, uint16_t) ATOMIC_AND_NV(16, uint16_t)
ATOMIC_AND_NV(ushort, ushort_t)
ATOMIC_AND_NV(32, uint32_t) ATOMIC_AND_NV(32, uint32_t)
ATOMIC_AND_NV(64, uint64_t)
ATOMIC_AND_NV(uchar, uchar_t)
ATOMIC_AND_NV(ushort, ushort_t)
ATOMIC_AND_NV(uint, uint_t) ATOMIC_AND_NV(uint, uint_t)
ATOMIC_AND_NV(ulong, ulong_t) ATOMIC_AND_NV(ulong, ulong_t)
ATOMIC_AND_NV(64, uint64_t) /* END CSTYLED */
/* /*
@ -268,15 +291,6 @@ ATOMIC_AND_NV(64, uint64_t)
return (exp); \ return (exp); \
} }
ATOMIC_CAS(8, uint8_t)
ATOMIC_CAS(uchar, uchar_t)
ATOMIC_CAS(16, uint16_t)
ATOMIC_CAS(ushort, ushort_t)
ATOMIC_CAS(32, uint32_t)
ATOMIC_CAS(uint, uint_t)
ATOMIC_CAS(ulong, ulong_t)
ATOMIC_CAS(64, uint64_t)
void * void *
atomic_cas_ptr(volatile void *target, void *exp, void *des) atomic_cas_ptr(volatile void *target, void *exp, void *des)
{ {
@ -286,6 +300,17 @@ atomic_cas_ptr(volatile void *target, void *exp, void *des)
return (exp); return (exp);
} }
/* BEGIN CSTYLED */
ATOMIC_CAS(8, uint8_t)
ATOMIC_CAS(16, uint16_t)
ATOMIC_CAS(32, uint32_t)
ATOMIC_CAS(64, uint64_t)
ATOMIC_CAS(uchar, uchar_t)
ATOMIC_CAS(ushort, ushort_t)
ATOMIC_CAS(uint, uint_t)
ATOMIC_CAS(ulong, ulong_t)
/* END CSTYLED */
/* /*
* Swap target and return old value * Swap target and return old value
@ -297,14 +322,15 @@ atomic_cas_ptr(volatile void *target, void *exp, void *des)
return (__atomic_exchange_n(target, bits, __ATOMIC_SEQ_CST)); \ return (__atomic_exchange_n(target, bits, __ATOMIC_SEQ_CST)); \
} }
/* BEGIN CSTYLED */
ATOMIC_SWAP(8, uint8_t) ATOMIC_SWAP(8, uint8_t)
ATOMIC_SWAP(uchar, uchar_t)
ATOMIC_SWAP(16, uint16_t) ATOMIC_SWAP(16, uint16_t)
ATOMIC_SWAP(ushort, ushort_t)
ATOMIC_SWAP(32, uint32_t) ATOMIC_SWAP(32, uint32_t)
ATOMIC_SWAP(64, uint64_t)
ATOMIC_SWAP(uchar, uchar_t)
ATOMIC_SWAP(ushort, ushort_t)
ATOMIC_SWAP(uint, uint_t) ATOMIC_SWAP(uint, uint_t)
ATOMIC_SWAP(ulong, ulong_t) ATOMIC_SWAP(ulong, ulong_t)
ATOMIC_SWAP(64, uint64_t)
/* END CSTYLED */ /* END CSTYLED */
void * void *

View File

@ -319,7 +319,6 @@ avl_rotation(avl_tree_t *tree, avl_node_t *node, int balance)
int which_child = AVL_XCHILD(node); int which_child = AVL_XCHILD(node);
int child_bal = AVL_XBALANCE(child); int child_bal = AVL_XBALANCE(child);
/* BEGIN CSTYLED */
/* /*
* case 1 : node is overly left heavy, the left child is balanced or * case 1 : node is overly left heavy, the left child is balanced or
* also left heavy. This requires the following rotation. * also left heavy. This requires the following rotation.
@ -345,7 +344,6 @@ avl_rotation(avl_tree_t *tree, avl_node_t *node, int balance)
* we detect this situation by noting that child's balance is not * we detect this situation by noting that child's balance is not
* right_heavy. * right_heavy.
*/ */
/* END CSTYLED */
if (child_bal != right_heavy) { if (child_bal != right_heavy) {
/* /*
@ -388,7 +386,6 @@ avl_rotation(avl_tree_t *tree, avl_node_t *node, int balance)
return (child_bal == 0); return (child_bal == 0);
} }
/* BEGIN CSTYLED */
/* /*
* case 2 : When node is left heavy, but child is right heavy we use * case 2 : When node is left heavy, but child is right heavy we use
* a different rotation. * a different rotation.
@ -420,7 +417,6 @@ avl_rotation(avl_tree_t *tree, avl_node_t *node, int balance)
* if gchild was right_heavy, then child is now left heavy * if gchild was right_heavy, then child is now left heavy
* else it is balanced * else it is balanced
*/ */
/* END CSTYLED */
gchild = child->avl_child[right]; gchild = child->avl_child[right];
gleft = gchild->avl_child[left]; gleft = gchild->avl_child[left];
gright = gchild->avl_child[right]; gright = gchild->avl_child[right];

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: lapi.c,v 2.171.1.1 2013/04/12 18:48:47 roberto Exp $ ** $Id: lapi.c,v 2.171.1.1 2013/04/12 18:48:47 roberto Exp $
** Lua API ** Lua API
@ -1296,7 +1295,6 @@ module_init(lua_init);
module_exit(lua_fini); module_exit(lua_fini);
#endif #endif
/* END CSTYLED */
ZFS_MODULE_DESCRIPTION("Lua Interpreter for ZFS"); ZFS_MODULE_DESCRIPTION("Lua Interpreter for ZFS");
ZFS_MODULE_AUTHOR("Lua.org"); ZFS_MODULE_AUTHOR("Lua.org");

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: lapi.h,v 2.7.1.1 2013/04/12 18:48:47 roberto Exp $ ** $Id: lapi.h,v 2.7.1.1 2013/04/12 18:48:47 roberto Exp $
** Auxiliary functions from Lua API ** Auxiliary functions from Lua API
@ -23,4 +22,3 @@
#endif #endif
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: lauxlib.c,v 1.248.1.1 2013/04/12 18:48:47 roberto Exp $ ** $Id: lauxlib.c,v 1.248.1.1 2013/04/12 18:48:47 roberto Exp $
** Auxiliary functions for building Lua libraries ** Auxiliary functions for building Lua libraries
@ -797,4 +796,3 @@ EXPORT_SYMBOL(luaL_newmetatable);
EXPORT_SYMBOL(luaL_traceback); EXPORT_SYMBOL(luaL_traceback);
#endif #endif
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: lbaselib.c,v 1.276.1.1 2013/04/12 18:48:47 roberto Exp $ ** $Id: lbaselib.c,v 1.276.1.1 2013/04/12 18:48:47 roberto Exp $
** Basic library ** Basic library
@ -293,4 +292,3 @@ LUAMOD_API int luaopen_base (lua_State *L) {
EXPORT_SYMBOL(luaopen_base); EXPORT_SYMBOL(luaopen_base);
#endif #endif
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: lcode.c,v 2.62.1.1 2013/04/12 18:48:47 roberto Exp $ ** $Id: lcode.c,v 2.62.1.1 2013/04/12 18:48:47 roberto Exp $
** Code generator for Lua ** Code generator for Lua
@ -885,4 +884,3 @@ void luaK_setlist (FuncState *fs, int base, int nelems, int tostore) {
luaX_syntaxerror(fs->ls, "constructor too long"); luaX_syntaxerror(fs->ls, "constructor too long");
fs->freereg = base + 1; /* free registers with list values */ fs->freereg = base + 1; /* free registers with list values */
} }
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: lcode.h,v 1.58.1.1 2013/04/12 18:48:47 roberto Exp $ ** $Id: lcode.h,v 1.58.1.1 2013/04/12 18:48:47 roberto Exp $
** Code generator for Lua ** Code generator for Lua
@ -82,4 +81,3 @@ LUAI_FUNC void luaK_setlist (FuncState *fs, int base, int nelems, int tostore);
#endif #endif
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: lcorolib.c,v 1.5.1.1 2013/04/12 18:48:47 roberto Exp $ ** $Id: lcorolib.c,v 1.5.1.1 2013/04/12 18:48:47 roberto Exp $
** Coroutine Library ** Coroutine Library
@ -156,4 +155,3 @@ LUAMOD_API int luaopen_coroutine (lua_State *L) {
EXPORT_SYMBOL(luaopen_coroutine); EXPORT_SYMBOL(luaopen_coroutine);
#endif #endif
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: lctype.c,v 1.11.1.1 2013/04/12 18:48:47 roberto Exp $ ** $Id: lctype.c,v 1.11.1.1 2013/04/12 18:48:47 roberto Exp $
** 'ctype' functions for Lua ** 'ctype' functions for Lua
@ -49,4 +48,3 @@ LUAI_DDEF const lu_byte luai_ctype_[UCHAR_MAX + 2] = {
}; };
#endif /* } */ #endif /* } */
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: lctype.h,v 1.12.1.1 2013/04/12 18:48:47 roberto Exp $ ** $Id: lctype.h,v 1.12.1.1 2013/04/12 18:48:47 roberto Exp $
** 'ctype' functions for Lua ** 'ctype' functions for Lua
@ -91,4 +90,3 @@ LUAI_DDEC const lu_byte luai_ctype_[UCHAR_MAX + 2];
#endif /* } */ #endif /* } */
#endif #endif
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: ldebug.c,v 2.90.1.4 2015/02/19 17:05:13 roberto Exp $ ** $Id: ldebug.c,v 2.90.1.4 2015/02/19 17:05:13 roberto Exp $
** Debug Interface ** Debug Interface
@ -605,4 +604,3 @@ l_noret luaG_runerror (lua_State *L, const char *fmt, ...) {
luaG_errormsg(L); luaG_errormsg(L);
L->runerror--; L->runerror--;
} }
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: ldebug.h,v 2.7.1.1 2013/04/12 18:48:47 roberto Exp $ ** $Id: ldebug.h,v 2.7.1.1 2013/04/12 18:48:47 roberto Exp $
** Auxiliary functions from Debug Interface module ** Auxiliary functions from Debug Interface module
@ -33,4 +32,3 @@ LUAI_FUNC l_noret luaG_runerror (lua_State *L, const char *fmt, ...);
LUAI_FUNC l_noret luaG_errormsg (lua_State *L); LUAI_FUNC l_noret luaG_errormsg (lua_State *L);
#endif #endif
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: ldo.c,v 2.108.1.3 2013/11/08 18:22:50 roberto Exp $ ** $Id: ldo.c,v 2.108.1.3 2013/11/08 18:22:50 roberto Exp $
** Stack and Call structure of Lua ** Stack and Call structure of Lua
@ -746,4 +745,3 @@ int luaD_protectedparser (lua_State *L, ZIO *z, const char *name,
L->nny--; L->nny--;
return status; return status;
} }
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: ldo.h,v 2.20.1.1 2013/04/12 18:48:47 roberto Exp $ ** $Id: ldo.h,v 2.20.1.1 2013/04/12 18:48:47 roberto Exp $
** Stack and Call structure of Lua ** Stack and Call structure of Lua
@ -44,4 +43,3 @@ LUAI_FUNC l_noret luaD_throw (lua_State *L, int errcode);
LUAI_FUNC int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud); LUAI_FUNC int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud);
#endif #endif
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: lfunc.c,v 2.30.1.1 2013/04/12 18:48:47 roberto Exp $ ** $Id: lfunc.c,v 2.30.1.1 2013/04/12 18:48:47 roberto Exp $
** Auxiliary functions to manipulate prototypes and closures ** Auxiliary functions to manipulate prototypes and closures
@ -157,4 +156,3 @@ const char *luaF_getlocalname (const Proto *f, int local_number, int pc) {
} }
return NULL; /* not found */ return NULL; /* not found */
} }
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: lfunc.h,v 2.8.1.1 2013/04/12 18:48:47 roberto Exp $ ** $Id: lfunc.h,v 2.8.1.1 2013/04/12 18:48:47 roberto Exp $
** Auxiliary functions to manipulate prototypes and closures ** Auxiliary functions to manipulate prototypes and closures
@ -32,4 +31,3 @@ LUAI_FUNC const char *luaF_getlocalname (const Proto *func, int local_number,
#endif #endif
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: lgc.c,v 2.140.1.3 2014/09/01 16:55:08 roberto Exp $ ** $Id: lgc.c,v 2.140.1.3 2014/09/01 16:55:08 roberto Exp $
** Garbage Collector ** Garbage Collector
@ -1215,4 +1214,3 @@ void luaC_fullgc (lua_State *L, int isemergency) {
} }
/* }====================================================== */ /* }====================================================== */
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: lgc.h,v 2.58.1.1 2013/04/12 18:48:47 roberto Exp $ ** $Id: lgc.h,v 2.58.1.1 2013/04/12 18:48:47 roberto Exp $
** Garbage Collector ** Garbage Collector
@ -156,4 +155,3 @@ LUAI_FUNC void luaC_checkupvalcolor (global_State *g, UpVal *uv);
LUAI_FUNC void luaC_changemode (lua_State *L, int mode); LUAI_FUNC void luaC_changemode (lua_State *L, int mode);
#endif #endif
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: llex.c,v 2.63.1.3 2015/02/09 17:56:34 roberto Exp $ ** $Id: llex.c,v 2.63.1.3 2015/02/09 17:56:34 roberto Exp $
** Lexical Analyzer ** Lexical Analyzer
@ -528,4 +527,3 @@ int luaX_lookahead (LexState *ls) {
ls->lookahead.token = llex(ls, &ls->lookahead.seminfo); ls->lookahead.token = llex(ls, &ls->lookahead.seminfo);
return ls->lookahead.token; return ls->lookahead.token;
} }
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: llex.h,v 1.72.1.1 2013/04/12 18:48:47 roberto Exp $ ** $Id: llex.h,v 1.72.1.1 2013/04/12 18:48:47 roberto Exp $
** Lexical Analyzer ** Lexical Analyzer
@ -80,4 +79,3 @@ LUAI_FUNC const char *luaX_token2str (LexState *ls, int token);
#endif #endif
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: llimits.h,v 1.103.1.1 2013/04/12 18:48:47 roberto Exp $ ** $Id: llimits.h,v 1.103.1.1 2013/04/12 18:48:47 roberto Exp $
** Limits, basic types, and some other `installation-dependent' definitions ** Limits, basic types, and some other `installation-dependent' definitions
@ -311,4 +310,3 @@ union luai_Cast { double l_d; LUA_INT32 l_p[2]; };
#endif #endif
#endif #endif
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: lmem.c,v 1.84.1.1 2013/04/12 18:48:47 roberto Exp $ ** $Id: lmem.c,v 1.84.1.1 2013/04/12 18:48:47 roberto Exp $
** Interface to Memory Manager ** Interface to Memory Manager
@ -95,4 +94,3 @@ void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) {
g->GCdebt = (g->GCdebt + nsize) - realosize; g->GCdebt = (g->GCdebt + nsize) - realosize;
return newblock; return newblock;
} }
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: lmem.h,v 1.40.1.1 2013/04/12 18:48:47 roberto Exp $ ** $Id: lmem.h,v 1.40.1.1 2013/04/12 18:48:47 roberto Exp $
** Interface to Memory Manager ** Interface to Memory Manager
@ -53,4 +52,3 @@ LUAI_FUNC void *luaM_growaux_ (lua_State *L, void *block, int *size,
const char *what); const char *what);
#endif #endif
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: lobject.c,v 2.58.1.1 2013/04/12 18:48:47 roberto Exp $ ** $Id: lobject.c,v 2.58.1.1 2013/04/12 18:48:47 roberto Exp $
** Some generic functions over Lua objects ** Some generic functions over Lua objects
@ -279,4 +278,3 @@ void luaO_chunkid (char *out, const char *source, size_t bufflen) {
memcpy(out, POS, (LL(POS) + 1) * sizeof(char)); memcpy(out, POS, (LL(POS) + 1) * sizeof(char));
} }
} }
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: lobject.h,v 2.71.1.2 2014/05/07 14:14:58 roberto Exp $ ** $Id: lobject.h,v 2.71.1.2 2014/05/07 14:14:58 roberto Exp $
** Type definitions for Lua objects ** Type definitions for Lua objects
@ -602,4 +601,3 @@ LUAI_FUNC void luaO_chunkid (char *out, const char *source, size_t len);
#endif #endif
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: lopcodes.c,v 1.49.1.1 2013/04/12 18:48:47 roberto Exp $ ** $Id: lopcodes.c,v 1.49.1.1 2013/04/12 18:48:47 roberto Exp $
** Opcodes for Lua virtual machine ** Opcodes for Lua virtual machine
@ -105,4 +104,3 @@ LUAI_DDEF const lu_byte luaP_opmodes[NUM_OPCODES] = {
,opmode(0, 1, OpArgU, OpArgN, iABC) /* OP_VARARG */ ,opmode(0, 1, OpArgU, OpArgN, iABC) /* OP_VARARG */
,opmode(0, 0, OpArgU, OpArgU, iAx) /* OP_EXTRAARG */ ,opmode(0, 0, OpArgU, OpArgU, iAx) /* OP_EXTRAARG */
}; };
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: lopcodes.h,v 1.142.1.2 2014/10/20 18:32:09 roberto Exp $ ** $Id: lopcodes.h,v 1.142.1.2 2014/10/20 18:32:09 roberto Exp $
** Opcodes for Lua virtual machine ** Opcodes for Lua virtual machine
@ -287,4 +286,3 @@ LUAI_DDEC const char *const luaP_opnames[NUM_OPCODES+1]; /* opcode names */
#endif #endif
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: lparser.c,v 2.130.1.1 2013/04/12 18:48:47 roberto Exp $ ** $Id: lparser.c,v 2.130.1.1 2013/04/12 18:48:47 roberto Exp $
** Lua Parser ** Lua Parser
@ -1640,4 +1639,3 @@ Closure *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff,
lua_assert(dyd->actvar.n == 0 && dyd->gt.n == 0 && dyd->label.n == 0); lua_assert(dyd->actvar.n == 0 && dyd->gt.n == 0 && dyd->label.n == 0);
return cl; /* it's on the stack too */ return cl; /* it's on the stack too */
} }
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: lparser.h,v 1.70.1.1 2013/04/12 18:48:47 roberto Exp $ ** $Id: lparser.h,v 1.70.1.1 2013/04/12 18:48:47 roberto Exp $
** Lua Parser ** Lua Parser
@ -118,4 +117,3 @@ LUAI_FUNC Closure *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff,
#endif #endif
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: lstate.c,v 2.99.1.2 2013/11/08 17:45:31 roberto Exp $ ** $Id: lstate.c,v 2.99.1.2 2013/11/08 17:45:31 roberto Exp $
** Global State ** Global State
@ -317,4 +316,3 @@ LUA_API void lua_close (lua_State *L) {
lua_lock(L); lua_lock(L);
close_state(L); close_state(L);
} }
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: lstate.h,v 2.82.1.1 2013/04/12 18:48:47 roberto Exp $ ** $Id: lstate.h,v 2.82.1.1 2013/04/12 18:48:47 roberto Exp $
** Global State ** Global State
@ -227,4 +226,3 @@ LUAI_FUNC void luaE_freeCI (lua_State *L);
#endif #endif
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: lstring.c,v 2.26.1.1 2013/04/12 18:48:47 roberto Exp $ ** $Id: lstring.c,v 2.26.1.1 2013/04/12 18:48:47 roberto Exp $
** String table (keeps all strings handled by Lua) ** String table (keeps all strings handled by Lua)
@ -183,4 +182,3 @@ Udata *luaS_newudata (lua_State *L, size_t s, Table *e) {
u->uv.env = e; u->uv.env = e;
return u; return u;
} }
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: lstring.h,v 1.49.1.1 2013/04/12 18:48:47 roberto Exp $ ** $Id: lstring.h,v 1.49.1.1 2013/04/12 18:48:47 roberto Exp $
** String table (keep all strings handled by Lua) ** String table (keep all strings handled by Lua)
@ -45,4 +44,3 @@ LUAI_FUNC TString *luaS_new (lua_State *L, const char *str);
#endif #endif
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: lstrlib.c,v 1.178.1.1 2013/04/12 18:48:47 roberto Exp $ ** $Id: lstrlib.c,v 1.178.1.1 2013/04/12 18:48:47 roberto Exp $
** Standard library for string operations and pattern-matching ** Standard library for string operations and pattern-matching
@ -1037,4 +1036,3 @@ LUAMOD_API int luaopen_string (lua_State *L) {
EXPORT_SYMBOL(luaopen_string); EXPORT_SYMBOL(luaopen_string);
#endif #endif
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: ltable.c,v 2.72.1.1 2013/04/12 18:48:47 roberto Exp $ ** $Id: ltable.c,v 2.72.1.1 2013/04/12 18:48:47 roberto Exp $
** Lua tables (hash) ** Lua tables (hash)
@ -589,4 +588,3 @@ Node *luaH_mainposition (const Table *t, const TValue *key) {
int luaH_isdummy (Node *n) { return isdummy(n); } int luaH_isdummy (Node *n) { return isdummy(n); }
#endif #endif
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: ltable.h,v 2.16.1.2 2013/08/30 15:49:41 roberto Exp $ ** $Id: ltable.h,v 2.16.1.2 2013/08/30 15:49:41 roberto Exp $
** Lua tables (hash) ** Lua tables (hash)
@ -44,4 +43,3 @@ LUAI_FUNC int luaH_isdummy (Node *n);
#endif #endif
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: ltablib.c,v 1.65.1.2 2014/05/07 16:32:55 roberto Exp $ ** $Id: ltablib.c,v 1.65.1.2 2014/05/07 16:32:55 roberto Exp $
** Library for Table Manipulation ** Library for Table Manipulation
@ -286,4 +285,3 @@ LUAMOD_API int luaopen_table (lua_State *L) {
EXPORT_SYMBOL(luaopen_table); EXPORT_SYMBOL(luaopen_table);
#endif #endif
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: ltm.c,v 2.14.1.1 2013/04/12 18:48:47 roberto Exp $ ** $Id: ltm.c,v 2.14.1.1 2013/04/12 18:48:47 roberto Exp $
** Tag methods ** Tag methods
@ -73,4 +72,3 @@ const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o, TMS event) {
} }
return (mt ? luaH_getstr(mt, G(L)->tmname[event]) : luaO_nilobject); return (mt ? luaH_getstr(mt, G(L)->tmname[event]) : luaO_nilobject);
} }
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: ltm.h,v 2.11.1.1 2013/04/12 18:48:47 roberto Exp $ ** $Id: ltm.h,v 2.11.1.1 2013/04/12 18:48:47 roberto Exp $
** Tag methods ** Tag methods
@ -56,4 +55,3 @@ LUAI_FUNC const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o,
LUAI_FUNC void luaT_init (lua_State *L); LUAI_FUNC void luaT_init (lua_State *L);
#endif #endif
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: lvm.c,v 2.155.1.1 2013/04/12 18:48:47 roberto Exp $ ** $Id: lvm.c,v 2.155.1.1 2013/04/12 18:48:47 roberto Exp $
** Lua virtual machine ** Lua virtual machine
@ -928,5 +927,3 @@ void luaV_execute (lua_State *L) {
} }
} }
} }
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: lvm.h,v 2.18.1.1 2013/04/12 18:48:47 roberto Exp $ ** $Id: lvm.h,v 2.18.1.1 2013/04/12 18:48:47 roberto Exp $
** Lua virtual machine ** Lua virtual machine
@ -43,4 +42,3 @@ LUAI_FUNC void luaV_arith (lua_State *L, StkId ra, const TValue *rb,
LUAI_FUNC void luaV_objlen (lua_State *L, StkId ra, const TValue *rb); LUAI_FUNC void luaV_objlen (lua_State *L, StkId ra, const TValue *rb);
#endif #endif
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: lzio.c,v 1.35.1.1 2013/04/12 18:48:47 roberto Exp $ ** $Id: lzio.c,v 1.35.1.1 2013/04/12 18:48:47 roberto Exp $
** Buffered streams ** Buffered streams
@ -71,4 +70,3 @@ char *luaZ_openspace (lua_State *L, Mbuffer *buff, size_t n) {
} }
return buff->buffer; return buff->buffer;
} }
/* END CSTYLED */

View File

@ -1,4 +1,3 @@
/* BEGIN CSTYLED */
/* /*
** $Id: lzio.h,v 1.26.1.1 2013/04/12 18:48:47 roberto Exp $ ** $Id: lzio.h,v 1.26.1.1 2013/04/12 18:48:47 roberto Exp $
** Buffered streams ** Buffered streams
@ -64,4 +63,3 @@ struct Zio {
LUAI_FUNC int luaZ_fill (ZIO *z); LUAI_FUNC int luaZ_fill (ZIO *z);
#endif #endif
/* END CSTYLED */

View File

@ -93,12 +93,10 @@ sysctl_vfs_zfs_arc_free_target(SYSCTL_HANDLER_ARGS)
return (0); return (0);
} }
SYSCTL_DECL(_vfs_zfs); SYSCTL_DECL(_vfs_zfs);
/* BEGIN CSTYLED */
SYSCTL_PROC(_vfs_zfs, OID_AUTO, arc_free_target, SYSCTL_PROC(_vfs_zfs, OID_AUTO, arc_free_target,
CTLTYPE_UINT | CTLFLAG_MPSAFE | CTLFLAG_RW, 0, sizeof (uint_t), CTLTYPE_UINT | CTLFLAG_MPSAFE | CTLFLAG_RW, 0, sizeof (uint_t),
sysctl_vfs_zfs_arc_free_target, "IU", sysctl_vfs_zfs_arc_free_target, "IU",
"Desired number of free pages below which ARC triggers reclaim"); "Desired number of free pages below which ARC triggers reclaim");
/* END CSTYLED */
int64_t int64_t
arc_available_memory(void) arc_available_memory(void)

View File

@ -92,12 +92,13 @@ __FBSDID("$FreeBSD$");
#include <sys/dsl_pool.h> #include <sys/dsl_pool.h>
/* BEGIN CSTYLED */
SYSCTL_DECL(_vfs_zfs); SYSCTL_DECL(_vfs_zfs);
SYSCTL_NODE(_vfs_zfs, OID_AUTO, arc, CTLFLAG_RW, 0, "ZFS adaptive replacement cache"); SYSCTL_NODE(_vfs_zfs, OID_AUTO, arc, CTLFLAG_RW, 0,
"ZFS adaptive replacement cache");
SYSCTL_NODE(_vfs_zfs, OID_AUTO, condense, CTLFLAG_RW, 0, "ZFS condense"); SYSCTL_NODE(_vfs_zfs, OID_AUTO, condense, CTLFLAG_RW, 0, "ZFS condense");
SYSCTL_NODE(_vfs_zfs, OID_AUTO, dbuf, CTLFLAG_RW, 0, "ZFS disk buf cache"); SYSCTL_NODE(_vfs_zfs, OID_AUTO, dbuf, CTLFLAG_RW, 0, "ZFS disk buf cache");
SYSCTL_NODE(_vfs_zfs, OID_AUTO, dbuf_cache, CTLFLAG_RW, 0, "ZFS disk buf cache"); SYSCTL_NODE(_vfs_zfs, OID_AUTO, dbuf_cache, CTLFLAG_RW, 0,
"ZFS disk buf cache");
SYSCTL_NODE(_vfs_zfs, OID_AUTO, deadman, CTLFLAG_RW, 0, "ZFS deadman"); SYSCTL_NODE(_vfs_zfs, OID_AUTO, deadman, CTLFLAG_RW, 0, "ZFS deadman");
SYSCTL_NODE(_vfs_zfs, OID_AUTO, dedup, CTLFLAG_RW, 0, "ZFS dedup"); SYSCTL_NODE(_vfs_zfs, OID_AUTO, dedup, CTLFLAG_RW, 0, "ZFS dedup");
SYSCTL_NODE(_vfs_zfs, OID_AUTO, l2arc, CTLFLAG_RW, 0, "ZFS l2arc"); SYSCTL_NODE(_vfs_zfs, OID_AUTO, l2arc, CTLFLAG_RW, 0, "ZFS l2arc");
@ -105,7 +106,8 @@ SYSCTL_NODE(_vfs_zfs, OID_AUTO, livelist, CTLFLAG_RW, 0, "ZFS livelist");
SYSCTL_NODE(_vfs_zfs, OID_AUTO, lua, CTLFLAG_RW, 0, "ZFS lua"); SYSCTL_NODE(_vfs_zfs, OID_AUTO, lua, CTLFLAG_RW, 0, "ZFS lua");
SYSCTL_NODE(_vfs_zfs, OID_AUTO, metaslab, CTLFLAG_RW, 0, "ZFS metaslab"); SYSCTL_NODE(_vfs_zfs, OID_AUTO, metaslab, CTLFLAG_RW, 0, "ZFS metaslab");
SYSCTL_NODE(_vfs_zfs, OID_AUTO, mg, CTLFLAG_RW, 0, "ZFS metaslab group"); SYSCTL_NODE(_vfs_zfs, OID_AUTO, mg, CTLFLAG_RW, 0, "ZFS metaslab group");
SYSCTL_NODE(_vfs_zfs, OID_AUTO, multihost, CTLFLAG_RW, 0, "ZFS multihost protection"); SYSCTL_NODE(_vfs_zfs, OID_AUTO, multihost, CTLFLAG_RW, 0,
"ZFS multihost protection");
SYSCTL_NODE(_vfs_zfs, OID_AUTO, prefetch, CTLFLAG_RW, 0, "ZFS prefetch"); SYSCTL_NODE(_vfs_zfs, OID_AUTO, prefetch, CTLFLAG_RW, 0, "ZFS prefetch");
SYSCTL_NODE(_vfs_zfs, OID_AUTO, reconstruct, CTLFLAG_RW, 0, "ZFS reconstruct"); SYSCTL_NODE(_vfs_zfs, OID_AUTO, reconstruct, CTLFLAG_RW, 0, "ZFS reconstruct");
SYSCTL_NODE(_vfs_zfs, OID_AUTO, recv, CTLFLAG_RW, 0, "ZFS receive"); SYSCTL_NODE(_vfs_zfs, OID_AUTO, recv, CTLFLAG_RW, 0, "ZFS receive");
@ -204,6 +206,7 @@ extern int l2arc_noprefetch; /* don't cache prefetch bufs */
extern int l2arc_feed_again; /* turbo warmup */ extern int l2arc_feed_again; /* turbo warmup */
extern int l2arc_norw; /* no reads during writes */ extern int l2arc_norw; /* no reads during writes */
/* BEGIN CSTYLED */
SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, l2arc_write_max, CTLFLAG_RW, SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, l2arc_write_max, CTLFLAG_RW,
&l2arc_write_max, 0, "max write size (LEGACY)"); &l2arc_write_max, 0, "max write size (LEGACY)");
SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, l2arc_write_boost, CTLFLAG_RW, SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, l2arc_write_boost, CTLFLAG_RW,
@ -221,11 +224,6 @@ SYSCTL_INT(_vfs_zfs, OID_AUTO, l2arc_feed_again, CTLFLAG_RW,
&l2arc_feed_again, 0, "turbo warmup (LEGACY)"); &l2arc_feed_again, 0, "turbo warmup (LEGACY)");
SYSCTL_INT(_vfs_zfs, OID_AUTO, l2arc_norw, CTLFLAG_RW, SYSCTL_INT(_vfs_zfs, OID_AUTO, l2arc_norw, CTLFLAG_RW,
&l2arc_norw, 0, "no reads during writes (LEGACY)"); &l2arc_norw, 0, "no reads during writes (LEGACY)");
#if 0
extern int zfs_compressed_arc_enabled;
SYSCTL_INT(_vfs_zfs, OID_AUTO, compressed_arc_enabled, CTLFLAG_RW,
&zfs_compressed_arc_enabled, 1, "compressed arc buffers (LEGACY)");
#endif
SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, anon_size, CTLFLAG_RD, SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, anon_size, CTLFLAG_RD,
&ARC_anon.arcs_size.rc_count, 0, "size of anonymous state"); &ARC_anon.arcs_size.rc_count, 0, "size of anonymous state");
@ -274,6 +272,7 @@ SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, mfu_ghost_data_esize, CTLFLAG_RD,
SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, l2c_only_size, CTLFLAG_RD, SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, l2c_only_size, CTLFLAG_RD,
&ARC_l2c_only.arcs_size.rc_count, 0, "size of mru state"); &ARC_l2c_only.arcs_size.rc_count, 0, "size of mru state");
/* END CSTYLED */
static int static int
sysctl_vfs_zfs_arc_no_grow_shift(SYSCTL_HANDLER_ARGS) sysctl_vfs_zfs_arc_no_grow_shift(SYSCTL_HANDLER_ARGS)
@ -325,6 +324,7 @@ param_set_arc_int(SYSCTL_HANDLER_ARGS)
return (0); return (0);
} }
/* BEGIN CSTYLED */
SYSCTL_PROC(_vfs_zfs, OID_AUTO, arc_min, SYSCTL_PROC(_vfs_zfs, OID_AUTO, arc_min,
CTLTYPE_ULONG | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, CTLTYPE_ULONG | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
&zfs_arc_min, sizeof (zfs_arc_min), param_set_arc_min, "LU", &zfs_arc_min, sizeof (zfs_arc_min), param_set_arc_min, "LU",
@ -333,6 +333,7 @@ SYSCTL_PROC(_vfs_zfs, OID_AUTO, arc_max,
CTLTYPE_ULONG | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, CTLTYPE_ULONG | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
&zfs_arc_max, sizeof (zfs_arc_max), param_set_arc_max, "LU", &zfs_arc_max, sizeof (zfs_arc_max), param_set_arc_max, "LU",
"max arc size (LEGACY)"); "max arc size (LEGACY)");
/* END CSTYLED */
/* dbuf.c */ /* dbuf.c */
@ -349,9 +350,11 @@ SYSCTL_UINT(_vfs_zfs_zfetch, OID_AUTO, max_distance, CTLFLAG_RWTUN,
/* max bytes to prefetch indirects for per stream (default 64MB) */ /* max bytes to prefetch indirects for per stream (default 64MB) */
extern uint32_t zfetch_max_idistance; extern uint32_t zfetch_max_idistance;
/* BEGIN CSTYLED */
SYSCTL_UINT(_vfs_zfs_zfetch, OID_AUTO, max_idistance, CTLFLAG_RWTUN, SYSCTL_UINT(_vfs_zfs_zfetch, OID_AUTO, max_idistance, CTLFLAG_RWTUN,
&zfetch_max_idistance, 0, &zfetch_max_idistance, 0,
"Max bytes to prefetch indirects for per stream (LEGACY)"); "Max bytes to prefetch indirects for per stream (LEGACY)");
/* END CSTYLED */
/* dsl_pool.c */ /* dsl_pool.c */
@ -369,6 +372,7 @@ SYSCTL_INT(_vfs_zfs, OID_AUTO, default_ibs, CTLFLAG_RWTUN,
/* metaslab.c */ /* metaslab.c */
/* BEGIN CSTYLED */
/* /*
* In pools where the log space map feature is not enabled we touch * In pools where the log space map feature is not enabled we touch
* multiple metaslabs (and their respective space maps) with each * multiple metaslabs (and their respective space maps) with each
@ -381,7 +385,7 @@ extern int zfs_metaslab_sm_blksz_no_log;
SYSCTL_INT(_vfs_zfs_metaslab, OID_AUTO, sm_blksz_no_log, CTLFLAG_RDTUN, SYSCTL_INT(_vfs_zfs_metaslab, OID_AUTO, sm_blksz_no_log, CTLFLAG_RDTUN,
&zfs_metaslab_sm_blksz_no_log, 0, &zfs_metaslab_sm_blksz_no_log, 0,
"Block size for space map in pools with log space map disabled. " "Block size for space map in pools with log space map disabled. "
"Power of 2 and greater than 4096."); "Power of 2 greater than 4096.");
/* /*
* When the log space map feature is enabled, we accumulate a lot of * When the log space map feature is enabled, we accumulate a lot of
@ -392,7 +396,7 @@ extern int zfs_metaslab_sm_blksz_with_log;
SYSCTL_INT(_vfs_zfs_metaslab, OID_AUTO, sm_blksz_with_log, CTLFLAG_RDTUN, SYSCTL_INT(_vfs_zfs_metaslab, OID_AUTO, sm_blksz_with_log, CTLFLAG_RDTUN,
&zfs_metaslab_sm_blksz_with_log, 0, &zfs_metaslab_sm_blksz_with_log, 0,
"Block size for space map in pools with log space map enabled. " "Block size for space map in pools with log space map enabled. "
"Power of 2 and greater than 4096."); "Power of 2 greater than 4096.");
/* /*
* The in-core space map representation is more compact than its on-disk form. * The in-core space map representation is more compact than its on-disk form.
@ -408,13 +412,13 @@ SYSCTL_INT(_vfs_zfs, OID_AUTO, condense_pct, CTLFLAG_RWTUN,
extern int zfs_remove_max_segment; extern int zfs_remove_max_segment;
SYSCTL_INT(_vfs_zfs, OID_AUTO, remove_max_segment, CTLFLAG_RWTUN, SYSCTL_INT(_vfs_zfs, OID_AUTO, remove_max_segment, CTLFLAG_RWTUN,
&zfs_remove_max_segment, 0, "Largest contiguous segment ZFS will attempt to" &zfs_remove_max_segment, 0, "Largest contiguous segment ZFS will"
" allocate when removing a device"); " attempt to allocate when removing a device");
extern int zfs_removal_suspend_progress; extern int zfs_removal_suspend_progress;
SYSCTL_INT(_vfs_zfs, OID_AUTO, removal_suspend_progress, CTLFLAG_RWTUN, SYSCTL_INT(_vfs_zfs, OID_AUTO, removal_suspend_progress, CTLFLAG_RWTUN,
&zfs_removal_suspend_progress, 0, "Ensures certain actions can happen while" &zfs_removal_suspend_progress, 0,
" in the middle of a removal"); "Ensures certain actions can happen while in the middle of a removal");
/* /*
@ -425,8 +429,8 @@ SYSCTL_INT(_vfs_zfs, OID_AUTO, removal_suspend_progress, CTLFLAG_RWTUN,
*/ */
extern uint64_t metaslab_df_alloc_threshold; extern uint64_t metaslab_df_alloc_threshold;
SYSCTL_QUAD(_vfs_zfs_metaslab, OID_AUTO, df_alloc_threshold, CTLFLAG_RWTUN, SYSCTL_QUAD(_vfs_zfs_metaslab, OID_AUTO, df_alloc_threshold, CTLFLAG_RWTUN,
&metaslab_df_alloc_threshold, 0, &metaslab_df_alloc_threshold, 0, "Minimum size which forces the dynamic"
"Minimum size which forces the dynamic allocator to change it's allocation strategy"); " allocator to change its allocation strategy");
/* /*
* The minimum free space, in percent, which must be available * The minimum free space, in percent, which must be available
@ -437,8 +441,8 @@ SYSCTL_QUAD(_vfs_zfs_metaslab, OID_AUTO, df_alloc_threshold, CTLFLAG_RWTUN,
extern int metaslab_df_free_pct; extern int metaslab_df_free_pct;
SYSCTL_INT(_vfs_zfs_metaslab, OID_AUTO, df_free_pct, CTLFLAG_RWTUN, SYSCTL_INT(_vfs_zfs_metaslab, OID_AUTO, df_free_pct, CTLFLAG_RWTUN,
&metaslab_df_free_pct, 0, &metaslab_df_free_pct, 0,
"The minimum free space, in percent, which must be available in a " "The minimum free space, in percent, which must be available in a"
"space map to continue allocations in a first-fit fashion"); " space map to continue allocations in a first-fit fashion");
/* /*
* Percentage of all cpus that can be used by the metaslab taskq. * Percentage of all cpus that can be used by the metaslab taskq.
@ -459,8 +463,8 @@ SYSCTL_INT(_vfs_zfs_metaslab, OID_AUTO, preload_limit, CTLFLAG_RWTUN,
/* spa.c */ /* spa.c */
extern int zfs_ccw_retry_interval; extern int zfs_ccw_retry_interval;
SYSCTL_INT(_vfs_zfs, OID_AUTO, ccw_retry_interval, CTLFLAG_RWTUN, SYSCTL_INT(_vfs_zfs, OID_AUTO, ccw_retry_interval, CTLFLAG_RWTUN,
&zfs_ccw_retry_interval, 0, &zfs_ccw_retry_interval, 0, "Configuration cache file write,"
"Configuration cache file write, retry after failure, interval (seconds)"); " retry after failure, interval (seconds)");
extern uint64_t zfs_max_missing_tvds_cachefile; extern uint64_t zfs_max_missing_tvds_cachefile;
SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, max_missing_tvds_cachefile, CTLFLAG_RWTUN, SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, max_missing_tvds_cachefile, CTLFLAG_RWTUN,
@ -471,6 +475,7 @@ extern uint64_t zfs_max_missing_tvds_scan;
SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, max_missing_tvds_scan, CTLFLAG_RWTUN, SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, max_missing_tvds_scan, CTLFLAG_RWTUN,
&zfs_max_missing_tvds_scan, 0, &zfs_max_missing_tvds_scan, 0,
"allow importing pools with missing top-level vdevs during scan"); "allow importing pools with missing top-level vdevs during scan");
/* END CSTYLED */
/* spa_misc.c */ /* spa_misc.c */
extern int zfs_flags; extern int zfs_flags;
@ -497,9 +502,11 @@ sysctl_vfs_zfs_debug_flags(SYSCTL_HANDLER_ARGS)
return (0); return (0);
} }
/* BEGIN CSTYLED */
SYSCTL_PROC(_vfs_zfs, OID_AUTO, debugflags, SYSCTL_PROC(_vfs_zfs, OID_AUTO, debugflags,
CTLTYPE_UINT | CTLFLAG_MPSAFE | CTLFLAG_RWTUN, NULL, 0, CTLTYPE_UINT | CTLFLAG_MPSAFE | CTLFLAG_RWTUN, NULL, 0,
sysctl_vfs_zfs_debug_flags, "IU", "Debug flags for ZFS testing."); sysctl_vfs_zfs_debug_flags, "IU", "Debug flags for ZFS testing.");
/* END CSTYLED */
int int
param_set_deadman_synctime(SYSCTL_HANDLER_ARGS) param_set_deadman_synctime(SYSCTL_HANDLER_ARGS)
@ -549,11 +556,11 @@ param_set_deadman_failmode(SYSCTL_HANDLER_ARGS)
return (rc); return (rc);
if (strcmp(buf, zfs_deadman_failmode) == 0) if (strcmp(buf, zfs_deadman_failmode) == 0)
return (0); return (0);
if (!strcmp(buf, "wait")) if (strcmp(buf, "wait") == 0)
zfs_deadman_failmode = "wait"; zfs_deadman_failmode = "wait";
if (!strcmp(buf, "continue")) if (strcmp(buf, "continue") == 0)
zfs_deadman_failmode = "continue"; zfs_deadman_failmode = "continue";
if (!strcmp(buf, "panic")) if (strcmp(buf, "panic") == 0)
zfs_deadman_failmode = "panic"; zfs_deadman_failmode = "panic";
return (-param_set_deadman_failmode_common(buf)); return (-param_set_deadman_failmode_common(buf));
@ -605,6 +612,7 @@ param_set_max_auto_ashift(SYSCTL_HANDLER_ARGS)
return (0); return (0);
} }
/* BEGIN CSTYLED */
SYSCTL_PROC(_vfs_zfs, OID_AUTO, min_auto_ashift, SYSCTL_PROC(_vfs_zfs, OID_AUTO, min_auto_ashift,
CTLTYPE_U64 | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, CTLTYPE_U64 | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
&zfs_vdev_min_auto_ashift, sizeof (zfs_vdev_min_auto_ashift), &zfs_vdev_min_auto_ashift, sizeof (zfs_vdev_min_auto_ashift),
@ -614,8 +622,8 @@ SYSCTL_PROC(_vfs_zfs, OID_AUTO, max_auto_ashift,
CTLTYPE_U64 | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, CTLTYPE_U64 | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
&zfs_vdev_max_auto_ashift, sizeof (zfs_vdev_max_auto_ashift), &zfs_vdev_max_auto_ashift, sizeof (zfs_vdev_max_auto_ashift),
param_set_max_auto_ashift, "QU", param_set_max_auto_ashift, "QU",
"Max ashift used when optimizing for logical -> physical sector size on " "Max ashift used when optimizing for logical -> physical sector size on"
"new top-level vdevs. (LEGACY)"); " new top-level vdevs. (LEGACY)");
/* /*
* Since the DTL space map of a vdev is not expected to have a lot of * Since the DTL space map of a vdev is not expected to have a lot of
@ -624,7 +632,7 @@ SYSCTL_PROC(_vfs_zfs, OID_AUTO, max_auto_ashift,
extern int zfs_vdev_dtl_sm_blksz; extern int zfs_vdev_dtl_sm_blksz;
SYSCTL_INT(_vfs_zfs, OID_AUTO, dtl_sm_blksz, CTLFLAG_RDTUN, SYSCTL_INT(_vfs_zfs, OID_AUTO, dtl_sm_blksz, CTLFLAG_RDTUN,
&zfs_vdev_dtl_sm_blksz, 0, &zfs_vdev_dtl_sm_blksz, 0,
"Block size for DTL space map. Power of 2 and greater than 4096."); "Block size for DTL space map. Power of 2 greater than 4096.");
/* /*
* vdev-wide space maps that have lots of entries written to them at * vdev-wide space maps that have lots of entries written to them at
@ -634,12 +642,12 @@ SYSCTL_INT(_vfs_zfs, OID_AUTO, dtl_sm_blksz, CTLFLAG_RDTUN,
extern int zfs_vdev_standard_sm_blksz; extern int zfs_vdev_standard_sm_blksz;
SYSCTL_INT(_vfs_zfs, OID_AUTO, standard_sm_blksz, CTLFLAG_RDTUN, SYSCTL_INT(_vfs_zfs, OID_AUTO, standard_sm_blksz, CTLFLAG_RDTUN,
&zfs_vdev_standard_sm_blksz, 0, &zfs_vdev_standard_sm_blksz, 0,
"Block size for standard space map. Power of 2 and greater than 4096."); "Block size for standard space map. Power of 2 greater than 4096.");
/* END CSTYLED */
extern int vdev_validate_skip; extern int vdev_validate_skip;
SYSCTL_INT(_vfs_zfs, OID_AUTO, validate_skip, CTLFLAG_RDTUN, SYSCTL_INT(_vfs_zfs, OID_AUTO, validate_skip, CTLFLAG_RDTUN,
&vdev_validate_skip, 0, &vdev_validate_skip, 0, "Enable to bypass vdev_validate().");
"Enable to bypass vdev_validate().");
/* vdev_cache.c */ /* vdev_cache.c */
@ -657,55 +665,23 @@ SYSCTL_INT(_vfs_zfs, OID_AUTO, validate_skip, CTLFLAG_RDTUN,
/* vdev_queue.c */ /* vdev_queue.c */
#define ZFS_VDEV_QUEUE_KNOB_MIN(name) \ /* BEGIN CSTYLED */
extern uint32_t zfs_vdev_ ## name ## _min_active; \
SYSCTL_UINT(_vfs_zfs_vdev, OID_AUTO, name ## _min_active, CTLFLAG_RWTUN,\
&zfs_vdev_ ## name ## _min_active, 0, \
"Initial number of I/O requests of type " #name \
" active for each device");
#define ZFS_VDEV_QUEUE_KNOB_MAX(name) \
extern uint32_t zfs_vdev_ ## name ## _max_active; \
SYSCTL_UINT(_vfs_zfs_vdev, OID_AUTO, name ## _max_active, CTLFLAG_RWTUN, \
&zfs_vdev_ ## name ## _max_active, 0, \
"Maximum number of I/O requests of type " #name \
" active for each device");
#undef ZFS_VDEV_QUEUE_KNOB
extern uint32_t zfs_vdev_max_active; extern uint32_t zfs_vdev_max_active;
SYSCTL_UINT(_vfs_zfs, OID_AUTO, top_maxinflight, CTLFLAG_RWTUN, SYSCTL_UINT(_vfs_zfs, OID_AUTO, top_maxinflight, CTLFLAG_RWTUN,
&zfs_vdev_max_active, 0, &zfs_vdev_max_active, 0,
"The maximum number of I/Os of all types active for each device. (LEGACY)"); "The maximum number of I/Os of all types active for each device."
" (LEGACY)");
extern int zfs_vdev_def_queue_depth; extern int zfs_vdev_def_queue_depth;
SYSCTL_INT(_vfs_zfs_vdev, OID_AUTO, def_queue_depth, CTLFLAG_RWTUN, SYSCTL_INT(_vfs_zfs_vdev, OID_AUTO, def_queue_depth, CTLFLAG_RWTUN,
&zfs_vdev_def_queue_depth, 0, &zfs_vdev_def_queue_depth, 0,
"Default queue depth for each allocator"); "Default queue depth for each allocator");
/*extern uint64_t zfs_multihost_history;
SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, multihost_history, CTLFLAG_RWTUN,
&zfs_multihost_history, 0,
"Historical staticists for the last N multihost updates");*/
#ifdef notyet SYSCTL_INT(_vfs_zfs_zio, OID_AUTO, exclude_metadata, CTLFLAG_RDTUN,
SYSCTL_INT(_vfs_zfs_vdev, OID_AUTO, trim_on_init, CTLFLAG_RW, &zio_exclude_metadata, 0,
&vdev_trim_on_init, 0, "Enable/disable full vdev trim on initialisation");
#endif
/* zio.c */
#if defined(__LP64__)
int zio_use_uma = 1;
#else
int zio_use_uma = 0;
#endif
SYSCTL_INT(_vfs_zfs_zio, OID_AUTO, use_uma, CTLFLAG_RDTUN, &zio_use_uma, 0,
"Use uma(9) for ZIO allocations");
SYSCTL_INT(_vfs_zfs_zio, OID_AUTO, exclude_metadata, CTLFLAG_RDTUN, &zio_exclude_metadata, 0,
"Exclude metadata buffers from dumps as well"); "Exclude metadata buffers from dumps as well");
/* END CSTYLED */
int int
param_set_slop_shift(SYSCTL_HANDLER_ARGS) param_set_slop_shift(SYSCTL_HANDLER_ARGS)

View File

@ -63,9 +63,9 @@ struct consumer_vdev_elem {
}; };
SLIST_HEAD(consumer_priv_t, consumer_vdev_elem); SLIST_HEAD(consumer_priv_t, consumer_vdev_elem);
/* BEGIN CSTYLED */ _Static_assert(
_Static_assert(sizeof (((struct g_consumer *)NULL)->private) sizeof (((struct g_consumer *)NULL)->private) ==
== sizeof (struct consumer_priv_t*), sizeof (struct consumer_priv_t *),
"consumer_priv_t* can't be stored in g_consumer.private"); "consumer_priv_t* can't be stored in g_consumer.private");
DECLARE_GEOM_CLASS(zfs_vdev_class, zfs_vdev); DECLARE_GEOM_CLASS(zfs_vdev_class, zfs_vdev);
@ -79,7 +79,6 @@ SYSCTL_INT(_vfs_zfs_vdev, OID_AUTO, bio_flush_disable, CTLFLAG_RWTUN,
static int vdev_geom_bio_delete_disable; static int vdev_geom_bio_delete_disable;
SYSCTL_INT(_vfs_zfs_vdev, OID_AUTO, bio_delete_disable, CTLFLAG_RWTUN, SYSCTL_INT(_vfs_zfs_vdev, OID_AUTO, bio_delete_disable, CTLFLAG_RWTUN,
&vdev_geom_bio_delete_disable, 0, "Disable BIO_DELETE"); &vdev_geom_bio_delete_disable, 0, "Disable BIO_DELETE");
/* END CSTYLED */
/* Declare local functions */ /* Declare local functions */
static void vdev_geom_detach(struct g_consumer *cp, boolean_t open_for_read); static void vdev_geom_detach(struct g_consumer *cp, boolean_t open_for_read);

View File

@ -245,10 +245,8 @@ zfs_dbgmsg_print(const char *tag)
} }
#endif /* _KERNEL */ #endif /* _KERNEL */
/* BEGIN CSTYLED */
ZFS_MODULE_PARAM(zfs, zfs_, dbgmsg_enable, INT, ZMOD_RW, ZFS_MODULE_PARAM(zfs, zfs_, dbgmsg_enable, INT, ZMOD_RW,
"Enable ZFS debug message log"); "Enable ZFS debug message log");
ZFS_MODULE_PARAM(zfs, zfs_, dbgmsg_maxsize, INT, ZMOD_RW, ZFS_MODULE_PARAM(zfs, zfs_, dbgmsg_maxsize, INT, ZMOD_RW,
"Maximum ZFS debug log size"); "Maximum ZFS debug log size");
/* END CSTYLED */

View File

@ -76,7 +76,6 @@
#define MNTK_NOMSYNC 8 #define MNTK_NOMSYNC 8
#endif #endif
/* BEGIN CSTYLED */
struct mtx zfs_debug_mtx; struct mtx zfs_debug_mtx;
MTX_SYSINIT(zfs_debug_mtx, &zfs_debug_mtx, "zfs_debug", MTX_DEF); MTX_SYSINIT(zfs_debug_mtx, &zfs_debug_mtx, "zfs_debug", MTX_DEF);
@ -84,7 +83,7 @@ SYSCTL_NODE(_vfs, OID_AUTO, zfs, CTLFLAG_RW, 0, "ZFS file system");
int zfs_super_owner; int zfs_super_owner;
SYSCTL_INT(_vfs_zfs, OID_AUTO, super_owner, CTLFLAG_RW, &zfs_super_owner, 0, SYSCTL_INT(_vfs_zfs, OID_AUTO, super_owner, CTLFLAG_RW, &zfs_super_owner, 0,
"File system owner can perform privileged operation on his file systems"); "File system owners can perform privileged operation on file systems");
int zfs_debug_level; int zfs_debug_level;
SYSCTL_INT(_vfs_zfs, OID_AUTO, debug, CTLFLAG_RWTUN, &zfs_debug_level, 0, SYSCTL_INT(_vfs_zfs, OID_AUTO, debug, CTLFLAG_RWTUN, &zfs_debug_level, 0,
@ -100,7 +99,6 @@ SYSCTL_INT(_vfs_zfs_version, OID_AUTO, spa, CTLFLAG_RD, &zfs_version_spa, 0,
static int zfs_version_zpl = ZPL_VERSION; static int zfs_version_zpl = ZPL_VERSION;
SYSCTL_INT(_vfs_zfs_version, OID_AUTO, zpl, CTLFLAG_RD, &zfs_version_zpl, 0, SYSCTL_INT(_vfs_zfs_version, OID_AUTO, zpl, CTLFLAG_RD, &zfs_version_zpl, 0,
"ZPL_VERSION"); "ZPL_VERSION");
/* END CSTYLED */
#if __FreeBSD_version >= 1400018 #if __FreeBSD_version >= 1400018
static int zfs_quotactl(vfs_t *vfsp, int cmds, uid_t id, void *arg, static int zfs_quotactl(vfs_t *vfsp, int cmds, uid_t id, void *arg,

View File

@ -1821,9 +1821,8 @@ error:
} }
#if defined(_KERNEL) && defined(HAVE_SPL) #if defined(_KERNEL) && defined(HAVE_SPL)
/* BEGIN CSTYLED */ /* CSTYLED */
module_param(zfs_key_max_salt_uses, ulong, 0644); module_param(zfs_key_max_salt_uses, ulong, 0644);
MODULE_PARM_DESC(zfs_key_max_salt_uses, "Max number of times a salt value " MODULE_PARM_DESC(zfs_key_max_salt_uses, "Max number of times a salt value "
"can be used for generating encryption keys before it is rotated"); "can be used for generating encryption keys before it is rotated");
/* END CSTYLED */
#endif #endif

View File

@ -32,11 +32,10 @@
* analysis and other such goodies. * analysis and other such goodies.
* But we would still default to the current default of not to do that. * But we would still default to the current default of not to do that.
*/ */
/* BEGIN CSTYLED */
unsigned int spl_panic_halt; unsigned int spl_panic_halt;
/* CSTYLED */
module_param(spl_panic_halt, uint, 0644); module_param(spl_panic_halt, uint, 0644);
MODULE_PARM_DESC(spl_panic_halt, "Cause kernel panic on assertion failures"); MODULE_PARM_DESC(spl_panic_halt, "Cause kernel panic on assertion failures");
/* END CSTYLED */
void void
spl_dumpstack(void) spl_dumpstack(void)

View File

@ -48,13 +48,12 @@
#include <sys/cred.h> #include <sys/cred.h>
#include <sys/vnode.h> #include <sys/vnode.h>
/* BEGIN CSTYLED */
unsigned long spl_hostid = 0; unsigned long spl_hostid = 0;
EXPORT_SYMBOL(spl_hostid); EXPORT_SYMBOL(spl_hostid);
/* CSTYLED */
module_param(spl_hostid, ulong, 0644); module_param(spl_hostid, ulong, 0644);
MODULE_PARM_DESC(spl_hostid, "The system hostid."); MODULE_PARM_DESC(spl_hostid, "The system hostid.");
/* END CSTYLED */
proc_t p0; proc_t p0;
EXPORT_SYMBOL(p0); EXPORT_SYMBOL(p0);
@ -268,11 +267,10 @@ __udivdi3(uint64_t u, uint64_t v)
} }
EXPORT_SYMBOL(__udivdi3); EXPORT_SYMBOL(__udivdi3);
/* BEGIN CSTYLED */
#ifndef abs64 #ifndef abs64
/* CSTYLED */
#define abs64(x) ({ uint64_t t = (x) >> 63; ((x) ^ t) - t; }) #define abs64(x) ({ uint64_t t = (x) >> 63; ((x) ^ t) - t; })
#endif #endif
/* END CSTYLED */
/* /*
* Implementation of 64-bit signed division for 32-bit machines. * Implementation of 64-bit signed division for 32-bit machines.
@ -384,11 +382,9 @@ __aeabi_uldivmod(uint64_t u, uint64_t v)
register uint32_t r2 asm("r2") = (mod & 0xFFFFFFFF); register uint32_t r2 asm("r2") = (mod & 0xFFFFFFFF);
register uint32_t r3 asm("r3") = (mod >> 32); register uint32_t r3 asm("r3") = (mod >> 32);
/* BEGIN CSTYLED */
asm volatile("" asm volatile(""
: "+r"(r0), "+r"(r1), "+r"(r2),"+r"(r3) /* output */ : "+r"(r0), "+r"(r1), "+r"(r2), "+r"(r3) /* output */
: "r"(r0), "r"(r1), "r"(r2), "r"(r3)); /* input */ : "r"(r0), "r"(r1), "r"(r2), "r"(r3)); /* input */
/* END CSTYLED */
return; /* r0; */ return; /* r0; */
} }
@ -409,11 +405,9 @@ __aeabi_ldivmod(int64_t u, int64_t v)
register uint32_t r2 asm("r2") = (mod & 0xFFFFFFFF); register uint32_t r2 asm("r2") = (mod & 0xFFFFFFFF);
register uint32_t r3 asm("r3") = (mod >> 32); register uint32_t r3 asm("r3") = (mod >> 32);
/* BEGIN CSTYLED */
asm volatile("" asm volatile(""
: "+r"(r0), "+r"(r1), "+r"(r2),"+r"(r3) /* output */ : "+r"(r0), "+r"(r1), "+r"(r2), "+r"(r3) /* output */
: "r"(r0), "r"(r1), "r"(r2), "r"(r3)); /* input */ : "r"(r0), "r"(r1), "r"(r2), "r"(r3)); /* input */
/* END CSTYLED */
return; /* r0; */ return; /* r0; */
} }

View File

@ -57,7 +57,6 @@
#endif #endif
/* BEGIN CSTYLED */ /* BEGIN CSTYLED */
/* /*
* Cache magazines are an optimization designed to minimize the cost of * Cache magazines are an optimization designed to minimize the cost of
* allocating memory. They do this by keeping a per-cpu cache of recently * allocating memory. They do this by keeping a per-cpu cache of recently

View File

@ -26,6 +26,7 @@
#include <sys/kmem.h> #include <sys/kmem.h>
#include <sys/vmem.h> #include <sys/vmem.h>
/* BEGIN CSTYLED */
/* /*
* As a general rule kmem_alloc() allocations should be small, preferably * As a general rule kmem_alloc() allocations should be small, preferably
* just a few pages since they must by physically contiguous. Therefore, a * just a few pages since they must by physically contiguous. Therefore, a
@ -41,7 +42,6 @@
* allocations are quickly caught. These warnings may be disabled by setting * allocations are quickly caught. These warnings may be disabled by setting
* the threshold to zero. * the threshold to zero.
*/ */
/* BEGIN CSTYLED */
unsigned int spl_kmem_alloc_warn = MIN(16 * PAGE_SIZE, 64 * 1024); unsigned int spl_kmem_alloc_warn = MIN(16 * PAGE_SIZE, 64 * 1024);
module_param(spl_kmem_alloc_warn, uint, 0644); module_param(spl_kmem_alloc_warn, uint, 0644);
MODULE_PARM_DESC(spl_kmem_alloc_warn, MODULE_PARM_DESC(spl_kmem_alloc_warn,

View File

@ -180,11 +180,10 @@ taskq_seq_show_headers(struct seq_file *f)
#define LHEAD_ACTIVE 4 #define LHEAD_ACTIVE 4
#define LHEAD_SIZE 5 #define LHEAD_SIZE 5
/* BEGIN CSTYLED */
static unsigned int spl_max_show_tasks = 512; static unsigned int spl_max_show_tasks = 512;
/* CSTYLED */
module_param(spl_max_show_tasks, uint, 0644); module_param(spl_max_show_tasks, uint, 0644);
MODULE_PARM_DESC(spl_max_show_tasks, "Max number of tasks shown in taskq proc"); MODULE_PARM_DESC(spl_max_show_tasks, "Max number of tasks shown in taskq proc");
/* END CSTYLED */
static int static int
taskq_seq_show_impl(struct seq_file *f, void *p, boolean_t allflag) taskq_seq_show_impl(struct seq_file *f, void *p, boolean_t allflag)

View File

@ -536,7 +536,5 @@ arc_prune_async(int64_t adjust)
mutex_exit(&arc_prune_mtx); mutex_exit(&arc_prune_mtx);
} }
/* BEGIN CSTYLED */
ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, shrinker_limit, INT, ZMOD_RW, ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, shrinker_limit, INT, ZMOD_RW,
"Limit on number of pages that ARC shrinker can reclaim at once"); "Limit on number of pages that ARC shrinker can reclaim at once");
/* END CSTYLED */

View File

@ -3995,9 +3995,8 @@ EXPORT_SYMBOL(zfs_putpage);
EXPORT_SYMBOL(zfs_dirty_inode); EXPORT_SYMBOL(zfs_dirty_inode);
EXPORT_SYMBOL(zfs_map); EXPORT_SYMBOL(zfs_map);
/* BEGIN CSTYLED */ /* CSTYLED */
module_param(zfs_delete_blocks, ulong, 0644); module_param(zfs_delete_blocks, ulong, 0644);
MODULE_PARM_DESC(zfs_delete_blocks, "Delete files larger than N blocks async"); MODULE_PARM_DESC(zfs_delete_blocks, "Delete files larger than N blocks async");
/* END CSTYLED */
#endif #endif

View File

@ -2051,9 +2051,8 @@ error:
} }
#if defined(_KERNEL) #if defined(_KERNEL)
/* BEGIN CSTYLED */ /* CSTYLED */
module_param(zfs_key_max_salt_uses, ulong, 0644); module_param(zfs_key_max_salt_uses, ulong, 0644);
MODULE_PARM_DESC(zfs_key_max_salt_uses, "Max number of times a salt value " MODULE_PARM_DESC(zfs_key_max_salt_uses, "Max number of times a salt value "
"can be used for generating encryption keys before it is rotated"); "can be used for generating encryption keys before it is rotated");
/* END CSTYLED */
#endif #endif

View File

@ -1100,8 +1100,7 @@ const struct file_operations zpl_dir_file_operations = {
#endif #endif
}; };
/* BEGIN CSTYLED */ /* CSTYLED */
module_param(zfs_fallocate_reserve_percent, uint, 0644); module_param(zfs_fallocate_reserve_percent, uint, 0644);
MODULE_PARM_DESC(zfs_fallocate_reserve_percent, MODULE_PARM_DESC(zfs_fallocate_reserve_percent,
"Percentage of length to use for the available capacity check"); "Percentage of length to use for the available capacity check");
/* END CSTYLED */

View File

@ -968,11 +968,9 @@ fletcher_4_param(ZFS_MODULE_PARAM_ARGS)
* Users can choose "cycle" to exercise all implementations, but this is * Users can choose "cycle" to exercise all implementations, but this is
* for testing purpose therefore it can only be set in user space. * for testing purpose therefore it can only be set in user space.
*/ */
/* BEGIN CSTYLED */
ZFS_MODULE_VIRTUAL_PARAM_CALL(zfs, zfs_, fletcher_4_impl, ZFS_MODULE_VIRTUAL_PARAM_CALL(zfs, zfs_, fletcher_4_impl,
fletcher_4_param_set, fletcher_4_param_get, ZMOD_RW, fletcher_4_param_set, fletcher_4_param_get, ZMOD_RW,
"Select fletcher 4 implementation."); "Select fletcher 4 implementation.");
/* END CSTYLED */
EXPORT_SYMBOL(fletcher_init); EXPORT_SYMBOL(fletcher_init);
EXPORT_SYMBOL(fletcher_2_incremental_native); EXPORT_SYMBOL(fletcher_2_incremental_native);

View File

@ -11043,7 +11043,6 @@ EXPORT_SYMBOL(arc_getbuf_func);
EXPORT_SYMBOL(arc_add_prune_callback); EXPORT_SYMBOL(arc_add_prune_callback);
EXPORT_SYMBOL(arc_remove_prune_callback); EXPORT_SYMBOL(arc_remove_prune_callback);
/* BEGIN CSTYLED */
ZFS_MODULE_PARAM_CALL(zfs_arc, zfs_arc_, min, param_set_arc_min, ZFS_MODULE_PARAM_CALL(zfs_arc, zfs_arc_, min, param_set_arc_min,
param_get_long, ZMOD_RW, "Min arc size"); param_get_long, ZMOD_RW, "Min arc size");
@ -11140,8 +11139,7 @@ ZFS_MODULE_PARAM(zfs_l2arc, l2arc_, mfuonly, INT, ZMOD_RW,
"Cache only MFU data from ARC into L2ARC"); "Cache only MFU data from ARC into L2ARC");
ZFS_MODULE_PARAM(zfs_l2arc, l2arc_, exclude_special, INT, ZMOD_RW, ZFS_MODULE_PARAM(zfs_l2arc, l2arc_, exclude_special, INT, ZMOD_RW,
"If set to 1 exclude dbufs on special vdevs from being cached to " "Exclude dbufs on special vdevs from being cached to L2ARC if set.");
"L2ARC.");
ZFS_MODULE_PARAM_CALL(zfs_arc, zfs_arc_, lotsfree_percent, param_set_arc_int, ZFS_MODULE_PARAM_CALL(zfs_arc, zfs_arc_, lotsfree_percent, param_set_arc_int,
param_get_int, ZMOD_RW, "System free memory I/O throttle in bytes"); param_get_int, ZMOD_RW, "System free memory I/O throttle in bytes");
@ -11167,4 +11165,3 @@ ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, evict_batch_limit, INT, ZMOD_RW,
ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, prune_task_threads, INT, ZMOD_RW, ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, prune_task_threads, INT, ZMOD_RW,
"Number of arc_prune threads"); "Number of arc_prune threads");
/* END CSTYLED */

View File

@ -822,7 +822,7 @@ dbuf_evict_thread(void *unused)
/* /*
* Wake up the dbuf eviction thread if the dbuf cache is at its max size. * Wake up the dbuf eviction thread if the dbuf cache is at its max size.
* If the dbuf cache is at its high water mark, then evict a dbuf from the * If the dbuf cache is at its high water mark, then evict a dbuf from the
* dbuf cache using the callers context. * dbuf cache using the caller's context.
*/ */
static void static void
dbuf_evict_notify(uint64_t size) dbuf_evict_notify(uint64_t size)
@ -5096,25 +5096,20 @@ EXPORT_SYMBOL(dmu_buf_set_user_ie);
EXPORT_SYMBOL(dmu_buf_get_user); EXPORT_SYMBOL(dmu_buf_get_user);
EXPORT_SYMBOL(dmu_buf_get_blkptr); EXPORT_SYMBOL(dmu_buf_get_blkptr);
/* BEGIN CSTYLED */
ZFS_MODULE_PARAM(zfs_dbuf_cache, dbuf_cache_, max_bytes, ULONG, ZMOD_RW, ZFS_MODULE_PARAM(zfs_dbuf_cache, dbuf_cache_, max_bytes, ULONG, ZMOD_RW,
"Maximum size in bytes of the dbuf cache."); "Maximum size in bytes of the dbuf cache.");
ZFS_MODULE_PARAM(zfs_dbuf_cache, dbuf_cache_, hiwater_pct, UINT, ZMOD_RW, ZFS_MODULE_PARAM(zfs_dbuf_cache, dbuf_cache_, hiwater_pct, UINT, ZMOD_RW,
"Percentage over dbuf_cache_max_bytes when dbufs must be evicted " "Percentage over dbuf_cache_max_bytes for direct dbuf eviction.");
"directly.");
ZFS_MODULE_PARAM(zfs_dbuf_cache, dbuf_cache_, lowater_pct, UINT, ZMOD_RW, ZFS_MODULE_PARAM(zfs_dbuf_cache, dbuf_cache_, lowater_pct, UINT, ZMOD_RW,
"Percentage below dbuf_cache_max_bytes when the evict thread stops " "Percentage below dbuf_cache_max_bytes when dbuf eviction stops.");
"evicting dbufs.");
ZFS_MODULE_PARAM(zfs_dbuf, dbuf_, metadata_cache_max_bytes, ULONG, ZMOD_RW, ZFS_MODULE_PARAM(zfs_dbuf, dbuf_, metadata_cache_max_bytes, ULONG, ZMOD_RW,
"Maximum size in bytes of the dbuf metadata cache."); "Maximum size in bytes of dbuf metadata cache.");
ZFS_MODULE_PARAM(zfs_dbuf, dbuf_, cache_shift, INT, ZMOD_RW, ZFS_MODULE_PARAM(zfs_dbuf, dbuf_, cache_shift, INT, ZMOD_RW,
"Set the size of the dbuf cache to a log2 fraction of arc size."); "Set size of dbuf cache to log2 fraction of arc size.");
ZFS_MODULE_PARAM(zfs_dbuf, dbuf_, metadata_cache_shift, INT, ZMOD_RW, ZFS_MODULE_PARAM(zfs_dbuf, dbuf_, metadata_cache_shift, INT, ZMOD_RW,
"Set the size of the dbuf metadata cache to a log2 fraction of arc " "Set size of dbuf metadata cache to log2 fraction of arc size.");
"size.");
/* END CSTYLED */

View File

@ -226,7 +226,5 @@ dbuf_stats_destroy(void)
dbuf_stats_hash_table_destroy(); dbuf_stats_hash_table_destroy();
} }
/* BEGIN CSTYLED */
ZFS_MODULE_PARAM(zfs, zfs_, dbuf_state_index, INT, ZMOD_RW, ZFS_MODULE_PARAM(zfs, zfs_, dbuf_state_index, INT, ZMOD_RW,
"Calculate arc header index"); "Calculate arc header index");
/* END CSTYLED */

View File

@ -1180,7 +1180,5 @@ ddt_walk(spa_t *spa, ddt_bookmark_t *ddb, ddt_entry_t *dde)
return (SET_ERROR(ENOENT)); return (SET_ERROR(ENOENT));
} }
/* BEGIN CSTYLED */
ZFS_MODULE_PARAM(zfs_dedup, zfs_dedup_, prefetch, INT, ZMOD_RW, ZFS_MODULE_PARAM(zfs_dedup, zfs_dedup_, prefetch, INT, ZMOD_RW,
"Enable prefetching dedup-ed blks"); "Enable prefetching dedup-ed blks");
/* END CSTYLED */

View File

@ -2346,7 +2346,6 @@ EXPORT_SYMBOL(dmu_assign_arcbuf_by_dbuf);
EXPORT_SYMBOL(dmu_buf_hold); EXPORT_SYMBOL(dmu_buf_hold);
EXPORT_SYMBOL(dmu_ot); EXPORT_SYMBOL(dmu_ot);
/* BEGIN CSTYLED */
ZFS_MODULE_PARAM(zfs, zfs_, nopwrite_enabled, INT, ZMOD_RW, ZFS_MODULE_PARAM(zfs, zfs_, nopwrite_enabled, INT, ZMOD_RW,
"Enable NOP writes"); "Enable NOP writes");
@ -2356,6 +2355,6 @@ ZFS_MODULE_PARAM(zfs, zfs_, per_txg_dirty_frees_percent, ULONG, ZMOD_RW,
ZFS_MODULE_PARAM(zfs, zfs_, dmu_offset_next_sync, INT, ZMOD_RW, ZFS_MODULE_PARAM(zfs, zfs_, dmu_offset_next_sync, INT, ZMOD_RW,
"Enable forcing txg sync to find holes"); "Enable forcing txg sync to find holes");
/* CSTYLED */
ZFS_MODULE_PARAM(zfs, , dmu_prefetch_max, INT, ZMOD_RW, ZFS_MODULE_PARAM(zfs, , dmu_prefetch_max, INT, ZMOD_RW,
"Limit one prefetch call to this size"); "Limit one prefetch call to this size");
/* END CSTYLED */

View File

@ -3389,7 +3389,6 @@ dmu_objset_is_receiving(objset_t *os)
os->os_dsl_dataset->ds_owner == dmu_recv_tag); os->os_dsl_dataset->ds_owner == dmu_recv_tag);
} }
/* BEGIN CSTYLED */
ZFS_MODULE_PARAM(zfs_recv, zfs_recv_, queue_length, INT, ZMOD_RW, ZFS_MODULE_PARAM(zfs_recv, zfs_recv_, queue_length, INT, ZMOD_RW,
"Maximum receive queue length"); "Maximum receive queue length");
@ -3398,4 +3397,3 @@ ZFS_MODULE_PARAM(zfs_recv, zfs_recv_, queue_ff, INT, ZMOD_RW,
ZFS_MODULE_PARAM(zfs_recv, zfs_recv_, write_batch_size, INT, ZMOD_RW, ZFS_MODULE_PARAM(zfs_recv, zfs_recv_, write_batch_size, INT, ZMOD_RW,
"Maximum amount of writes to batch into one transaction"); "Maximum amount of writes to batch into one transaction");
/* END CSTYLED */

View File

@ -3084,7 +3084,6 @@ out:
return (err); return (err);
} }
/* BEGIN CSTYLED */
ZFS_MODULE_PARAM(zfs_send, zfs_send_, corrupt_data, INT, ZMOD_RW, ZFS_MODULE_PARAM(zfs_send, zfs_send_, corrupt_data, INT, ZMOD_RW,
"Allow sending corrupt data"); "Allow sending corrupt data");
@ -3105,4 +3104,3 @@ ZFS_MODULE_PARAM(zfs_send, zfs_send_, no_prefetch_queue_ff, INT, ZMOD_RW,
ZFS_MODULE_PARAM(zfs_send, zfs_, override_estimate_recordsize, INT, ZMOD_RW, ZFS_MODULE_PARAM(zfs_send, zfs_, override_estimate_recordsize, INT, ZMOD_RW,
"Override block size estimate with fixed size"); "Override block size estimate with fixed size");
/* END CSTYLED */

View File

@ -809,7 +809,6 @@ traverse_pool(spa_t *spa, uint64_t txg_start, int flags,
EXPORT_SYMBOL(traverse_dataset); EXPORT_SYMBOL(traverse_dataset);
EXPORT_SYMBOL(traverse_pool); EXPORT_SYMBOL(traverse_pool);
/* BEGIN CSTYLED */
ZFS_MODULE_PARAM(zfs, zfs_, pd_bytes_max, INT, ZMOD_RW, ZFS_MODULE_PARAM(zfs, zfs_, pd_bytes_max, INT, ZMOD_RW,
"Max number of bytes to prefetch"); "Max number of bytes to prefetch");
@ -822,6 +821,6 @@ MODULE_PARM_DESC(ignore_hole_birth,
"Alias for send_holes_without_birth_time"); "Alias for send_holes_without_birth_time");
#endif #endif
/* CSTYLED */
ZFS_MODULE_PARAM(zfs, , send_holes_without_birth_time, INT, ZMOD_RW, ZFS_MODULE_PARAM(zfs, , send_holes_without_birth_time, INT, ZMOD_RW,
"Ignore hole_birth txg for zfs send"); "Ignore hole_birth txg for zfs send");
/* END CSTYLED */

View File

@ -531,7 +531,6 @@ dmu_zfetch(zfetch_t *zf, uint64_t blkid, uint64_t nblks, boolean_t fetch_data,
dmu_zfetch_run(zs, missed, have_lock); dmu_zfetch_run(zs, missed, have_lock);
} }
/* BEGIN CSTYLED */
ZFS_MODULE_PARAM(zfs_prefetch, zfs_prefetch_, disable, INT, ZMOD_RW, ZFS_MODULE_PARAM(zfs_prefetch, zfs_prefetch_, disable, INT, ZMOD_RW,
"Disable all ZFS prefetching"); "Disable all ZFS prefetching");
@ -549,4 +548,3 @@ ZFS_MODULE_PARAM(zfs_prefetch, zfetch_, max_idistance, UINT, ZMOD_RW,
ZFS_MODULE_PARAM(zfs_prefetch, zfetch_, array_rd_sz, ULONG, ZMOD_RW, ZFS_MODULE_PARAM(zfs_prefetch, zfetch_, array_rd_sz, ULONG, ZMOD_RW,
"Number of bytes in a array_read"); "Number of bytes in a array_read");
/* END CSTYLED */

Some files were not shown because too many files have changed in this diff Show More