openkylin
/
linux
mirror of https://gitee.com/openkylin/linux.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

nfs: nfs4xdr: get rid of WRITEMEM 

s/WRITEMEM(/p = xdr_encode_opaque_fixed(p, /

Signed-off-by: Benny Halevy <bhalevy@panasas.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
This commit is contained in:
Benny Halevy 2009-08-14 17:19:06 +03:00 committed by Trond Myklebust
parent b95be5a976
commit 93f0cf2594
1 changed files with 32 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
fs/nfs/nfs4xdr.c
View File

@ -712,10 +712,6 @@ struct compound_hdr {
* task to translate them into Linux-specific versions which are more * task to translate them into Linux-specific versions which are more
* consistent with the style used in NFSv2/v3... * consistent with the style used in NFSv2/v3...
*/ */
#define WRITEMEM(ptr,nbytes) do { \
p = xdr_encode_opaque_fixed(p, ptr, nbytes); \
} while (0)
#define RESERVE_SPACE(nbytes) do { \ #define RESERVE_SPACE(nbytes) do { \
p = xdr_reserve_space(xdr, nbytes); \ p = xdr_reserve_space(xdr, nbytes); \
BUG_ON(!p); \ BUG_ON(!p); \
@ -746,7 +742,7 @@ static void encode_compound_hdr(struct xdr_stream *xdr,
BUG_ON(hdr->taglen > NFS4_MAXTAGLEN); BUG_ON(hdr->taglen > NFS4_MAXTAGLEN);
RESERVE_SPACE(12+(XDR_QUADLEN(hdr->taglen)<<2)); RESERVE_SPACE(12+(XDR_QUADLEN(hdr->taglen)<<2));
*p++ = cpu_to_be32(hdr->taglen); *p++ = cpu_to_be32(hdr->taglen);
WRITEMEM(hdr->tag, hdr->taglen); p = xdr_encode_opaque_fixed(p, hdr->tag, hdr->taglen);
*p++ = cpu_to_be32(hdr->minorversion); *p++ = cpu_to_be32(hdr->minorversion);
hdr->nops_p = p; hdr->nops_p = p;
*p++ = cpu_to_be32(hdr->nops); *p++ = cpu_to_be32(hdr->nops);
@ -845,12 +841,12 @@ static void encode_attrs(struct xdr_stream *xdr, const struct iattr *iap, const
if (iap->ia_valid & ATTR_UID) { if (iap->ia_valid & ATTR_UID) {
bmval1 |= FATTR4_WORD1_OWNER; bmval1 |= FATTR4_WORD1_OWNER;
*p++ = cpu_to_be32(owner_namelen); *p++ = cpu_to_be32(owner_namelen);
WRITEMEM(owner_name, owner_namelen); p = xdr_encode_opaque_fixed(p, owner_name, owner_namelen);
} }
if (iap->ia_valid & ATTR_GID) { if (iap->ia_valid & ATTR_GID) {
bmval1 |= FATTR4_WORD1_OWNER_GROUP; bmval1 |= FATTR4_WORD1_OWNER_GROUP;
*p++ = cpu_to_be32(owner_grouplen); *p++ = cpu_to_be32(owner_grouplen);
WRITEMEM(owner_group, owner_grouplen); p = xdr_encode_opaque_fixed(p, owner_group, owner_grouplen);
} }
if (iap->ia_valid & ATTR_ATIME_SET) { if (iap->ia_valid & ATTR_ATIME_SET) {
bmval1 |= FATTR4_WORD1_TIME_ACCESS_SET; bmval1 |= FATTR4_WORD1_TIME_ACCESS_SET;
@ -909,7 +905,7 @@ static void encode_close(struct xdr_stream *xdr, const struct nfs_closeargs *arg
RESERVE_SPACE(8+NFS4_STATEID_SIZE); RESERVE_SPACE(8+NFS4_STATEID_SIZE);
*p++ = cpu_to_be32(OP_CLOSE); *p++ = cpu_to_be32(OP_CLOSE);
*p++ = cpu_to_be32(arg->seqid->sequence->counter); *p++ = cpu_to_be32(arg->seqid->sequence->counter);
WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE); p = xdr_encode_opaque_fixed(p, arg->stateid->data, NFS4_STATEID_SIZE);
hdr->nops++; hdr->nops++;
hdr->replen += decode_close_maxsz; hdr->replen += decode_close_maxsz;
} }
@ -953,7 +949,7 @@ static void encode_create(struct xdr_stream *xdr, const struct nfs4_create_arg *
RESERVE_SPACE(4 + create->name->len); RESERVE_SPACE(4 + create->name->len);
*p++ = cpu_to_be32(create->name->len); *p++ = cpu_to_be32(create->name->len);
WRITEMEM(create->name->name, create->name->len); p = xdr_encode_opaque_fixed(p, create->name->name, create->name->len);
hdr->nops++; hdr->nops++;
hdr->replen += decode_create_maxsz; hdr->replen += decode_create_maxsz;
@ -1020,7 +1016,7 @@ static void encode_link(struct xdr_stream *xdr, const struct qstr *name, struct
RESERVE_SPACE(8 + name->len); RESERVE_SPACE(8 + name->len);
*p++ = cpu_to_be32(OP_LINK); *p++ = cpu_to_be32(OP_LINK);
*p++ = cpu_to_be32(name->len); *p++ = cpu_to_be32(name->len);
WRITEMEM(name->name, name->len); p = xdr_encode_opaque_fixed(p, name->name, name->len);
hdr->nops++; hdr->nops++;
hdr->replen += decode_link_maxsz; hdr->replen += decode_link_maxsz;
} }
@ -1057,16 +1053,16 @@ static void encode_lock(struct xdr_stream *xdr, const struct nfs_lock_args *args
if (args->new_lock_owner){ if (args->new_lock_owner){
RESERVE_SPACE(4+NFS4_STATEID_SIZE+32); RESERVE_SPACE(4+NFS4_STATEID_SIZE+32);
*p++ = cpu_to_be32(args->open_seqid->sequence->counter); *p++ = cpu_to_be32(args->open_seqid->sequence->counter);
WRITEMEM(args->open_stateid->data, NFS4_STATEID_SIZE); p = xdr_encode_opaque_fixed(p, args->open_stateid->data, NFS4_STATEID_SIZE);
*p++ = cpu_to_be32(args->lock_seqid->sequence->counter); *p++ = cpu_to_be32(args->lock_seqid->sequence->counter);
p = xdr_encode_hyper(p, args->lock_owner.clientid); p = xdr_encode_hyper(p, args->lock_owner.clientid);
*p++ = cpu_to_be32(16); *p++ = cpu_to_be32(16);
WRITEMEM("lock id:", 8); p = xdr_encode_opaque_fixed(p, "lock id:", 8);
p = xdr_encode_hyper(p, args->lock_owner.id); p = xdr_encode_hyper(p, args->lock_owner.id);
} }
else { else {
RESERVE_SPACE(NFS4_STATEID_SIZE+4); RESERVE_SPACE(NFS4_STATEID_SIZE+4);
WRITEMEM(args->lock_stateid->data, NFS4_STATEID_SIZE); p = xdr_encode_opaque_fixed(p, args->lock_stateid->data, NFS4_STATEID_SIZE);
*p++ = cpu_to_be32(args->lock_seqid->sequence->counter); *p++ = cpu_to_be32(args->lock_seqid->sequence->counter);
} }
hdr->nops++; hdr->nops++;
@ -1084,7 +1080,7 @@ static void encode_lockt(struct xdr_stream *xdr, const struct nfs_lockt_args *ar
p = xdr_encode_hyper(p, nfs4_lock_length(args->fl)); p = xdr_encode_hyper(p, nfs4_lock_length(args->fl));
p = xdr_encode_hyper(p, args->lock_owner.clientid); p = xdr_encode_hyper(p, args->lock_owner.clientid);
*p++ = cpu_to_be32(16); *p++ = cpu_to_be32(16);
WRITEMEM("lock id:", 8); p = xdr_encode_opaque_fixed(p, "lock id:", 8);
p = xdr_encode_hyper(p, args->lock_owner.id); p = xdr_encode_hyper(p, args->lock_owner.id);
hdr->nops++; hdr->nops++;
hdr->replen += decode_lockt_maxsz; hdr->replen += decode_lockt_maxsz;
@ -1098,7 +1094,7 @@ static void encode_locku(struct xdr_stream *xdr, const struct nfs_locku_args *ar
*p++ = cpu_to_be32(OP_LOCKU); *p++ = cpu_to_be32(OP_LOCKU);
*p++ = cpu_to_be32(nfs4_lock_type(args->fl, 0)); *p++ = cpu_to_be32(nfs4_lock_type(args->fl, 0));
*p++ = cpu_to_be32(args->seqid->sequence->counter); *p++ = cpu_to_be32(args->seqid->sequence->counter);
WRITEMEM(args->stateid->data, NFS4_STATEID_SIZE); p = xdr_encode_opaque_fixed(p, args->stateid->data, NFS4_STATEID_SIZE);
p = xdr_encode_hyper(p, args->fl->fl_start); p = xdr_encode_hyper(p, args->fl->fl_start);
p = xdr_encode_hyper(p, nfs4_lock_length(args->fl)); p = xdr_encode_hyper(p, nfs4_lock_length(args->fl));
hdr->nops++; hdr->nops++;
@ -1113,7 +1109,7 @@ static void encode_lookup(struct xdr_stream *xdr, const struct qstr *name, struc
RESERVE_SPACE(8 + len); RESERVE_SPACE(8 + len);
*p++ = cpu_to_be32(OP_LOOKUP); *p++ = cpu_to_be32(OP_LOOKUP);
*p++ = cpu_to_be32(len); *p++ = cpu_to_be32(len);
WRITEMEM(name->name, len); p = xdr_encode_opaque_fixed(p, name->name, len);
hdr->nops++; hdr->nops++;
hdr->replen += decode_lookup_maxsz; hdr->replen += decode_lookup_maxsz;
} }
@ -1153,7 +1149,7 @@ static inline void encode_openhdr(struct xdr_stream *xdr, const struct nfs_opena
RESERVE_SPACE(28); RESERVE_SPACE(28);
p = xdr_encode_hyper(p, arg->clientid); p = xdr_encode_hyper(p, arg->clientid);
*p++ = cpu_to_be32(16); *p++ = cpu_to_be32(16);
WRITEMEM("open id:", 8); p = xdr_encode_opaque_fixed(p, "open id:", 8);
p = xdr_encode_hyper(p, arg->id); p = xdr_encode_hyper(p, arg->id);
} }
@ -1233,7 +1229,7 @@ static inline void encode_claim_delegate_cur(struct xdr_stream *xdr, const struc
RESERVE_SPACE(4+NFS4_STATEID_SIZE); RESERVE_SPACE(4+NFS4_STATEID_SIZE);
*p++ = cpu_to_be32(NFS4_OPEN_CLAIM_DELEGATE_CUR); *p++ = cpu_to_be32(NFS4_OPEN_CLAIM_DELEGATE_CUR);
WRITEMEM(stateid->data, NFS4_STATEID_SIZE); p = xdr_encode_opaque_fixed(p, stateid->data, NFS4_STATEID_SIZE);
encode_string(xdr, name->len, name->name); encode_string(xdr, name->len, name->name);
} }
@ -1264,7 +1260,7 @@ static void encode_open_confirm(struct xdr_stream *xdr, const struct nfs_open_co
RESERVE_SPACE(4+NFS4_STATEID_SIZE+4); RESERVE_SPACE(4+NFS4_STATEID_SIZE+4);
*p++ = cpu_to_be32(OP_OPEN_CONFIRM); *p++ = cpu_to_be32(OP_OPEN_CONFIRM);
WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE); p = xdr_encode_opaque_fixed(p, arg->stateid->data, NFS4_STATEID_SIZE);
*p++ = cpu_to_be32(arg->seqid->sequence->counter); *p++ = cpu_to_be32(arg->seqid->sequence->counter);
hdr->nops++; hdr->nops++;
hdr->replen += decode_open_confirm_maxsz; hdr->replen += decode_open_confirm_maxsz;
@ -1276,7 +1272,7 @@ static void encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_close
RESERVE_SPACE(4+NFS4_STATEID_SIZE+4); RESERVE_SPACE(4+NFS4_STATEID_SIZE+4);
*p++ = cpu_to_be32(OP_OPEN_DOWNGRADE); *p++ = cpu_to_be32(OP_OPEN_DOWNGRADE);
WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE); p = xdr_encode_opaque_fixed(p, arg->stateid->data, NFS4_STATEID_SIZE);
*p++ = cpu_to_be32(arg->seqid->sequence->counter); *p++ = cpu_to_be32(arg->seqid->sequence->counter);
encode_share_access(xdr, arg->fmode); encode_share_access(xdr, arg->fmode);
hdr->nops++; hdr->nops++;
@ -1292,7 +1288,7 @@ encode_putfh(struct xdr_stream *xdr, const struct nfs_fh *fh, struct compound_hd
RESERVE_SPACE(8 + len); RESERVE_SPACE(8 + len);
*p++ = cpu_to_be32(OP_PUTFH); *p++ = cpu_to_be32(OP_PUTFH);
*p++ = cpu_to_be32(len); *p++ = cpu_to_be32(len);
WRITEMEM(fh->data, len); p = xdr_encode_opaque_fixed(p, fh->data, len);
hdr->nops++; hdr->nops++;
hdr->replen += decode_putfh_maxsz; hdr->replen += decode_putfh_maxsz;
} }
@ -1315,9 +1311,9 @@ static void encode_stateid(struct xdr_stream *xdr, const struct nfs_open_context
RESERVE_SPACE(NFS4_STATEID_SIZE); RESERVE_SPACE(NFS4_STATEID_SIZE);
if (ctx->state != NULL) { if (ctx->state != NULL) {
nfs4_copy_stateid(&stateid, ctx->state, ctx->lockowner); nfs4_copy_stateid(&stateid, ctx->state, ctx->lockowner);
WRITEMEM(stateid.data, NFS4_STATEID_SIZE); p = xdr_encode_opaque_fixed(p, stateid.data, NFS4_STATEID_SIZE);
} else } else
WRITEMEM(zero_stateid.data, NFS4_STATEID_SIZE); p = xdr_encode_opaque_fixed(p, zero_stateid.data, NFS4_STATEID_SIZE);
} }
static void encode_read(struct xdr_stream *xdr, const struct nfs_readargs *args, struct compound_hdr *hdr) static void encode_read(struct xdr_stream *xdr, const struct nfs_readargs *args, struct compound_hdr *hdr)
@ -1347,7 +1343,7 @@ static void encode_readdir(struct xdr_stream *xdr, const struct nfs4_readdir_arg
RESERVE_SPACE(12+NFS4_VERIFIER_SIZE+20); RESERVE_SPACE(12+NFS4_VERIFIER_SIZE+20);
*p++ = cpu_to_be32(OP_READDIR); *p++ = cpu_to_be32(OP_READDIR);
p = xdr_encode_hyper(p, readdir->cookie); p = xdr_encode_hyper(p, readdir->cookie);
WRITEMEM(readdir->verifier.data, NFS4_VERIFIER_SIZE); p = xdr_encode_opaque_fixed(p, readdir->verifier.data, NFS4_VERIFIER_SIZE);
*p++ = cpu_to_be32(readdir->count >> 1); /* We're not doing readdirplus */ *p++ = cpu_to_be32(readdir->count >> 1); /* We're not doing readdirplus */
*p++ = cpu_to_be32(readdir->count); *p++ = cpu_to_be32(readdir->count);
*p++ = cpu_to_be32(2); *p++ = cpu_to_be32(2);
@ -1386,7 +1382,7 @@ static void encode_remove(struct xdr_stream *xdr, const struct qstr *name, struc
RESERVE_SPACE(8 + name->len); RESERVE_SPACE(8 + name->len);
*p++ = cpu_to_be32(OP_REMOVE); *p++ = cpu_to_be32(OP_REMOVE);
*p++ = cpu_to_be32(name->len); *p++ = cpu_to_be32(name->len);
WRITEMEM(name->name, name->len); p = xdr_encode_opaque_fixed(p, name->name, name->len);
hdr->nops++; hdr->nops++;
hdr->replen += decode_remove_maxsz; hdr->replen += decode_remove_maxsz;
} }
@ -1398,11 +1394,11 @@ static void encode_rename(struct xdr_stream *xdr, const struct qstr *oldname, co
RESERVE_SPACE(8 + oldname->len); RESERVE_SPACE(8 + oldname->len);
*p++ = cpu_to_be32(OP_RENAME); *p++ = cpu_to_be32(OP_RENAME);
*p++ = cpu_to_be32(oldname->len); *p++ = cpu_to_be32(oldname->len);
WRITEMEM(oldname->name, oldname->len); p = xdr_encode_opaque_fixed(p, oldname->name, oldname->len);
RESERVE_SPACE(4 + newname->len); RESERVE_SPACE(4 + newname->len);
*p++ = cpu_to_be32(newname->len); *p++ = cpu_to_be32(newname->len);
WRITEMEM(newname->name, newname->len); p = xdr_encode_opaque_fixed(p, newname->name, newname->len);
hdr->nops++; hdr->nops++;
hdr->replen += decode_rename_maxsz; hdr->replen += decode_rename_maxsz;
} }
@ -1436,7 +1432,7 @@ encode_setacl(struct xdr_stream *xdr, struct nfs_setaclargs *arg, struct compoun
RESERVE_SPACE(4+NFS4_STATEID_SIZE); RESERVE_SPACE(4+NFS4_STATEID_SIZE);
*p++ = cpu_to_be32(OP_SETATTR); *p++ = cpu_to_be32(OP_SETATTR);
WRITEMEM(zero_stateid.data, NFS4_STATEID_SIZE); p = xdr_encode_opaque_fixed(p, zero_stateid.data, NFS4_STATEID_SIZE);
RESERVE_SPACE(2*4); RESERVE_SPACE(2*4);
*p++ = cpu_to_be32(1); *p++ = cpu_to_be32(1);
*p++ = cpu_to_be32(FATTR4_WORD0_ACL); *p++ = cpu_to_be32(FATTR4_WORD0_ACL);
@ -1467,7 +1463,7 @@ static void encode_setattr(struct xdr_stream *xdr, const struct nfs_setattrargs
RESERVE_SPACE(4+NFS4_STATEID_SIZE); RESERVE_SPACE(4+NFS4_STATEID_SIZE);
*p++ = cpu_to_be32(OP_SETATTR); *p++ = cpu_to_be32(OP_SETATTR);
WRITEMEM(arg->stateid.data, NFS4_STATEID_SIZE); p = xdr_encode_opaque_fixed(p, arg->stateid.data, NFS4_STATEID_SIZE);
hdr->nops++; hdr->nops++;
hdr->replen += decode_setattr_maxsz; hdr->replen += decode_setattr_maxsz;
encode_attrs(xdr, arg->iap, server); encode_attrs(xdr, arg->iap, server);
@ -1479,7 +1475,7 @@ static void encode_setclientid(struct xdr_stream *xdr, const struct nfs4_setclie
RESERVE_SPACE(4 + NFS4_VERIFIER_SIZE); RESERVE_SPACE(4 + NFS4_VERIFIER_SIZE);
*p++ = cpu_to_be32(OP_SETCLIENTID); *p++ = cpu_to_be32(OP_SETCLIENTID);
WRITEMEM(setclientid->sc_verifier->data, NFS4_VERIFIER_SIZE); p = xdr_encode_opaque_fixed(p, setclientid->sc_verifier->data, NFS4_VERIFIER_SIZE);
encode_string(xdr, setclientid->sc_name_len, setclientid->sc_name); encode_string(xdr, setclientid->sc_name_len, setclientid->sc_name);
RESERVE_SPACE(4); RESERVE_SPACE(4);
@ -1499,7 +1495,7 @@ static void encode_setclientid_confirm(struct xdr_stream *xdr, const struct nfs_
RESERVE_SPACE(12 + NFS4_VERIFIER_SIZE); RESERVE_SPACE(12 + NFS4_VERIFIER_SIZE);
*p++ = cpu_to_be32(OP_SETCLIENTID_CONFIRM); *p++ = cpu_to_be32(OP_SETCLIENTID_CONFIRM);
p = xdr_encode_hyper(p, client_state->cl_clientid); p = xdr_encode_hyper(p, client_state->cl_clientid);
WRITEMEM(client_state->cl_confirm.data, NFS4_VERIFIER_SIZE); p = xdr_encode_opaque_fixed(p, client_state->cl_confirm.data, NFS4_VERIFIER_SIZE);
hdr->nops++; hdr->nops++;
hdr->replen += decode_setclientid_confirm_maxsz; hdr->replen += decode_setclientid_confirm_maxsz;
} }
@ -1530,7 +1526,7 @@ static void encode_delegreturn(struct xdr_stream *xdr, const nfs4_stateid *state
RESERVE_SPACE(4+NFS4_STATEID_SIZE); RESERVE_SPACE(4+NFS4_STATEID_SIZE);
*p++ = cpu_to_be32(OP_DELEGRETURN); *p++ = cpu_to_be32(OP_DELEGRETURN);
WRITEMEM(stateid->data, NFS4_STATEID_SIZE); p = xdr_encode_opaque_fixed(p, stateid->data, NFS4_STATEID_SIZE);
hdr->nops++; hdr->nops++;
hdr->replen += decode_delegreturn_maxsz; hdr->replen += decode_delegreturn_maxsz;
} }
@ -1545,7 +1541,7 @@ static void encode_exchange_id(struct xdr_stream *xdr,
RESERVE_SPACE(4 + sizeof(args->verifier->data)); RESERVE_SPACE(4 + sizeof(args->verifier->data));
*p++ = cpu_to_be32(OP_EXCHANGE_ID); *p++ = cpu_to_be32(OP_EXCHANGE_ID);
WRITEMEM(args->verifier->data, sizeof(args->verifier->data)); p = xdr_encode_opaque_fixed(p, args->verifier->data, sizeof(args->verifier->data));
encode_string(xdr, args->id_len, args->id); encode_string(xdr, args->id_len, args->id);
@ -1611,7 +1607,7 @@ static void encode_create_session(struct xdr_stream *xdr,
clp->cl_ipaddr); clp->cl_ipaddr);
RESERVE_SPACE(16 + len); RESERVE_SPACE(16 + len);
*p++ = cpu_to_be32(len); *p++ = cpu_to_be32(len);
WRITEMEM(machine_name, len); p = xdr_encode_opaque_fixed(p, machine_name, len);
*p++ = cpu_to_be32(0); /* UID */ *p++ = cpu_to_be32(0); /* UID */
*p++ = cpu_to_be32(0); /* GID */ *p++ = cpu_to_be32(0); /* GID */
*p++ = cpu_to_be32(0); /* No more gids */ *p++ = cpu_to_be32(0); /* No more gids */
@ -1626,7 +1622,7 @@ static void encode_destroy_session(struct xdr_stream *xdr,
__be32 *p; __be32 *p;
RESERVE_SPACE(4 + NFS4_MAX_SESSIONID_LEN); RESERVE_SPACE(4 + NFS4_MAX_SESSIONID_LEN);
*p++ = cpu_to_be32(OP_DESTROY_SESSION); *p++ = cpu_to_be32(OP_DESTROY_SESSION);
WRITEMEM(session->sess_id.data, NFS4_MAX_SESSIONID_LEN); p = xdr_encode_opaque_fixed(p, session->sess_id.data, NFS4_MAX_SESSIONID_LEN);
hdr->nops++; hdr->nops++;
hdr->replen += decode_destroy_session_maxsz; hdr->replen += decode_destroy_session_maxsz;
} }
@ -1666,7 +1662,7 @@ static void encode_sequence(struct xdr_stream *xdr,
slot->seq_nr, args->sa_slotid, slot->seq_nr, args->sa_slotid,
tp->highest_used_slotid, args->sa_cache_this); tp->highest_used_slotid, args->sa_cache_this);
RESERVE_SPACE(NFS4_MAX_SESSIONID_LEN + 16); RESERVE_SPACE(NFS4_MAX_SESSIONID_LEN + 16);
WRITEMEM(session->sess_id.data, NFS4_MAX_SESSIONID_LEN); p = xdr_encode_opaque_fixed(p, session->sess_id.data, NFS4_MAX_SESSIONID_LEN);
*p++ = cpu_to_be32(slot->seq_nr); *p++ = cpu_to_be32(slot->seq_nr);
*p++ = cpu_to_be32(args->sa_slotid); *p++ = cpu_to_be32(args->sa_slotid);
*p++ = cpu_to_be32(tp->highest_used_slotid); *p++ = cpu_to_be32(tp->highest_used_slotid);