mirrors/linux-stable
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git synced 2024-09-12 21:57:43 +00:00
Code Issues Releases Wiki Activity

staging: lustre: remove CLASSERT macro

Browse source 
lustre uses a fake switch() statement as a compile-time assert, but unfortunately
each use of that causes a warning when building with clang:

drivers/staging/lustre/lnet/klnds/socklnd/socklnd.c:2907:2: warning: no case matching constant switch condition '42'
drivers/staging/lustre/lnet/klnds/socklnd/../../../include/linux/libcfs/libcfs_private.h:294:36: note: expanded from macro 'CLASSERT'
 #define CLASSERT(cond) do {switch (42) {case (cond): case 0: break; } } while (0)

As Greg suggested, let's just kill off this macro completely instead of
fixing it. This replaces it with BUILD_BUG_ON(), which means we have
to negate all the conditions in the process.

Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
Arnd Bergmann 2017-02-02 12:26:51 +01:00 committed by Greg Kroah-Hartman
parent 757b9bd074
commit f440d90908
29 changed files with 269 additions and 285 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
drivers/staging/lustre/include/linux/libcfs/libcfs_private.h
View file

@ -277,22 +277,6 @@ do { \
#define CFS_ALLOC_PTR(ptr) LIBCFS_ALLOC(ptr, sizeof(*(ptr)))
#define CFS_FREE_PTR(ptr) LIBCFS_FREE(ptr, sizeof(*(ptr)))
/** Compile-time assertion.
*
* Check an invariant described by a constant expression at compile time by
* forcing a compiler error if it does not hold. \a cond must be a constant
* expression as defined by the ISO C Standard:
*
* 6.8.4.2 The switch statement
* ....
* [#3] The expression of each case label shall be an integer
* constant expression and no two of the case constant
* expressions in the same switch statement shall have the same
* value after conversion...
*
*/
#define CLASSERT(cond) do {switch (42) {case (cond): case 0: break; } } while (0)
/* max value for numeric network address */
#define MAX_NUMERIC_VALUE 0xffffffff

16
drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd.c
View file

@ -258,8 +258,8 @@ int kiblnd_unpack_msg(struct kib_msg *msg, int nob)
if (flip) {
/* leave magic unflipped as a clue to peer endianness */
msg->ibm_version = version;
CLASSERT(sizeof(msg->ibm_type) == 1);
CLASSERT(sizeof(msg->ibm_credits) == 1);
BUILD_BUG_ON(sizeof(msg->ibm_type) != 1);
BUILD_BUG_ON(sizeof(msg->ibm_credits) != 1);
msg->ibm_nob = msg_nob;
__swab64s(&msg->ibm_srcnid);
__swab64s(&msg->ibm_srcstamp);
@ -1247,10 +1247,10 @@ static void kiblnd_map_tx_pool(struct kib_tx_pool *tpo)
dev = net->ibn_dev;
/* pre-mapped messages are not bigger than 1 page */
CLASSERT(IBLND_MSG_SIZE <= PAGE_SIZE);
BUILD_BUG_ON(IBLND_MSG_SIZE > PAGE_SIZE);
/* No fancy arithmetic when we do the buffer calculations */
CLASSERT(!(PAGE_SIZE % IBLND_MSG_SIZE));
BUILD_BUG_ON(PAGE_SIZE % IBLND_MSG_SIZE);
tpo->tpo_hdev = kiblnd_current_hdev(dev);
@ -2943,7 +2943,7 @@ static int kiblnd_startup(lnet_ni_t *ni)
if (ni->ni_interfaces[0]) {
/* Use the IPoIB interface specified in 'networks=' */
CLASSERT(LNET_MAX_INTERFACES > 1);
BUILD_BUG_ON(LNET_MAX_INTERFACES <= 1);
if (ni->ni_interfaces[1]) {
CERROR("Multiple interfaces not supported\n");
goto failed;
@ -3020,11 +3020,11 @@ static void __exit ko2iblnd_exit(void)
static int __init ko2iblnd_init(void)
{
CLASSERT(sizeof(struct kib_msg) <= IBLND_MSG_SIZE);
CLASSERT(offsetof(struct kib_msg,
BUILD_BUG_ON(sizeof(struct kib_msg) > IBLND_MSG_SIZE);
BUILD_BUG_ON(!offsetof(struct kib_msg,
ibm_u.get.ibgm_rd.rd_frags[IBLND_MAX_RDMA_FRAGS])
<= IBLND_MSG_SIZE);
CLASSERT(offsetof(struct kib_msg,
BUILD_BUG_ON(!offsetof(struct kib_msg,
ibm_u.putack.ibpam_rd.rd_frags[IBLND_MAX_RDMA_FRAGS])
<= IBLND_MSG_SIZE);

4
drivers/staging/lustre/lnet/klnds/socklnd/socklnd.c
View file

@ -2904,8 +2904,8 @@ static int __init ksocklnd_init(void)
int rc;
/* check ksnr_connected/connecting field large enough */
CLASSERT(SOCKLND_CONN_NTYPES <= 4);
CLASSERT(SOCKLND_CONN_ACK == SOCKLND_CONN_BULK_IN);
BUILD_BUG_ON(SOCKLND_CONN_NTYPES > 4);
BUILD_BUG_ON(SOCKLND_CONN_ACK != SOCKLND_CONN_BULK_IN);
/* initialize the_ksocklnd */
the_ksocklnd.lnd_type = SOCKLND;

2
drivers/staging/lustre/lnet/klnds/socklnd/socklnd_cb.c
View file

@ -1658,7 +1658,7 @@ ksocknal_parse_proto_version(ksock_hello_msg_t *hello)
if (hello->kshm_magic == le32_to_cpu(LNET_PROTO_TCP_MAGIC)) {
struct lnet_magicversion *hmv = (struct lnet_magicversion *)hello;
CLASSERT(sizeof(struct lnet_magicversion) ==
BUILD_BUG_ON(sizeof(struct lnet_magicversion) !=
offsetof(ksock_hello_msg_t, kshm_src_nid));
if (hmv->version_major == cpu_to_le16(KSOCK_PROTO_V1_MAJOR) &&

2
drivers/staging/lustre/lnet/klnds/socklnd/socklnd_proto.c
View file

@ -464,7 +464,7 @@ ksocknal_send_hello_v1(struct ksock_conn *conn, ksock_hello_msg_t *hello)
int rc;
int i;
CLASSERT(sizeof(struct lnet_magicversion) == offsetof(struct lnet_hdr, src_nid));
BUILD_BUG_ON(sizeof(struct lnet_magicversion) != offsetof(struct lnet_hdr, src_nid));
LIBCFS_ALLOC(hdr, sizeof(*hdr));
if (!hdr) {

2
drivers/staging/lustre/lnet/libcfs/hash.c
View file

@ -1000,7 +1000,7 @@ cfs_hash_create(char *name, unsigned int cur_bits, unsigned int max_bits,
struct cfs_hash *hs;
int len;
CLASSERT(CFS_HASH_THETA_BITS < 15);
BUILD_BUG_ON(CFS_HASH_THETA_BITS >= 15);
LASSERT(name);
LASSERT(ops->hs_key);

4
drivers/staging/lustre/lnet/lnet/acceptor.c
View file

@ -149,7 +149,7 @@ lnet_connect(struct socket **sockp, lnet_nid_t peer_nid,
int port;
int fatal;
CLASSERT(sizeof(cr) <= 16); /* not too big to be on the stack */
BUILD_BUG_ON(sizeof(cr) > 16); /* too big to be on the stack */
for (port = LNET_ACCEPTOR_MAX_RESERVED_PORT;
port >= LNET_ACCEPTOR_MIN_RESERVED_PORT;
@ -164,7 +164,7 @@ lnet_connect(struct socket **sockp, lnet_nid_t peer_nid,
continue;
}
CLASSERT(LNET_PROTO_ACCEPTOR_VERSION == 1);
BUILD_BUG_ON(LNET_PROTO_ACCEPTOR_VERSION != 1);
cr.acr_magic = LNET_PROTO_ACCEPTOR_MAGIC;
cr.acr_version = LNET_PROTO_ACCEPTOR_VERSION;

134
drivers/staging/lustre/lnet/lnet/api-ni.c
View file

@ -180,89 +180,89 @@ static void lnet_assert_wire_constants(void)
*/
/* Constants... */
CLASSERT(LNET_PROTO_TCP_MAGIC == 0xeebc0ded);
CLASSERT(LNET_PROTO_TCP_VERSION_MAJOR == 1);
CLASSERT(LNET_PROTO_TCP_VERSION_MINOR == 0);
CLASSERT(LNET_MSG_ACK == 0);
CLASSERT(LNET_MSG_PUT == 1);
CLASSERT(LNET_MSG_GET == 2);
CLASSERT(LNET_MSG_REPLY == 3);
CLASSERT(LNET_MSG_HELLO == 4);
BUILD_BUG_ON(LNET_PROTO_TCP_MAGIC != 0xeebc0ded);
BUILD_BUG_ON(LNET_PROTO_TCP_VERSION_MAJOR != 1);
BUILD_BUG_ON(LNET_PROTO_TCP_VERSION_MINOR != 0);
BUILD_BUG_ON(LNET_MSG_ACK != 0);
BUILD_BUG_ON(LNET_MSG_PUT != 1);
BUILD_BUG_ON(LNET_MSG_GET != 2);
BUILD_BUG_ON(LNET_MSG_REPLY != 3);
BUILD_BUG_ON(LNET_MSG_HELLO != 4);
/* Checks for struct ptl_handle_wire_t */
CLASSERT((int)sizeof(struct lnet_handle_wire) == 16);
CLASSERT((int)offsetof(struct lnet_handle_wire, wh_interface_cookie) == 0);
CLASSERT((int)sizeof(((struct lnet_handle_wire *)0)->wh_interface_cookie) == 8);
CLASSERT((int)offsetof(struct lnet_handle_wire, wh_object_cookie) == 8);
CLASSERT((int)sizeof(((struct lnet_handle_wire *)0)->wh_object_cookie) == 8);
BUILD_BUG_ON((int)sizeof(struct lnet_handle_wire) != 16);
BUILD_BUG_ON((int)offsetof(struct lnet_handle_wire, wh_interface_cookie) != 0);
BUILD_BUG_ON((int)sizeof(((struct lnet_handle_wire *)0)->wh_interface_cookie) != 8);
BUILD_BUG_ON((int)offsetof(struct lnet_handle_wire, wh_object_cookie) != 8);
BUILD_BUG_ON((int)sizeof(((struct lnet_handle_wire *)0)->wh_object_cookie) != 8);
/* Checks for struct struct lnet_magicversion */
CLASSERT((int)sizeof(struct lnet_magicversion) == 8);
CLASSERT((int)offsetof(struct lnet_magicversion, magic) == 0);
CLASSERT((int)sizeof(((struct lnet_magicversion *)0)->magic) == 4);
CLASSERT((int)offsetof(struct lnet_magicversion, version_major) == 4);
CLASSERT((int)sizeof(((struct lnet_magicversion *)0)->version_major) == 2);
CLASSERT((int)offsetof(struct lnet_magicversion, version_minor) == 6);
CLASSERT((int)sizeof(((struct lnet_magicversion *)0)->version_minor) == 2);
BUILD_BUG_ON((int)sizeof(struct lnet_magicversion) != 8);
BUILD_BUG_ON((int)offsetof(struct lnet_magicversion, magic) != 0);
BUILD_BUG_ON((int)sizeof(((struct lnet_magicversion *)0)->magic) != 4);
BUILD_BUG_ON((int)offsetof(struct lnet_magicversion, version_major) != 4);
BUILD_BUG_ON((int)sizeof(((struct lnet_magicversion *)0)->version_major) != 2);
BUILD_BUG_ON((int)offsetof(struct lnet_magicversion, version_minor) != 6);
BUILD_BUG_ON((int)sizeof(((struct lnet_magicversion *)0)->version_minor) != 2);
/* Checks for struct struct lnet_hdr */
CLASSERT((int)sizeof(struct lnet_hdr) == 72);
CLASSERT((int)offsetof(struct lnet_hdr, dest_nid) == 0);
CLASSERT((int)sizeof(((struct lnet_hdr *)0)->dest_nid) == 8);
CLASSERT((int)offsetof(struct lnet_hdr, src_nid) == 8);
CLASSERT((int)sizeof(((struct lnet_hdr *)0)->src_nid) == 8);
CLASSERT((int)offsetof(struct lnet_hdr, dest_pid) == 16);
CLASSERT((int)sizeof(((struct lnet_hdr *)0)->dest_pid) == 4);
CLASSERT((int)offsetof(struct lnet_hdr, src_pid) == 20);
CLASSERT((int)sizeof(((struct lnet_hdr *)0)->src_pid) == 4);
CLASSERT((int)offsetof(struct lnet_hdr, type) == 24);
CLASSERT((int)sizeof(((struct lnet_hdr *)0)->type) == 4);
CLASSERT((int)offsetof(struct lnet_hdr, payload_length) == 28);
CLASSERT((int)sizeof(((struct lnet_hdr *)0)->payload_length) == 4);
CLASSERT((int)offsetof(struct lnet_hdr, msg) == 32);
CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg) == 40);
BUILD_BUG_ON((int)sizeof(struct lnet_hdr) != 72);
BUILD_BUG_ON((int)offsetof(struct lnet_hdr, dest_nid) != 0);
BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->dest_nid) != 8);
BUILD_BUG_ON((int)offsetof(struct lnet_hdr, src_nid) != 8);
BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->src_nid) != 8);
BUILD_BUG_ON((int)offsetof(struct lnet_hdr, dest_pid) != 16);
BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->dest_pid) != 4);
BUILD_BUG_ON((int)offsetof(struct lnet_hdr, src_pid) != 20);
BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->src_pid) != 4);
BUILD_BUG_ON((int)offsetof(struct lnet_hdr, type) != 24);
BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->type) != 4);
BUILD_BUG_ON((int)offsetof(struct lnet_hdr, payload_length) != 28);
BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->payload_length) != 4);
BUILD_BUG_ON((int)offsetof(struct lnet_hdr, msg) != 32);
BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->msg) != 40);
/* Ack */
CLASSERT((int)offsetof(struct lnet_hdr, msg.ack.dst_wmd) == 32);
CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.ack.dst_wmd) == 16);
CLASSERT((int)offsetof(struct lnet_hdr, msg.ack.match_bits) == 48);
CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.ack.match_bits) == 8);
CLASSERT((int)offsetof(struct lnet_hdr, msg.ack.mlength) == 56);
CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.ack.mlength) == 4);
BUILD_BUG_ON((int)offsetof(struct lnet_hdr, msg.ack.dst_wmd) != 32);
BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->msg.ack.dst_wmd) != 16);
BUILD_BUG_ON((int)offsetof(struct lnet_hdr, msg.ack.match_bits) != 48);
BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->msg.ack.match_bits) != 8);
BUILD_BUG_ON((int)offsetof(struct lnet_hdr, msg.ack.mlength) != 56);
BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->msg.ack.mlength) != 4);
/* Put */
CLASSERT((int)offsetof(struct lnet_hdr, msg.put.ack_wmd) == 32);
CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.put.ack_wmd) == 16);
CLASSERT((int)offsetof(struct lnet_hdr, msg.put.match_bits) == 48);
CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.put.match_bits) == 8);
CLASSERT((int)offsetof(struct lnet_hdr, msg.put.hdr_data) == 56);
CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.put.hdr_data) == 8);
CLASSERT((int)offsetof(struct lnet_hdr, msg.put.ptl_index) == 64);
CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.put.ptl_index) == 4);
CLASSERT((int)offsetof(struct lnet_hdr, msg.put.offset) == 68);
CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.put.offset) == 4);
BUILD_BUG_ON((int)offsetof(struct lnet_hdr, msg.put.ack_wmd) != 32);
BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->msg.put.ack_wmd) != 16);
BUILD_BUG_ON((int)offsetof(struct lnet_hdr, msg.put.match_bits) != 48);
BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->msg.put.match_bits) != 8);
BUILD_BUG_ON((int)offsetof(struct lnet_hdr, msg.put.hdr_data) != 56);
BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->msg.put.hdr_data) != 8);
BUILD_BUG_ON((int)offsetof(struct lnet_hdr, msg.put.ptl_index) != 64);
BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->msg.put.ptl_index) != 4);
BUILD_BUG_ON((int)offsetof(struct lnet_hdr, msg.put.offset) != 68);
BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->msg.put.offset) != 4);
/* Get */
CLASSERT((int)offsetof(struct lnet_hdr, msg.get.return_wmd) == 32);
CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.get.return_wmd) == 16);
CLASSERT((int)offsetof(struct lnet_hdr, msg.get.match_bits) == 48);
CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.get.match_bits) == 8);
CLASSERT((int)offsetof(struct lnet_hdr, msg.get.ptl_index) == 56);
CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.get.ptl_index) == 4);
CLASSERT((int)offsetof(struct lnet_hdr, msg.get.src_offset) == 60);
CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.get.src_offset) == 4);
CLASSERT((int)offsetof(struct lnet_hdr, msg.get.sink_length) == 64);
CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.get.sink_length) == 4);
BUILD_BUG_ON((int)offsetof(struct lnet_hdr, msg.get.return_wmd) != 32);
BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->msg.get.return_wmd) != 16);
BUILD_BUG_ON((int)offsetof(struct lnet_hdr, msg.get.match_bits) != 48);
BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->msg.get.match_bits) != 8);
BUILD_BUG_ON((int)offsetof(struct lnet_hdr, msg.get.ptl_index) != 56);
BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->msg.get.ptl_index) != 4);
BUILD_BUG_ON((int)offsetof(struct lnet_hdr, msg.get.src_offset) != 60);
BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->msg.get.src_offset) != 4);
BUILD_BUG_ON((int)offsetof(struct lnet_hdr, msg.get.sink_length) != 64);
BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->msg.get.sink_length) != 4);
/* Reply */
CLASSERT((int)offsetof(struct lnet_hdr, msg.reply.dst_wmd) == 32);
CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.reply.dst_wmd) == 16);
BUILD_BUG_ON((int)offsetof(struct lnet_hdr, msg.reply.dst_wmd) != 32);
BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->msg.reply.dst_wmd) != 16);
/* Hello */
CLASSERT((int)offsetof(struct lnet_hdr, msg.hello.incarnation) == 32);
CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.hello.incarnation) == 8);
CLASSERT((int)offsetof(struct lnet_hdr, msg.hello.type) == 40);
CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.hello.type) == 4);
BUILD_BUG_ON((int)offsetof(struct lnet_hdr, msg.hello.incarnation) != 32);
BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->msg.hello.incarnation) != 8);
BUILD_BUG_ON((int)offsetof(struct lnet_hdr, msg.hello.type) != 40);
BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->msg.hello.type) != 4);
}
static lnd_t *

2
drivers/staging/lustre/lnet/lnet/lib-socket.c
View file

@ -97,7 +97,7 @@ lnet_ipif_query(char *name, int *up, __u32 *ip, __u32 *mask)
return -EINVAL;
}
CLASSERT(sizeof(ifr.ifr_name) >= IFNAMSIZ);
BUILD_BUG_ON(sizeof(ifr.ifr_name) < IFNAMSIZ);
if (strlen(name) > sizeof(ifr.ifr_name) - 1)
return -E2BIG;

8
drivers/staging/lustre/lnet/lnet/net_fault.c
View file

@ -997,10 +997,10 @@ lnet_fault_ctl(int opc, struct libcfs_ioctl_data *data)
int
lnet_fault_init(void)
{
CLASSERT(LNET_PUT_BIT == 1 << LNET_MSG_PUT);
CLASSERT(LNET_ACK_BIT == 1 << LNET_MSG_ACK);
CLASSERT(LNET_GET_BIT == 1 << LNET_MSG_GET);
CLASSERT(LNET_REPLY_BIT == 1 << LNET_MSG_REPLY);
BUILD_BUG_ON(LNET_PUT_BIT != 1 << LNET_MSG_PUT);
BUILD_BUG_ON(LNET_ACK_BIT != 1 << LNET_MSG_ACK);
BUILD_BUG_ON(LNET_GET_BIT != 1 << LNET_MSG_GET);
BUILD_BUG_ON(LNET_REPLY_BIT != 1 << LNET_MSG_REPLY);
mutex_init(&delay_dd.dd_mutex);
spin_lock_init(&delay_dd.dd_lock);

4
drivers/staging/lustre/lnet/lnet/router_proc.c
View file

@ -139,7 +139,7 @@ static int proc_lnet_routes(struct ctl_table *table, int write,
int ver;
int off;
CLASSERT(sizeof(loff_t) >= 4);
BUILD_BUG_ON(sizeof(loff_t) < 4);
off = LNET_PROC_HOFF_GET(*ppos);
ver = LNET_PROC_VER_GET(*ppos);
@ -404,7 +404,7 @@ static int proc_lnet_peers(struct ctl_table *table, int write,
int rc = 0;
int len;
CLASSERT(LNET_PROC_HASH_BITS >= LNET_PEER_HASH_BITS);
BUILD_BUG_ON(LNET_PROC_HASH_BITS < LNET_PEER_HASH_BITS);
LASSERT(!write);
if (!*lenp)

2
drivers/staging/lustre/lustre/include/cl_object.h
View file

@ -2311,7 +2311,7 @@ struct cl_io *cl_io_top(struct cl_io *io);
do { \
typeof(foo_io) __foo_io = (foo_io); \
\
CLASSERT(offsetof(typeof(*__foo_io), base) == 0); \
BUILD_BUG_ON(offsetof(typeof(*__foo_io), base) != 0); \
memset(&__foo_io->base + 1, 0, \
sizeof(*__foo_io) - sizeof(__foo_io->base)); \
} while (0)

2
drivers/staging/lustre/lustre/include/lu_object.h
View file

@ -1120,7 +1120,7 @@ struct lu_context_key {
{ \
type *value; \
\
CLASSERT(PAGE_SIZE >= sizeof(*value)); \
BUILD_BUG_ON(PAGE_SIZE < sizeof(*value)); \
\
value = kzalloc(sizeof(*value), GFP_NOFS); \
if (!value) \

4
drivers/staging/lustre/lustre/include/lustre_net.h
View file

@ -315,8 +315,8 @@ struct ptlrpc_client {
union ptlrpc_async_args {
/**
* Scratchpad for passing args to completion interpreter. Users
* cast to the struct of their choosing, and CLASSERT that this is
* big enough. For _tons_ of context, kmalloc a struct and store
* cast to the struct of their choosing, and BUILD_BUG_ON oversized
* arguments. For _tons_ of context, kmalloc a struct and store
* a pointer to it here. The pointer_arg ensures this struct is at
* least big enough for that.
*/

2
drivers/staging/lustre/lustre/ldlm/ldlm_request.c
View file

@ -1972,7 +1972,7 @@ static int replay_one_lock(struct obd_import *imp, struct ldlm_lock *lock)
LDLM_DEBUG(lock, "replaying lock:");
atomic_inc(&req->rq_import->imp_replay_inflight);
CLASSERT(sizeof(*aa) <= sizeof(req->rq_async_args));
BUILD_BUG_ON(sizeof(*aa) > sizeof(req->rq_async_args));
aa = ptlrpc_req_async_args(req);
aa->lock_handle = body->lock_handle[0];
req->rq_interpret_reply = (ptlrpc_interpterer_t)replay_lock_interpret;

2
drivers/staging/lustre/lustre/ldlm/ldlm_resource.c
View file

@ -1368,7 +1368,7 @@ void ldlm_resource_dump(int level, struct ldlm_resource *res)
struct ldlm_lock *lock;
unsigned int granted = 0;
CLASSERT(RES_NAME_SIZE == 4);
BUILD_BUG_ON(RES_NAME_SIZE != 4);
if (!((libcfs_debug | D_ERROR) & level))
return;

2
drivers/staging/lustre/lustre/llite/super25.c
View file

@ -88,7 +88,7 @@ static int __init lustre_init(void)
struct timespec64 ts;
int i, rc, seed[2];
CLASSERT(sizeof(LUSTRE_VOLATILE_HDR) == LUSTRE_VOLATILE_HDR_LEN + 1);
BUILD_BUG_ON(sizeof(LUSTRE_VOLATILE_HDR) != LUSTRE_VOLATILE_HDR_LEN + 1);
/* print an address of _any_ initialized kernel symbol from this
* module, to allow debugging with gdb that doesn't support data

2
drivers/staging/lustre/lustre/llite/vvp_dev.c
View file

@ -391,7 +391,7 @@ struct vvp_pgcache_id {
static void vvp_pgcache_id_unpack(loff_t pos, struct vvp_pgcache_id *id)
{
CLASSERT(sizeof(pos) == sizeof(__u64));
BUILD_BUG_ON(sizeof(pos) != sizeof(__u64));
id->vpi_index = pos & 0xffffffff;
id->vpi_depth = (pos >> PGC_DEPTH_SHIFT) & 0xf;

6
drivers/staging/lustre/lustre/lov/lov_pack.c
View file

@ -136,7 +136,7 @@ ssize_t lov_lsm_pack(const struct lov_stripe_md *lsm, void *buf,
lmmv1->lmm_layout_gen = cpu_to_le16(lsm->lsm_layout_gen);
if (lsm->lsm_magic == LOV_MAGIC_V3) {
CLASSERT(sizeof(lsm->lsm_pool_name) ==
BUILD_BUG_ON(sizeof(lsm->lsm_pool_name) !=
sizeof(lmmv3->lmm_pool_name));
strlcpy(lmmv3->lmm_pool_name, lsm->lsm_pool_name,
sizeof(lmmv3->lmm_pool_name));
@ -357,8 +357,8 @@ int lov_getstripe(struct lov_object *obj, struct lov_stripe_md *lsm,
/* FIXME: Bug 1185 - copy fields properly when structs change */
/* struct lov_user_md_v3 and struct lov_mds_md_v3 must be the same */
CLASSERT(sizeof(lum) == sizeof(struct lov_mds_md_v3));
CLASSERT(sizeof(lum.lmm_objects[0]) == sizeof(lmmk->lmm_objects[0]));
BUILD_BUG_ON(sizeof(lum) != sizeof(struct lov_mds_md_v3));
BUILD_BUG_ON(sizeof(lum.lmm_objects[0]) != sizeof(lmmk->lmm_objects[0]));
if (cpu_to_le32(LOV_MAGIC) != LOV_MAGIC &&
(lmmk->lmm_magic == cpu_to_le32(LOV_MAGIC_V1) ||

12
drivers/staging/lustre/lustre/mdc/mdc_lib.c
View file

@ -125,7 +125,7 @@ void mdc_create_pack(struct ptlrpc_request *req, struct md_op_data *op_data,
char *tmp;
__u64 flags;
CLASSERT(sizeof(struct mdt_rec_reint) == sizeof(struct mdt_rec_create));
BUILD_BUG_ON(sizeof(struct mdt_rec_reint) != sizeof(struct mdt_rec_create));
rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT);
rec->cr_opcode = REINT_CREATE;
@ -189,7 +189,7 @@ void mdc_open_pack(struct ptlrpc_request *req, struct md_op_data *op_data,
char *tmp;
__u64 cr_flags;
CLASSERT(sizeof(struct mdt_rec_reint) == sizeof(struct mdt_rec_create));
BUILD_BUG_ON(sizeof(struct mdt_rec_reint) != sizeof(struct mdt_rec_create));
rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT);
/* XXX do something about time, uid, gid */
@ -313,7 +313,7 @@ void mdc_setattr_pack(struct ptlrpc_request *req, struct md_op_data *op_data,
struct mdt_rec_setattr *rec;
struct lov_user_md *lum = NULL;
CLASSERT(sizeof(struct mdt_rec_reint) ==
BUILD_BUG_ON(sizeof(struct mdt_rec_reint) !=
sizeof(struct mdt_rec_setattr));
rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT);
mdc_setattr_pack_rec(rec, op_data);
@ -336,7 +336,7 @@ void mdc_unlink_pack(struct ptlrpc_request *req, struct md_op_data *op_data)
{
struct mdt_rec_unlink *rec;
CLASSERT(sizeof(struct mdt_rec_reint) == sizeof(struct mdt_rec_unlink));
BUILD_BUG_ON(sizeof(struct mdt_rec_reint) != sizeof(struct mdt_rec_unlink));
rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT);
rec->ul_opcode = op_data->op_cli_flags & CLI_RM_ENTRY ?
@ -359,7 +359,7 @@ void mdc_link_pack(struct ptlrpc_request *req, struct md_op_data *op_data)
{
struct mdt_rec_link *rec;
CLASSERT(sizeof(struct mdt_rec_reint) == sizeof(struct mdt_rec_link));
BUILD_BUG_ON(sizeof(struct mdt_rec_reint) != sizeof(struct mdt_rec_link));
rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT);
rec->lk_opcode = REINT_LINK;
@ -407,7 +407,7 @@ void mdc_rename_pack(struct ptlrpc_request *req, struct md_op_data *op_data,
{
struct mdt_rec_rename *rec;
CLASSERT(sizeof(struct mdt_rec_reint) == sizeof(struct mdt_rec_rename));
BUILD_BUG_ON(sizeof(struct mdt_rec_reint) != sizeof(struct mdt_rec_rename));
rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT);
/* XXX do something about time, uid, gid */

2
drivers/staging/lustre/lustre/mdc/mdc_locks.c
View file

@ -1196,7 +1196,7 @@ int mdc_intent_getattr_async(struct obd_export *exp,
return rc;
}
CLASSERT(sizeof(*ga) <= sizeof(req->rq_async_args));
BUILD_BUG_ON(sizeof(*ga) > sizeof(req->rq_async_args));
ga = ptlrpc_req_async_args(req);
ga->ga_exp = exp;
ga->ga_minfo = minfo;

2
drivers/staging/lustre/lustre/mdc/mdc_request.c
View file

@ -295,7 +295,7 @@ static int mdc_xattr_common(struct obd_export *exp,
if (opcode == MDS_REINT) {
struct mdt_rec_setxattr *rec;
CLASSERT(sizeof(struct mdt_rec_setxattr) ==
BUILD_BUG_ON(sizeof(struct mdt_rec_setxattr) !=
sizeof(struct mdt_rec_reint));
rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT);
rec->sx_opcode = REINT_SETXATTR;

2
drivers/staging/lustre/lustre/osc/osc_io.c
View file

@ -699,7 +699,7 @@ static int osc_io_data_version_start(const struct lu_env *env,
ptlrpc_request_set_replen(req);
req->rq_interpret_reply = osc_data_version_interpret;
CLASSERT(sizeof(*dva) <= sizeof(req->rq_async_args));
BUILD_BUG_ON(sizeof(*dva) > sizeof(req->rq_async_args));
dva = ptlrpc_req_async_args(req);
dva->dva_oio = oio;

16
drivers/staging/lustre/lustre/osc/osc_request.c
View file

@ -251,7 +251,7 @@ int osc_setattr_async(struct obd_export *exp, struct obdo *oa,
req->rq_interpret_reply =
(ptlrpc_interpterer_t)osc_setattr_interpret;
CLASSERT(sizeof(*sa) <= sizeof(req->rq_async_args));
BUILD_BUG_ON(sizeof(*sa) > sizeof(req->rq_async_args));
sa = ptlrpc_req_async_args(req);
sa->sa_oa = oa;
sa->sa_upcall = upcall;
@ -349,7 +349,7 @@ int osc_punch_base(struct obd_export *exp, struct obdo *oa,
ptlrpc_request_set_replen(req);
req->rq_interpret_reply = (ptlrpc_interpterer_t)osc_setattr_interpret;
CLASSERT(sizeof(*sa) <= sizeof(req->rq_async_args));
BUILD_BUG_ON(sizeof(*sa) > sizeof(req->rq_async_args));
sa = ptlrpc_req_async_args(req);
sa->sa_oa = oa;
sa->sa_upcall = upcall;
@ -430,7 +430,7 @@ int osc_sync_base(struct osc_object *obj, struct obdo *oa,
ptlrpc_request_set_replen(req);
req->rq_interpret_reply = osc_sync_interpret;
CLASSERT(sizeof(*fa) <= sizeof(req->rq_async_args));
BUILD_BUG_ON(sizeof(*fa) > sizeof(req->rq_async_args));
fa = ptlrpc_req_async_args(req);
fa->fa_obj = obj;
fa->fa_oa = oa;
@ -1171,7 +1171,7 @@ static int osc_brw_prep_request(int cmd, struct client_obd *cli,
}
ptlrpc_request_set_replen(req);
CLASSERT(sizeof(*aa) <= sizeof(req->rq_async_args));
BUILD_BUG_ON(sizeof(*aa) > sizeof(req->rq_async_args));
aa = ptlrpc_req_async_args(req);
aa->aa_oa = oa;
aa->aa_requested_nob = requested_nob;
@ -1758,7 +1758,7 @@ int osc_build_rpc(const struct lu_env *env, struct client_obd *cli,
cl_req_attr_set(env, osc2cl(obj), crattr);
lustre_msg_set_jobid(req->rq_reqmsg, crattr->cra_jobid);
CLASSERT(sizeof(*aa) <= sizeof(req->rq_async_args));
BUILD_BUG_ON(sizeof(*aa) > sizeof(req->rq_async_args));
aa = ptlrpc_req_async_args(req);
INIT_LIST_HEAD(&aa->aa_oaps);
list_splice_init(&rpc_list, &aa->aa_oaps);
@ -2039,7 +2039,7 @@ int osc_enqueue_base(struct obd_export *exp, struct ldlm_res_id *res_id,
if (!rc) {
struct osc_enqueue_args *aa;
CLASSERT(sizeof(*aa) <= sizeof(req->rq_async_args));
BUILD_BUG_ON(sizeof(*aa) > sizeof(req->rq_async_args));
aa = ptlrpc_req_async_args(req);
aa->oa_exp = exp;
aa->oa_mode = einfo->ei_mode;
@ -2196,7 +2196,7 @@ static int osc_statfs_async(struct obd_export *exp,
}
req->rq_interpret_reply = (ptlrpc_interpterer_t)osc_statfs_interpret;
CLASSERT(sizeof(*aa) <= sizeof(req->rq_async_args));
BUILD_BUG_ON(sizeof(*aa) > sizeof(req->rq_async_args));
aa = ptlrpc_req_async_args(req);
aa->aa_oi = oinfo;
@ -2401,7 +2401,7 @@ static int osc_set_info_async(const struct lu_env *env, struct obd_export *exp,
struct osc_brw_async_args *aa;
struct obdo *oa;
CLASSERT(sizeof(*aa) <= sizeof(req->rq_async_args));
BUILD_BUG_ON(sizeof(*aa) > sizeof(req->rq_async_args));
aa = ptlrpc_req_async_args(req);
oa = kmem_cache_zalloc(obdo_cachep, GFP_NOFS);
if (!oa) {

4
drivers/staging/lustre/lustre/ptlrpc/client.c
View file

@ -3070,7 +3070,7 @@ void ptlrpc_init_xid(void)
}
/* Always need to be aligned to a power-of-two for multi-bulk BRW */
CLASSERT(((PTLRPC_BULK_OPS_COUNT - 1) & PTLRPC_BULK_OPS_COUNT) == 0);
BUILD_BUG_ON(((PTLRPC_BULK_OPS_COUNT - 1) & PTLRPC_BULK_OPS_COUNT) != 0);
ptlrpc_last_xid &= PTLRPC_BULK_OPS_MASK;
}
@ -3256,7 +3256,7 @@ void *ptlrpcd_alloc_work(struct obd_import *imp,
req->rq_no_resend = 1;
req->rq_pill.rc_fmt = (void *)&worker_format;
CLASSERT(sizeof(*args) <= sizeof(req->rq_async_args));
BUILD_BUG_ON(sizeof(*args) > sizeof(req->rq_async_args));
args = ptlrpc_req_async_args(req);
args->cb = cb;
args->cbdata = cbdata;

2
drivers/staging/lustre/lustre/ptlrpc/import.c
View file

@ -703,7 +703,7 @@ int ptlrpc_connect_import(struct obd_import *imp)
ptlrpc_request_set_replen(request);
request->rq_interpret_reply = ptlrpc_connect_interpret;
CLASSERT(sizeof(*aa) <= sizeof(request->rq_async_args));
BUILD_BUG_ON(sizeof(*aa) > sizeof(request->rq_async_args));
aa = ptlrpc_req_async_args(request);
memset(aa, 0, sizeof(*aa));

102
drivers/staging/lustre/lustre/ptlrpc/pack_generic.c
View file

@ -510,8 +510,8 @@ static int lustre_unpack_msg_v2(struct lustre_msg_v2 *m, int len)
__swab32s(&m->lm_repsize);
__swab32s(&m->lm_cksum);
__swab32s(&m->lm_flags);
CLASSERT(offsetof(typeof(*m), lm_padding_2) != 0);
CLASSERT(offsetof(typeof(*m), lm_padding_3) != 0);
BUILD_BUG_ON(offsetof(typeof(*m), lm_padding_2) == 0);
BUILD_BUG_ON(offsetof(typeof(*m), lm_padding_3) == 0);
}
required_len = lustre_msg_hdr_size_v2(m->lm_bufcount);
@ -1526,18 +1526,18 @@ void lustre_swab_ptlrpc_body(struct ptlrpc_body *b)
__swab64s(&b->pb_pre_versions[2]);
__swab64s(&b->pb_pre_versions[3]);
__swab64s(&b->pb_mbits);
CLASSERT(offsetof(typeof(*b), pb_padding0) != 0);
CLASSERT(offsetof(typeof(*b), pb_padding1) != 0);
CLASSERT(offsetof(typeof(*b), pb_padding64_0) != 0);
CLASSERT(offsetof(typeof(*b), pb_padding64_1) != 0);
CLASSERT(offsetof(typeof(*b), pb_padding64_2) != 0);
BUILD_BUG_ON(offsetof(typeof(*b), pb_padding0) == 0);
BUILD_BUG_ON(offsetof(typeof(*b), pb_padding1) == 0);
BUILD_BUG_ON(offsetof(typeof(*b), pb_padding64_0) == 0);
BUILD_BUG_ON(offsetof(typeof(*b), pb_padding64_1) == 0);
BUILD_BUG_ON(offsetof(typeof(*b), pb_padding64_2) == 0);
/* While we need to maintain compatibility between
* clients and servers without ptlrpc_body_v2 (< 2.3)
* do not swab any fields beyond pb_jobid, as we are
* using this swab function for both ptlrpc_body
* and ptlrpc_body_v2.
*/
CLASSERT(offsetof(typeof(*b), pb_jobid) != 0);
BUILD_BUG_ON(offsetof(typeof(*b), pb_jobid) == 0);
}
void lustre_swab_connect(struct obd_connect_data *ocd)
@ -1568,23 +1568,23 @@ void lustre_swab_connect(struct obd_connect_data *ocd)
__swab64s(&ocd->ocd_maxbytes);
if (ocd->ocd_connect_flags & OBD_CONNECT_MULTIMODRPCS)
__swab16s(&ocd->ocd_maxmodrpcs);
CLASSERT(offsetof(typeof(*ocd), padding0));
CLASSERT(offsetof(typeof(*ocd), padding1) != 0);
BUILD_BUG_ON(!offsetof(typeof(*ocd), padding0));
BUILD_BUG_ON(offsetof(typeof(*ocd), padding1) == 0);
if (ocd->ocd_connect_flags & OBD_CONNECT_FLAGS2)
__swab64s(&ocd->ocd_connect_flags2);
CLASSERT(offsetof(typeof(*ocd), padding3) != 0);
CLASSERT(offsetof(typeof(*ocd), padding4) != 0);
CLASSERT(offsetof(typeof(*ocd), padding5) != 0);
CLASSERT(offsetof(typeof(*ocd), padding6) != 0);
CLASSERT(offsetof(typeof(*ocd), padding7) != 0);
CLASSERT(offsetof(typeof(*ocd), padding8) != 0);
CLASSERT(offsetof(typeof(*ocd), padding9) != 0);
CLASSERT(offsetof(typeof(*ocd), paddingA) != 0);
CLASSERT(offsetof(typeof(*ocd), paddingB) != 0);
CLASSERT(offsetof(typeof(*ocd), paddingC) != 0);
CLASSERT(offsetof(typeof(*ocd), paddingD) != 0);
CLASSERT(offsetof(typeof(*ocd), paddingE) != 0);
CLASSERT(offsetof(typeof(*ocd), paddingF) != 0);
BUILD_BUG_ON(offsetof(typeof(*ocd), padding3) == 0);
BUILD_BUG_ON(offsetof(typeof(*ocd), padding4) == 0);
BUILD_BUG_ON(offsetof(typeof(*ocd), padding5) == 0);
BUILD_BUG_ON(offsetof(typeof(*ocd), padding6) == 0);
BUILD_BUG_ON(offsetof(typeof(*ocd), padding7) == 0);
BUILD_BUG_ON(offsetof(typeof(*ocd), padding8) == 0);
BUILD_BUG_ON(offsetof(typeof(*ocd), padding9) == 0);
BUILD_BUG_ON(offsetof(typeof(*ocd), paddingA) == 0);
BUILD_BUG_ON(offsetof(typeof(*ocd), paddingB) == 0);
BUILD_BUG_ON(offsetof(typeof(*ocd), paddingC) == 0);
BUILD_BUG_ON(offsetof(typeof(*ocd), paddingD) == 0);
BUILD_BUG_ON(offsetof(typeof(*ocd), paddingE) == 0);
BUILD_BUG_ON(offsetof(typeof(*ocd), paddingF) == 0);
}
static void lustre_swab_obdo(struct obdo *o)
@ -1614,9 +1614,9 @@ static void lustre_swab_obdo(struct obdo *o)
__swab32s(&o->o_uid_h);
__swab32s(&o->o_gid_h);
__swab64s(&o->o_data_version);
CLASSERT(offsetof(typeof(*o), o_padding_4) != 0);
CLASSERT(offsetof(typeof(*o), o_padding_5) != 0);
CLASSERT(offsetof(typeof(*o), o_padding_6) != 0);
BUILD_BUG_ON(offsetof(typeof(*o), o_padding_4) == 0);
BUILD_BUG_ON(offsetof(typeof(*o), o_padding_5) == 0);
BUILD_BUG_ON(offsetof(typeof(*o), o_padding_6) == 0);
}
void lustre_swab_obd_statfs(struct obd_statfs *os)
@ -1632,15 +1632,15 @@ void lustre_swab_obd_statfs(struct obd_statfs *os)
__swab32s(&os->os_namelen);
__swab64s(&os->os_maxbytes);
__swab32s(&os->os_state);
CLASSERT(offsetof(typeof(*os), os_fprecreated) != 0);
CLASSERT(offsetof(typeof(*os), os_spare2) != 0);
CLASSERT(offsetof(typeof(*os), os_spare3) != 0);
CLASSERT(offsetof(typeof(*os), os_spare4) != 0);
CLASSERT(offsetof(typeof(*os), os_spare5) != 0);
CLASSERT(offsetof(typeof(*os), os_spare6) != 0);
CLASSERT(offsetof(typeof(*os), os_spare7) != 0);
CLASSERT(offsetof(typeof(*os), os_spare8) != 0);
CLASSERT(offsetof(typeof(*os), os_spare9) != 0);
BUILD_BUG_ON(offsetof(typeof(*os), os_fprecreated) == 0);
BUILD_BUG_ON(offsetof(typeof(*os), os_spare2) == 0);
BUILD_BUG_ON(offsetof(typeof(*os), os_spare3) == 0);
BUILD_BUG_ON(offsetof(typeof(*os), os_spare4) == 0);
BUILD_BUG_ON(offsetof(typeof(*os), os_spare5) == 0);
BUILD_BUG_ON(offsetof(typeof(*os), os_spare6) == 0);
BUILD_BUG_ON(offsetof(typeof(*os), os_spare7) == 0);
BUILD_BUG_ON(offsetof(typeof(*os), os_spare8) == 0);
BUILD_BUG_ON(offsetof(typeof(*os), os_spare9) == 0);
}
void lustre_swab_obd_ioobj(struct obd_ioobj *ioo)
@ -1680,7 +1680,7 @@ void lustre_swab_gl_desc(union ldlm_gl_desc *desc)
__swab64s(&desc->lquota_desc.gl_hardlimit);
__swab64s(&desc->lquota_desc.gl_softlimit);
__swab64s(&desc->lquota_desc.gl_time);
CLASSERT(offsetof(typeof(desc->lquota_desc), gl_pad2) != 0);
BUILD_BUG_ON(offsetof(typeof(desc->lquota_desc), gl_pad2) == 0);
}
void lustre_swab_ost_lvb_v1(struct ost_lvb_v1 *lvb)
@ -1739,24 +1739,24 @@ void lustre_swab_mdt_body(struct mdt_body *b)
__swab32s(&b->mbo_flags);
__swab32s(&b->mbo_rdev);
__swab32s(&b->mbo_nlink);
CLASSERT(offsetof(typeof(*b), mbo_unused2) != 0);
BUILD_BUG_ON(offsetof(typeof(*b), mbo_unused2) == 0);
__swab32s(&b->mbo_suppgid);
__swab32s(&b->mbo_eadatasize);
__swab32s(&b->mbo_aclsize);
__swab32s(&b->mbo_max_mdsize);
CLASSERT(offsetof(typeof(*b), mbo_unused3));
BUILD_BUG_ON(!offsetof(typeof(*b), mbo_unused3));
__swab32s(&b->mbo_uid_h);
__swab32s(&b->mbo_gid_h);
CLASSERT(offsetof(typeof(*b), mbo_padding_5) != 0);
BUILD_BUG_ON(offsetof(typeof(*b), mbo_padding_5) == 0);
}
void lustre_swab_mdt_ioepoch(struct mdt_ioepoch *b)
{
/* handle is opaque */
/* mio_handle is opaque */
CLASSERT(offsetof(typeof(*b), mio_unused1));
CLASSERT(offsetof(typeof(*b), mio_unused2));
CLASSERT(offsetof(typeof(*b), mio_padding));
BUILD_BUG_ON(!offsetof(typeof(*b), mio_unused1));
BUILD_BUG_ON(!offsetof(typeof(*b), mio_unused2));
BUILD_BUG_ON(!offsetof(typeof(*b), mio_padding));
}
void lustre_swab_mgs_target_info(struct mgs_target_info *mti)
@ -1769,7 +1769,7 @@ void lustre_swab_mgs_target_info(struct mgs_target_info *mti)
__swab32s(&mti->mti_flags);
__swab32s(&mti->mti_instance);
__swab32s(&mti->mti_nid_count);
CLASSERT(sizeof(lnet_nid_t) == sizeof(__u64));
BUILD_BUG_ON(sizeof(lnet_nid_t) != sizeof(__u64));
for (i = 0; i < MTI_NIDS_MAX; i++)
__swab64s(&mti->mti_nids[i]);
}
@ -1785,13 +1785,13 @@ void lustre_swab_mgs_nidtbl_entry(struct mgs_nidtbl_entry *entry)
/* mne_nid_(count|type) must be one byte size because we're gonna
* access it w/o swapping. */
CLASSERT(sizeof(entry->mne_nid_count) == sizeof(__u8));
CLASSERT(sizeof(entry->mne_nid_type) == sizeof(__u8));
BUILD_BUG_ON(sizeof(entry->mne_nid_count) != sizeof(__u8));
BUILD_BUG_ON(sizeof(entry->mne_nid_type) != sizeof(__u8));
/* remove this assertion if ipv6 is supported. */
LASSERT(entry->mne_nid_type == 0);
for (i = 0; i < entry->mne_nid_count; i++) {
CLASSERT(sizeof(lnet_nid_t) == sizeof(__u64));
BUILD_BUG_ON(sizeof(lnet_nid_t) != sizeof(__u64));
__swab64s(&entry->u.nids[i]);
}
}
@ -1829,7 +1829,7 @@ static void lustre_swab_obd_dqblk(struct obd_dqblk *b)
__swab64s(&b->dqb_btime);
__swab64s(&b->dqb_itime);
__swab32s(&b->dqb_valid);
CLASSERT(offsetof(typeof(*b), dqb_padding) != 0);
BUILD_BUG_ON(offsetof(typeof(*b), dqb_padding) == 0);
}
void lustre_swab_obd_quotactl(struct obd_quotactl *q)
@ -1900,7 +1900,7 @@ void lustre_swab_mdt_rec_reint (struct mdt_rec_reint *rr)
__swab32s(&rr->rr_flags_h);
__swab32s(&rr->rr_umask);
CLASSERT(offsetof(typeof(*rr), rr_padding_4) != 0);
BUILD_BUG_ON(offsetof(typeof(*rr), rr_padding_4) == 0);
};
void lustre_swab_lov_desc(struct lov_desc *ld)
@ -1949,7 +1949,7 @@ void lustre_swab_lmv_user_md(struct lmv_user_md *lum)
__swab32s(&lum->lum_stripe_offset);
__swab32s(&lum->lum_hash_type);
__swab32s(&lum->lum_type);
CLASSERT(offsetof(typeof(*lum), lum_padding1));
BUILD_BUG_ON(!offsetof(typeof(*lum), lum_padding1));
}
EXPORT_SYMBOL(lustre_swab_lmv_user_md);
@ -2038,7 +2038,7 @@ void lustre_swab_ldlm_intent(struct ldlm_intent *i)
static void lustre_swab_ldlm_resource_desc(struct ldlm_resource_desc *r)
{
__swab32s(&r->lr_type);
CLASSERT(offsetof(typeof(*r), lr_padding) != 0);
BUILD_BUG_ON(offsetof(typeof(*r), lr_padding) == 0);
lustre_swab_ldlm_res_id(&r->lr_name);
}
@ -2061,7 +2061,7 @@ void lustre_swab_ldlm_request(struct ldlm_request *rq)
void lustre_swab_ldlm_reply(struct ldlm_reply *r)
{
__swab32s(&r->lock_flags);
CLASSERT(offsetof(typeof(*r), lock_padding) != 0);
BUILD_BUG_ON(offsetof(typeof(*r), lock_padding) == 0);
lustre_swab_ldlm_lock_desc(&r->lock_desc);
/* lock_handle opaque */
__swab64s(&r->lock_policy_res1);

2
drivers/staging/lustre/lustre/ptlrpc/pers.c
View file

@ -45,7 +45,7 @@ void ptlrpc_fill_bulk_md(lnet_md_t *md, struct ptlrpc_bulk_desc *desc,
{
int offset = mdidx * LNET_MAX_IOV;
CLASSERT(PTLRPC_MAX_BRW_PAGES < LI_POISON);
BUILD_BUG_ON(PTLRPC_MAX_BRW_PAGES >= LI_POISON);
LASSERT(mdidx < desc->bd_md_max_brw);
LASSERT(desc->bd_iov_count <= PTLRPC_MAX_BRW_PAGES);

194
drivers/staging/lustre/lustre/ptlrpc/wiretest.c
View file

@ -61,7 +61,7 @@ void lustre_assert_wire_constants(void)
MDS_DIR_END_OFF);
LASSERTF(DEAD_HANDLE_MAGIC == 0xdeadbeefcafebabeULL, "found 0x%.16llxULL\n",
DEAD_HANDLE_MAGIC);
CLASSERT(MTI_NAME_MAXLEN == 64);
BUILD_BUG_ON(MTI_NAME_MAXLEN != 64);
LASSERTF(OST_REPLY == 0, "found %lld\n",
(long long)OST_REPLY);
LASSERTF(OST_GETATTR == 1, "found %lld\n",
@ -306,16 +306,16 @@ void lustre_assert_wire_constants(void)
(long long)LCK_MAXMODE);
LASSERTF(LCK_MODE_NUM == 8, "found %lld\n",
(long long)LCK_MODE_NUM);
CLASSERT(LDLM_PLAIN == 10);
CLASSERT(LDLM_EXTENT == 11);
CLASSERT(LDLM_FLOCK == 12);
CLASSERT(LDLM_IBITS == 13);
CLASSERT(LDLM_MAX_TYPE == 14);
CLASSERT(LUSTRE_RES_ID_SEQ_OFF == 0);
CLASSERT(LUSTRE_RES_ID_VER_OID_OFF == 1);
CLASSERT(LUSTRE_RES_ID_QUOTA_SEQ_OFF == 2);
CLASSERT(LUSTRE_RES_ID_QUOTA_VER_OID_OFF == 3);
CLASSERT(LUSTRE_RES_ID_HSH_OFF == 3);
BUILD_BUG_ON(LDLM_PLAIN != 10);
BUILD_BUG_ON(LDLM_EXTENT != 11);
BUILD_BUG_ON(LDLM_FLOCK != 12);
BUILD_BUG_ON(LDLM_IBITS != 13);
BUILD_BUG_ON(LDLM_MAX_TYPE != 14);
BUILD_BUG_ON(LUSTRE_RES_ID_SEQ_OFF != 0);
BUILD_BUG_ON(LUSTRE_RES_ID_VER_OID_OFF != 1);
BUILD_BUG_ON(LUSTRE_RES_ID_QUOTA_SEQ_OFF != 2);
BUILD_BUG_ON(LUSTRE_RES_ID_QUOTA_VER_OID_OFF != 3);
BUILD_BUG_ON(LUSTRE_RES_ID_HSH_OFF != 3);
LASSERTF(OBD_PING == 400, "found %lld\n",
(long long)OBD_PING);
LASSERTF(OBD_LOG_CANCEL == 401, "found %lld\n",
@ -661,7 +661,7 @@ void lustre_assert_wire_constants(void)
(long long)(int)offsetof(struct ptlrpc_body_v3, pb_slv));
LASSERTF((int)sizeof(((struct ptlrpc_body_v3 *)0)->pb_slv) == 8, "found %lld\n",
(long long)(int)sizeof(((struct ptlrpc_body_v3 *)0)->pb_slv));
CLASSERT(PTLRPC_NUM_VERSIONS == 4);
BUILD_BUG_ON(PTLRPC_NUM_VERSIONS != 4);
LASSERTF((int)offsetof(struct ptlrpc_body_v3, pb_pre_versions) == 88, "found %lld\n",
(long long)(int)offsetof(struct ptlrpc_body_v3, pb_pre_versions));
LASSERTF((int)sizeof(((struct ptlrpc_body_v3 *)0)->pb_pre_versions) == 32, "found %lld\n",
@ -682,7 +682,7 @@ void lustre_assert_wire_constants(void)
(long long)(int)offsetof(struct ptlrpc_body_v3, pb_padding64_2));
LASSERTF((int)sizeof(((struct ptlrpc_body_v3 *)0)->pb_padding64_2) == 8, "found %lld\n",
(long long)(int)sizeof(((struct ptlrpc_body_v3 *)0)->pb_padding64_2));
CLASSERT(LUSTRE_JOBID_SIZE == 32);
BUILD_BUG_ON(LUSTRE_JOBID_SIZE != 32);
LASSERTF((int)offsetof(struct ptlrpc_body_v3, pb_jobid) == 152, "found %lld\n",
(long long)(int)offsetof(struct ptlrpc_body_v3, pb_jobid));
LASSERTF((int)sizeof(((struct ptlrpc_body_v3 *)0)->pb_jobid) == 32, "found %lld\n",
@ -1319,27 +1319,27 @@ void lustre_assert_wire_constants(void)
OBD_MD_FLGETATTRLOCK);
LASSERTF(OBD_MD_FLDATAVERSION == (0x0010000000000000ULL), "found 0x%.16llxULL\n",
OBD_MD_FLDATAVERSION);
CLASSERT(OBD_FL_INLINEDATA == 0x00000001);
CLASSERT(OBD_FL_OBDMDEXISTS == 0x00000002);
CLASSERT(OBD_FL_DELORPHAN == 0x00000004);
CLASSERT(OBD_FL_NORPC == 0x00000008);
CLASSERT(OBD_FL_IDONLY == 0x00000010);
CLASSERT(OBD_FL_RECREATE_OBJS == 0x00000020);
CLASSERT(OBD_FL_DEBUG_CHECK == 0x00000040);
CLASSERT(OBD_FL_NO_USRQUOTA == 0x00000100);
CLASSERT(OBD_FL_NO_GRPQUOTA == 0x00000200);
CLASSERT(OBD_FL_CREATE_CROW == 0x00000400);
CLASSERT(OBD_FL_SRVLOCK == 0x00000800);
CLASSERT(OBD_FL_CKSUM_CRC32 == 0x00001000);
CLASSERT(OBD_FL_CKSUM_ADLER == 0x00002000);
CLASSERT(OBD_FL_CKSUM_CRC32C == 0x00004000);
CLASSERT(OBD_FL_CKSUM_RSVD2 == 0x00008000);
CLASSERT(OBD_FL_CKSUM_RSVD3 == 0x00010000);
CLASSERT(OBD_FL_SHRINK_GRANT == 0x00020000);
CLASSERT(OBD_FL_MMAP == 0x00040000);
CLASSERT(OBD_FL_RECOV_RESEND == 0x00080000);
CLASSERT(OBD_FL_NOSPC_BLK == 0x00100000);
CLASSERT(OBD_FL_LOCAL_MASK == 0xf0000000);
BUILD_BUG_ON(OBD_FL_INLINEDATA != 0x00000001);
BUILD_BUG_ON(OBD_FL_OBDMDEXISTS != 0x00000002);
BUILD_BUG_ON(OBD_FL_DELORPHAN != 0x00000004);
BUILD_BUG_ON(OBD_FL_NORPC != 0x00000008);
BUILD_BUG_ON(OBD_FL_IDONLY != 0x00000010);
BUILD_BUG_ON(OBD_FL_RECREATE_OBJS != 0x00000020);
BUILD_BUG_ON(OBD_FL_DEBUG_CHECK != 0x00000040);
BUILD_BUG_ON(OBD_FL_NO_USRQUOTA != 0x00000100);
BUILD_BUG_ON(OBD_FL_NO_GRPQUOTA != 0x00000200);
BUILD_BUG_ON(OBD_FL_CREATE_CROW != 0x00000400);
BUILD_BUG_ON(OBD_FL_SRVLOCK != 0x00000800);
BUILD_BUG_ON(OBD_FL_CKSUM_CRC32 != 0x00001000);
BUILD_BUG_ON(OBD_FL_CKSUM_ADLER != 0x00002000);
BUILD_BUG_ON(OBD_FL_CKSUM_CRC32C != 0x00004000);
BUILD_BUG_ON(OBD_FL_CKSUM_RSVD2 != 0x00008000);
BUILD_BUG_ON(OBD_FL_CKSUM_RSVD3 != 0x00010000);
BUILD_BUG_ON(OBD_FL_SHRINK_GRANT != 0x00020000);
BUILD_BUG_ON(OBD_FL_MMAP != 0x00040000);
BUILD_BUG_ON(OBD_FL_RECOV_RESEND != 0x00080000);
BUILD_BUG_ON(OBD_FL_NOSPC_BLK != 0x00100000);
BUILD_BUG_ON(OBD_FL_LOCAL_MASK != 0xf0000000);
/* Checks for struct lov_ost_data_v1 */
LASSERTF((int)sizeof(struct lov_ost_data_v1) == 24, "found %lld\n",
@ -1388,7 +1388,7 @@ void lustre_assert_wire_constants(void)
(long long)(int)offsetof(struct lov_mds_md_v1, lmm_objects[0]));
LASSERTF((int)sizeof(((struct lov_mds_md_v1 *)0)->lmm_objects[0]) == 24, "found %lld\n",
(long long)(int)sizeof(((struct lov_mds_md_v1 *)0)->lmm_objects[0]));
CLASSERT(LOV_MAGIC_V1 == (0x0BD10000 | 0x0BD0));
BUILD_BUG_ON(LOV_MAGIC_V1 != (0x0BD10000 | 0x0BD0));
/* Checks for struct lov_mds_md_v3 */
LASSERTF((int)sizeof(struct lov_mds_md_v3) == 48, "found %lld\n",
@ -1417,7 +1417,7 @@ void lustre_assert_wire_constants(void)
(long long)(int)offsetof(struct lov_mds_md_v3, lmm_layout_gen));
LASSERTF((int)sizeof(((struct lov_mds_md_v3 *)0)->lmm_layout_gen) == 2, "found %lld\n",
(long long)(int)sizeof(((struct lov_mds_md_v3 *)0)->lmm_layout_gen));
CLASSERT(LOV_MAXPOOLNAME == 15);
BUILD_BUG_ON(LOV_MAXPOOLNAME != 15);
LASSERTF((int)offsetof(struct lov_mds_md_v3, lmm_pool_name[16]) == 48, "found %lld\n",
(long long)(int)offsetof(struct lov_mds_md_v3, lmm_pool_name[16]));
LASSERTF((int)sizeof(((struct lov_mds_md_v3 *)0)->lmm_pool_name[16]) == 1, "found %lld\n",
@ -1426,7 +1426,7 @@ void lustre_assert_wire_constants(void)
(long long)(int)offsetof(struct lov_mds_md_v3, lmm_objects[0]));
LASSERTF((int)sizeof(((struct lov_mds_md_v3 *)0)->lmm_objects[0]) == 24, "found %lld\n",
(long long)(int)sizeof(((struct lov_mds_md_v3 *)0)->lmm_objects[0]));
CLASSERT(LOV_MAGIC_V3 == (0x0BD30000 | 0x0BD0));
BUILD_BUG_ON(LOV_MAGIC_V3 != (0x0BD30000 | 0x0BD0));
LASSERTF(LOV_PATTERN_RAID0 == 0x00000001UL, "found 0x%.8xUL\n",
(unsigned int)LOV_PATTERN_RAID0);
LASSERTF(LOV_PATTERN_RAID1 == 0x00000002UL, "found 0x%.8xUL\n",
@ -1479,11 +1479,11 @@ void lustre_assert_wire_constants(void)
(long long)(int)offsetof(struct lmv_mds_md_v1, lmv_stripe_fids[0]));
LASSERTF((int)sizeof(((struct lmv_mds_md_v1 *)0)->lmv_stripe_fids[0]) == 16, "found %lld\n",
(long long)(int)sizeof(((struct lmv_mds_md_v1 *)0)->lmv_stripe_fids[0]));
CLASSERT(LMV_MAGIC_V1 == 0x0CD20CD0);
CLASSERT(LMV_MAGIC_STRIPE == 0x0CD40CD0);
CLASSERT(LMV_HASH_TYPE_MASK == 0x0000ffff);
CLASSERT(LMV_HASH_FLAG_MIGRATION == 0x80000000);
CLASSERT(LMV_HASH_FLAG_DEAD == 0x40000000);
BUILD_BUG_ON(LMV_MAGIC_V1 != 0x0CD20CD0);
BUILD_BUG_ON(LMV_MAGIC_STRIPE != 0x0CD40CD0);
BUILD_BUG_ON(LMV_HASH_TYPE_MASK != 0x0000ffff);
BUILD_BUG_ON(LMV_HASH_FLAG_MIGRATION != 0x80000000);
BUILD_BUG_ON(LMV_HASH_FLAG_DEAD != 0x40000000);
/* Checks for struct obd_statfs */
LASSERTF((int)sizeof(struct obd_statfs) == 144, "found %lld\n",
@ -2761,12 +2761,12 @@ void lustre_assert_wire_constants(void)
(long long)(int)offsetof(struct lov_desc, ld_uuid));
LASSERTF((int)sizeof(((struct lov_desc *)0)->ld_uuid) == 40, "found %lld\n",
(long long)(int)sizeof(((struct lov_desc *)0)->ld_uuid));
CLASSERT(LOV_DESC_MAGIC == 0xB0CCDE5C);
BUILD_BUG_ON(LOV_DESC_MAGIC != 0xB0CCDE5C);
/* Checks for struct ldlm_res_id */
LASSERTF((int)sizeof(struct ldlm_res_id) == 32, "found %lld\n",
(long long)(int)sizeof(struct ldlm_res_id));
CLASSERT(RES_NAME_SIZE == 4);
BUILD_BUG_ON(RES_NAME_SIZE != 4);
LASSERTF((int)offsetof(struct ldlm_res_id, name[4]) == 32, "found %lld\n",
(long long)(int)offsetof(struct ldlm_res_id, name[4]));
LASSERTF((int)sizeof(((struct ldlm_res_id *)0)->name[4]) == 8, "found %lld\n",
@ -3037,7 +3037,7 @@ void lustre_assert_wire_constants(void)
/* Checks for struct mgs_send_param */
LASSERTF((int)sizeof(struct mgs_send_param) == 1024, "found %lld\n",
(long long)(int)sizeof(struct mgs_send_param));
CLASSERT(MGS_PARAM_MAXLEN == 1024);
BUILD_BUG_ON(MGS_PARAM_MAXLEN != 1024);
LASSERTF((int)offsetof(struct mgs_send_param, mgs_param[1024]) == 1024, "found %lld\n",
(long long)(int)offsetof(struct mgs_send_param, mgs_param[1024]));
LASSERTF((int)sizeof(((struct mgs_send_param *)0)->mgs_param[1024]) == 1, "found %lld\n",
@ -3090,16 +3090,16 @@ void lustre_assert_wire_constants(void)
(long long)(int)offsetof(struct llog_logid, lgl_ogen));
LASSERTF((int)sizeof(((struct llog_logid *)0)->lgl_ogen) == 4, "found %lld\n",
(long long)(int)sizeof(((struct llog_logid *)0)->lgl_ogen));
CLASSERT(OST_SZ_REC == 274730752);
CLASSERT(MDS_UNLINK_REC == 274801668);
CLASSERT(MDS_UNLINK64_REC == 275325956);
CLASSERT(MDS_SETATTR64_REC == 275325953);
CLASSERT(OBD_CFG_REC == 274857984);
CLASSERT(LLOG_GEN_REC == 274989056);
CLASSERT(CHANGELOG_REC == 275120128);
CLASSERT(CHANGELOG_USER_REC == 275185664);
CLASSERT(LLOG_HDR_MAGIC == 275010873);
CLASSERT(LLOG_LOGID_MAGIC == 275010875);
BUILD_BUG_ON(OST_SZ_REC != 274730752);
BUILD_BUG_ON(MDS_UNLINK_REC != 274801668);
BUILD_BUG_ON(MDS_UNLINK64_REC != 275325956);
BUILD_BUG_ON(MDS_SETATTR64_REC != 275325953);
BUILD_BUG_ON(OBD_CFG_REC != 274857984);
BUILD_BUG_ON(LLOG_GEN_REC != 274989056);
BUILD_BUG_ON(CHANGELOG_REC != 275120128);
BUILD_BUG_ON(CHANGELOG_USER_REC != 275185664);
BUILD_BUG_ON(LLOG_HDR_MAGIC != 275010873);
BUILD_BUG_ON(LLOG_LOGID_MAGIC != 275010875);
/* Checks for struct llog_catid */
LASSERTF((int)sizeof(struct llog_catid) == 32, "found %lld\n",
@ -3519,30 +3519,30 @@ void lustre_assert_wire_constants(void)
(long long)(int)offsetof(struct llogd_body, lgd_cur_offset));
LASSERTF((int)sizeof(((struct llogd_body *)0)->lgd_cur_offset) == 8, "found %lld\n",
(long long)(int)sizeof(((struct llogd_body *)0)->lgd_cur_offset));
CLASSERT(LLOG_ORIGIN_HANDLE_CREATE == 501);
CLASSERT(LLOG_ORIGIN_HANDLE_NEXT_BLOCK == 502);
CLASSERT(LLOG_ORIGIN_HANDLE_READ_HEADER == 503);
CLASSERT(LLOG_ORIGIN_HANDLE_WRITE_REC == 504);
CLASSERT(LLOG_ORIGIN_HANDLE_CLOSE == 505);
CLASSERT(LLOG_ORIGIN_CONNECT == 506);
CLASSERT(LLOG_CATINFO == 507);
CLASSERT(LLOG_ORIGIN_HANDLE_PREV_BLOCK == 508);
CLASSERT(LLOG_ORIGIN_HANDLE_DESTROY == 509);
CLASSERT(LLOG_FIRST_OPC == 501);
CLASSERT(LLOG_LAST_OPC == 510);
CLASSERT(LLOG_CONFIG_ORIG_CTXT == 0);
CLASSERT(LLOG_CONFIG_REPL_CTXT == 1);
CLASSERT(LLOG_MDS_OST_ORIG_CTXT == 2);
CLASSERT(LLOG_MDS_OST_REPL_CTXT == 3);
CLASSERT(LLOG_SIZE_ORIG_CTXT == 4);
CLASSERT(LLOG_SIZE_REPL_CTXT == 5);
CLASSERT(LLOG_TEST_ORIG_CTXT == 8);
CLASSERT(LLOG_TEST_REPL_CTXT == 9);
CLASSERT(LLOG_CHANGELOG_ORIG_CTXT == 12);
CLASSERT(LLOG_CHANGELOG_REPL_CTXT == 13);
CLASSERT(LLOG_CHANGELOG_USER_ORIG_CTXT == 14);
CLASSERT(LLOG_AGENT_ORIG_CTXT == 15);
CLASSERT(LLOG_MAX_CTXTS == 16);
BUILD_BUG_ON(LLOG_ORIGIN_HANDLE_CREATE != 501);
BUILD_BUG_ON(LLOG_ORIGIN_HANDLE_NEXT_BLOCK != 502);
BUILD_BUG_ON(LLOG_ORIGIN_HANDLE_READ_HEADER != 503);
BUILD_BUG_ON(LLOG_ORIGIN_HANDLE_WRITE_REC != 504);
BUILD_BUG_ON(LLOG_ORIGIN_HANDLE_CLOSE != 505);
BUILD_BUG_ON(LLOG_ORIGIN_CONNECT != 506);
BUILD_BUG_ON(LLOG_CATINFO != 507);
BUILD_BUG_ON(LLOG_ORIGIN_HANDLE_PREV_BLOCK != 508);
BUILD_BUG_ON(LLOG_ORIGIN_HANDLE_DESTROY != 509);
BUILD_BUG_ON(LLOG_FIRST_OPC != 501);
BUILD_BUG_ON(LLOG_LAST_OPC != 510);
BUILD_BUG_ON(LLOG_CONFIG_ORIG_CTXT != 0);
BUILD_BUG_ON(LLOG_CONFIG_REPL_CTXT != 1);
BUILD_BUG_ON(LLOG_MDS_OST_ORIG_CTXT != 2);
BUILD_BUG_ON(LLOG_MDS_OST_REPL_CTXT != 3);
BUILD_BUG_ON(LLOG_SIZE_ORIG_CTXT != 4);
BUILD_BUG_ON(LLOG_SIZE_REPL_CTXT != 5);
BUILD_BUG_ON(LLOG_TEST_ORIG_CTXT != 8);
BUILD_BUG_ON(LLOG_TEST_REPL_CTXT != 9);
BUILD_BUG_ON(LLOG_CHANGELOG_ORIG_CTXT != 12);
BUILD_BUG_ON(LLOG_CHANGELOG_REPL_CTXT != 13);
BUILD_BUG_ON(LLOG_CHANGELOG_USER_ORIG_CTXT != 14);
BUILD_BUG_ON(LLOG_AGENT_ORIG_CTXT != 15);
BUILD_BUG_ON(LLOG_MAX_CTXTS != 16);
/* Checks for struct llogd_conn_body */
LASSERTF((int)sizeof(struct llogd_conn_body) == 40, "found %lld\n",
@ -3659,7 +3659,7 @@ void lustre_assert_wire_constants(void)
(long long)(int)offsetof(struct lustre_capa, lc_expiry));
LASSERTF((int)sizeof(((struct lustre_capa *)0)->lc_expiry) == 4, "found %lld\n",
(long long)(int)sizeof(((struct lustre_capa *)0)->lc_expiry));
CLASSERT(CAPA_HMAC_MAX_LEN == 64);
BUILD_BUG_ON(CAPA_HMAC_MAX_LEN != 64);
LASSERTF((int)offsetof(struct lustre_capa, lc_hmac[64]) == 120, "found %lld\n",
(long long)(int)offsetof(struct lustre_capa, lc_hmac[64]));
LASSERTF((int)sizeof(((struct lustre_capa *)0)->lc_hmac[64]) == 1, "found %lld\n",
@ -3680,7 +3680,7 @@ void lustre_assert_wire_constants(void)
(long long)(int)offsetof(struct lustre_capa_key, lk_padding));
LASSERTF((int)sizeof(((struct lustre_capa_key *)0)->lk_padding) == 4, "found %lld\n",
(long long)(int)sizeof(((struct lustre_capa_key *)0)->lk_padding));
CLASSERT(CAPA_HMAC_KEY_MAX_LEN == 56);
BUILD_BUG_ON(CAPA_HMAC_KEY_MAX_LEN != 56);
LASSERTF((int)offsetof(struct lustre_capa_key, lk_key[56]) == 72, "found %lld\n",
(long long)(int)offsetof(struct lustre_capa_key, lk_key[56]));
LASSERTF((int)sizeof(((struct lustre_capa_key *)0)->lk_key[56]) == 1, "found %lld\n",
@ -3741,9 +3741,9 @@ void lustre_assert_wire_constants(void)
(long long)(int)offsetof(struct fiemap, fm_extents));
LASSERTF((int)sizeof(((struct fiemap *)0)->fm_extents) == 0, "found %lld\n",
(long long)(int)sizeof(((struct fiemap *)0)->fm_extents));
CLASSERT(FIEMAP_FLAG_SYNC == 0x00000001);
CLASSERT(FIEMAP_FLAG_XATTR == 0x00000002);
CLASSERT(FIEMAP_FLAG_DEVICE_ORDER == 0x40000000);
BUILD_BUG_ON(FIEMAP_FLAG_SYNC != 0x00000001);
BUILD_BUG_ON(FIEMAP_FLAG_XATTR != 0x00000002);
BUILD_BUG_ON(FIEMAP_FLAG_DEVICE_ORDER != 0x40000000);
/* Checks for struct fiemap_extent */
LASSERTF((int)sizeof(struct fiemap_extent) == 56, "found %lld\n",
@ -3768,18 +3768,18 @@ void lustre_assert_wire_constants(void)
(long long)(int)offsetof(struct fiemap_extent, fe_reserved[0]));
LASSERTF((int)sizeof(((struct fiemap_extent *)0)->fe_reserved[0]) == 4, "found %lld\n",
(long long)(int)sizeof(((struct fiemap_extent *)0)->fe_reserved[0]));
CLASSERT(FIEMAP_EXTENT_LAST == 0x00000001);
CLASSERT(FIEMAP_EXTENT_UNKNOWN == 0x00000002);
CLASSERT(FIEMAP_EXTENT_DELALLOC == 0x00000004);
CLASSERT(FIEMAP_EXTENT_ENCODED == 0x00000008);
CLASSERT(FIEMAP_EXTENT_DATA_ENCRYPTED == 0x00000080);
CLASSERT(FIEMAP_EXTENT_NOT_ALIGNED == 0x00000100);
CLASSERT(FIEMAP_EXTENT_DATA_INLINE == 0x00000200);
CLASSERT(FIEMAP_EXTENT_DATA_TAIL == 0x00000400);
CLASSERT(FIEMAP_EXTENT_UNWRITTEN == 0x00000800);
CLASSERT(FIEMAP_EXTENT_MERGED == 0x00001000);
CLASSERT(FIEMAP_EXTENT_NO_DIRECT == 0x40000000);
CLASSERT(FIEMAP_EXTENT_NET == 0x80000000);
BUILD_BUG_ON(FIEMAP_EXTENT_LAST != 0x00000001);
BUILD_BUG_ON(FIEMAP_EXTENT_UNKNOWN != 0x00000002);
BUILD_BUG_ON(FIEMAP_EXTENT_DELALLOC != 0x00000004);
BUILD_BUG_ON(FIEMAP_EXTENT_ENCODED != 0x00000008);
BUILD_BUG_ON(FIEMAP_EXTENT_DATA_ENCRYPTED != 0x00000080);
BUILD_BUG_ON(FIEMAP_EXTENT_NOT_ALIGNED != 0x00000100);
BUILD_BUG_ON(FIEMAP_EXTENT_DATA_INLINE != 0x00000200);
BUILD_BUG_ON(FIEMAP_EXTENT_DATA_TAIL != 0x00000400);
BUILD_BUG_ON(FIEMAP_EXTENT_UNWRITTEN != 0x00000800);
BUILD_BUG_ON(FIEMAP_EXTENT_MERGED != 0x00001000);
BUILD_BUG_ON(FIEMAP_EXTENT_NO_DIRECT != 0x40000000);
BUILD_BUG_ON(FIEMAP_EXTENT_NET != 0x80000000);
/* Checks for type posix_acl_xattr_entry */
LASSERTF((int)sizeof(struct posix_acl_xattr_entry) == 8, "found %lld\n",
@ -3828,7 +3828,7 @@ void lustre_assert_wire_constants(void)
(long long)(int)offsetof(struct link_ea_header, padding2));
LASSERTF((int)sizeof(((struct link_ea_header *)0)->padding2) == 4, "found %lld\n",
(long long)(int)sizeof(((struct link_ea_header *)0)->padding2));
CLASSERT(LINK_EA_MAGIC == 0x11EAF1DFUL);
BUILD_BUG_ON(LINK_EA_MAGIC != 0x11EAF1DFUL);
/* Checks for struct link_ea_entry */
LASSERTF((int)sizeof(struct link_ea_entry) == 18, "found %lld\n",