{ CAM_SCSI_BUSY, "SCSI Bus Busy" },
};
-const int num_cam_status_entries =
- sizeof(cam_status_table)/sizeof(*cam_status_table);
+const int num_cam_status_entries = NELEM(cam_status_table);
#ifdef _KERNEL
SYSCTL_NODE(_kern, OID_AUTO, cam, CTLFLAG_RD, 0, "CAM Subsystem");
},
};
-static const int xpt_quirk_table_size =
- sizeof(xpt_quirk_table) / sizeof(*xpt_quirk_table);
+static const int xpt_quirk_table_size = NELEM(xpt_quirk_table);
typedef enum {
DM_RET_COPY = 0x01,
match = cam_quirkmatch((caddr_t)&device->inq_data,
(caddr_t)xpt_quirk_table,
- sizeof(xpt_quirk_table)/sizeof(*xpt_quirk_table),
+ NELEM(xpt_quirk_table),
sizeof(*xpt_quirk_table), scsi_inquiry_match);
if (match == NULL)
* feel free to change this quirk entry.
*/
{T_CDROM, SIP_MEDIA_REMOVABLE, "PLEXTOR", "CD-ROM PX*", "*"},
- sizeof(plextor_cd_ops)/sizeof(struct op_table_entry),
+ NELEM(plextor_cd_ops),
plextor_cd_ops
}
};
match = cam_quirkmatch((caddr_t)inq_data,
(caddr_t)scsi_op_quirk_table,
- sizeof(scsi_op_quirk_table)/
- sizeof(*scsi_op_quirk_table),
+ NELEM(scsi_op_quirk_table),
sizeof(*scsi_op_quirk_table),
scsi_inquiry_match);
*/
{T_DIRECT, SIP_MEDIA_FIXED, "QUANTUM", "FIREBALL S*", "*"},
/*num_sense_keys*/0,
- sizeof(quantum_fireball_entries)/sizeof(struct asc_table_entry),
+ NELEM(quantum_fireball_entries),
/*sense key entries*/NULL,
quantum_fireball_entries
},
*/
{T_DIRECT, SIP_MEDIA_REMOVABLE, "SONY", "SMO-*", "*"},
/*num_sense_keys*/0,
- sizeof(sony_mo_entries)/sizeof(struct asc_table_entry),
+ NELEM(sony_mo_entries),
/*sense key entries*/NULL,
sony_mo_entries
}
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/cam/scsi/scsi_cd.c,v 1.31.2.16 2003/10/21 22:26:11 thomas Exp $
- * $DragonFly: src/sys/bus/cam/scsi/scsi_cd.c,v 1.44 2008/07/18 00:07:23 dillon Exp $
*/
/*
* Portions of this driver taken from the original FreeBSD cd driver.
*/
match = cam_quirkmatch((caddr_t)&cgd->inq_data,
(caddr_t)cd_quirk_table,
- sizeof(cd_quirk_table)/sizeof(*cd_quirk_table),
+ NELEM(cd_quirk_table),
sizeof(*cd_quirk_table), scsi_inquiry_match);
if (match != NULL)
{
int i;
- for (i = 0; i < (sizeof(cd_page_size_table)/
- sizeof(cd_page_size_table[0])); i++) {
+ for (i = 0; i < NELEM(cd_page_size_table); i++) {
if (cd_page_size_table[i].page == page_num)
return (cd_page_size_table[i].page_size);
}
*/
match = cam_quirkmatch((caddr_t)&cgd->inq_data,
(caddr_t)da_quirk_table,
- sizeof(da_quirk_table)/sizeof(*da_quirk_table),
+ NELEM(da_quirk_table),
sizeof(*da_quirk_table), scsi_inquiry_match);
if (match != NULL)
*/
match = cam_quirkmatch((caddr_t)&cgd->inq_data,
(caddr_t)sa_quirk_table,
- sizeof(sa_quirk_table)/sizeof(*sa_quirk_table),
+ NELEM(sa_quirk_table),
sizeof(*sa_quirk_table), scsi_inquiry_match);
if (match != NULL) {
0x330 /* Eighth and default selection in BIOS setup */
};
-#define MAX_ISA_IOPORT_INDEX (sizeof(adv_isa_ioports)/sizeof(u_int16_t) - 1)
+#define MAX_ISA_IOPORT_INDEX (NELEM(adv_isa_ioports) - 1)
static int adv_isa_probe(device_t dev);
static int adv_isa_attach(device_t dev);
target_mask = ADV_TID_TO_TARGET_MASK(cgd->ccb_h.target_id);
- num_entries = sizeof(adv_quirk_table)/sizeof(*adv_quirk_table);
+ num_entries = NELEM(adv_quirk_table);
match = cam_quirkmatch((caddr_t)&cgd->inq_data,
(caddr_t)adv_quirk_table,
num_entries, sizeof(*adv_quirk_table),
#endif
};
-static const int adw_num_pci_devs =
- sizeof(adw_pci_ident_table) / sizeof(*adw_pci_ident_table);
+static const int adw_num_pci_devs = NELEM(adw_pci_ident_table);
#define ADW_PCI_MAX_DMA_ADDR (0xFFFFFFFFUL)
#define ADW_PCI_MAX_DMA_COUNT (0xFFFFFFFFUL)
/* $FreeBSD: src/sys/dev/isp/isp.c,v 1.41.2.23 2002/10/11 17:34:28 mjacob Exp $ */
-/* $DragonFly: src/sys/dev/disk/isp/isp.c,v 1.5 2007/05/13 22:25:42 swildner Exp $ */
/*
* Machine and OS Independent (well, as best as possible)
* code for the Qlogic ISP SCSI adapters.
if (IS_FC(isp)) {
mcp = mbpfc;
- lim = (sizeof (mbpfc) / sizeof (mbpfc[0]));
+ lim = NELEM(mbpfc);
} else {
mcp = mbpscsi;
- lim = (sizeof (mbpscsi) / sizeof (mbpscsi[0]));
+ lim = NELEM(mbpscsi);
}
opcode = mbp->param[0];
ibits = HIBYT(mcp[opcode]) & NMBOX_BMASK(isp);
if (IS_FC(isp)) {
mcp = mbpfc;
- lim = (sizeof (mbpfc) / sizeof (mbpfc[0]));
+ lim = NELEM(mbpfc);
} else {
mcp = mbpscsi;
- lim = (sizeof (mbpscsi) / sizeof (mbpscsi[0]));
+ lim = NELEM(mbpscsi);
}
if ((opcode = mbp->param[0]) >= lim) {
{ MOUSE_MODEL_GENERIC,
0xc0, MOUSE_PS2_PACKETSIZE, NULL },
};
-#define GENERIC_MOUSE_ENTRY \
- ((sizeof(vendortype) / sizeof(*vendortype)) - 1)
+#define GENERIC_MOUSE_ENTRY (NELEM(vendortype) - 1)
/* device driver declarateion */
static device_method_t psm_methods[] = {
STATS_ENTRY("truncated", "frames truncated due to Rx FIFO inderrun",
rx_trunc)
};
-#define AE_STATS_RX_LEN (sizeof(ae_stats_rx) / sizeof(*ae_stats_rx))
-#define AE_STATS_TX_LEN (sizeof(ae_stats_tx) / sizeof(*ae_stats_tx))
+#define AE_STATS_RX_LEN NELEM(ae_stats_rx)
+#define AE_STATS_TX_LEN NELEM(ae_stats_tx)
static void
ae_stop(struct ae_softc *sc)
case 0:
return (-20);
case ENOENT:
- for (i = 0; i < sizeof(le_isa_params) /
- sizeof(le_isa_params[0]); i++) {
+ for (i = 0; i < NELEM(le_isa_params); i++) {
if (le_isa_probe_legacy(dev, &le_isa_params[i]) == 0) {
device_set_desc(dev, le_isa_params[i].name);
return (-20);
macstride = 1;
break;
case ENOENT:
- for (i = 0; i < sizeof(le_isa_params) /
- sizeof(le_isa_params[0]); i++) {
+ for (i = 0; i < NELEM(le_isa_params); i++) {
if (le_isa_probe_legacy(dev, &le_isa_params[i]) == 0) {
lesc->sc_rres = bus_alloc_resource(dev,
SYS_RES_IOPORT, &lesc->sc_rrid, 0, ~0,
if (*ptr == 'R') {
/* -R is XFP */
mxge_media_types = mxge_xfp_media_types;
- mxge_media_type_entries =
- sizeof (mxge_xfp_media_types) /
- sizeof (mxge_xfp_media_types[0]);
+ mxge_media_type_entries = NELEM(mxge_xfp_media_types);
byte = MXGE_XFP_COMPLIANCE_BYTE;
cage_type = "XFP";
}
if (*ptr == 'S' || *(ptr +1) == 'S') {
/* -S or -2S is SFP+ */
mxge_media_types = mxge_sfp_media_types;
- mxge_media_type_entries =
- sizeof (mxge_sfp_media_types) /
- sizeof (mxge_sfp_media_types[0]);
+ mxge_media_type_entries = NELEM(mxge_sfp_media_types);
cage_type = "SFP+";
byte = 3;
}
/* Set TX power */
if ((ic->ic_caps & IEEE80211_C_TXPMGT) &&
- ic->ic_txpowlimit < (sizeof(dBm2mW) / sizeof(dBm2mW[0]))) {
+ ic->ic_txpowlimit < NELEM(dBm2mW)) {
arg = dBm2mW[ic->ic_txpowlimit];
len = sizeof(arg);
ndis_set_info(sc, OID_802_11_TX_POWER_LEVEL, &arg, &len);
if (ic->ic_caps & IEEE80211_C_TXPMGT) {
len = sizeof(arg);
ndis_get_info(sc, OID_802_11_TX_POWER_LEVEL, &arg, &len);
- for (i = 0; i < (sizeof(dBm2mW) / sizeof(dBm2mW[0])); i++)
+ for (i = 0; i < NELEM(dBm2mW); i++)
if (dBm2mW[i] >= arg)
break;
ic->ic_txpowlimit = i;
if (ctlp->rp != NULL) {
crit_enter();
- for (i = 0 ; i < sizeof(p_rp_addr) / sizeof(*p_rp_addr) ; i++)
+ for (i = 0 ; i < NELEM(p_rp_addr) ; i++)
if (p_rp_addr[i] == ctlp->rp)
p_rp_addr[i] = NULL;
- for (i = 0 ; i < sizeof(p_rp_table) / sizeof(*p_rp_table) ; i++)
+ for (i = 0 ; i < NELEM(p_rp_table) ; i++)
if (p_rp_table[i] == ctlp->rp)
p_rp_table[i] = NULL;
crit_exit();
{ STL_PCINSVENDID, STL_PCINSDEVID, BRD_ECHPCI },
};
-static int stl_nrpcibrds = sizeof(stl_pcibrds) / sizeof(stlpcibrd_t);
+static int stl_nrpcibrds = NELEM(stl_pcibrds);
/*****************************************************************************/
230400, 460800
};
-#define SC26198_NRBAUDS (sizeof(sc26198_baudtable) / sizeof(unsigned int))
+#define SC26198_NRBAUDS NELEM(sc26198_baudtable)
/*
* Define the maximum baud rate of the sc26198 devices.
base = isa_get_port(scp->dev);
else
base = 0;
- for (i = 0 ; i < sizeof(scp->io) / sizeof(*scp->io) ; i++) {
+ for (i = 0 ; i < NELEM(scp->io) ; i++) {
if (scp->io[i] == NULL) {
scp->io_rid[i] = i;
if (base == 0)
return (1);
scp->irq_alloced = 0;
}
- for (i = 0 ; i < sizeof(scp->drq) / sizeof(*scp->drq) ; i++) {
+ for (i = 0 ; i < NELEM(scp->drq) ; i++) {
if (scp->drq[i] == NULL) {
scp->drq_rid[i] = i;
if (base == 0 || i == 0)
switch(lid) {
case LOGICALID_PCM:
case LOGICALID_NOPNP: /* XXX Non-PnP */
- for (i = 0 ; i < sizeof(scp->io) / sizeof(*scp->io) ; i++) {
+ for (i = 0 ; i < NELEM(scp->io) ; i++) {
if (scp->io[i] != NULL) {
bus_release_resource(scp->dev, SYS_RES_IOPORT, scp->io_rid[i], scp->io[i]);
scp->io[i] = NULL;
bus_release_resource(scp->dev, SYS_RES_IRQ, scp->irq_rid, scp->irq);
scp->irq = NULL;
}
- for (i = 0 ; i < sizeof(scp->drq) / sizeof(*scp->drq) ; i++) {
+ for (i = 0 ; i < NELEM(scp->drq) ; i++) {
if (scp->drq[i] != NULL) {
bus_release_resource(scp->dev, SYS_RES_DRQ, scp->drq_rid[i], scp->drq[i]);
scp->drq[i] = NULL;
{ 2941, 368, 93750, { 1, 0, 0 } },
{ 367, 1, 11719, { 0, 0, 0 } },
};
-#define NUM_DIVIDERS (sizeof (dividers) / sizeof (dividers[0]))
+#define NUM_DIVIDERS NELEM(dividers)
static void uchcom_get_status(void *, int, u_char *, u_char *);
static void uchcom_set(void *, int, int, int);
},
};
-#define METEOR_PIXFMT_TABLE_SIZE ( sizeof(meteor_pixfmt_table) / \
- sizeof(meteor_pixfmt_table[0]) )
+#define METEOR_PIXFMT_TABLE_SIZE NELEM(meteor_pixfmt_table)
#define BSWAP (BT848_COLOR_CTL_BSWAP_ODD | BT848_COLOR_CTL_BSWAP_EVEN)
ps = psbuf;
lwkt_gettoken(&p->p_token);
- if (p->p_stat > sizeof state_str / sizeof *state_str)
+ if (p->p_stat > NELEM(state_str))
state = state_str[0];
else
state = state_str[(int)p->p_stat];
15 /* 30 T_RESERVED */
};
#define bsd_to_linux_trapcode(code) \
- ((code)<sizeof(_bsd_to_linux_trapcode)/sizeof(*_bsd_to_linux_trapcode)? \
+ ((code)<NELEM(_bsd_to_linux_trapcode)? \
_bsd_to_linux_trapcode[(code)]: \
LINUX_T_UNKNOWN)
*
* @(#)tty_conf.c 8.4 (Berkeley) 1/21/94
* $FreeBSD: src/sys/kern/tty_conf.c,v 1.16.2.1 2002/03/11 01:14:55 dd Exp $
- * $DragonFly: src/sys/kern/tty_conf.c,v 1.6 2006/12/23 23:47:54 swildner Exp $
*/
#include "opt_compat.h"
NODISC(8), /* loadable */
};
-int nlinesw = sizeof (linesw) / sizeof (linesw[0]);
+int nlinesw = NELEM(linesw);
static struct linesw nodisc = NODISC(0);
(*r)->anchor->match = 0;
if (match)
*match = 0;
- if (*depth >= sizeof(pf_anchor_stack) /
- sizeof(pf_anchor_stack[0])) {
+ if (*depth >= NELEM(pf_anchor_stack)) {
kprintf("pf_step_into_anchor: stack overflow\n");
*r = TAILQ_NEXT(*r, entries);
return;
-/* $DragonFly: src/sys/netbt/hci_event.c,v 1.2 2008/03/18 13:41:42 hasso Exp $ */
/* $OpenBSD: src/sys/netbt/hci_event.c,v 1.7 2008/02/24 21:34:48 uwe Exp $ */
/* $NetBSD: hci_event.c,v 1.14 2008/02/10 17:40:54 plunky Exp $ */
hci_eventstr(unsigned int event)
{
- if (event < (sizeof(hci_eventnames) / sizeof(*hci_eventnames)))
+ if (event < NELEM(hci_eventnames))
return hci_eventnames[event];
switch (event) {
{ AF_NATM, NG_IFACE_HOOK_NATM },
{ AF_NS, NG_IFACE_HOOK_NS },
};
-#define NUM_FAMILIES (sizeof(gFamilies) / sizeof(*gFamilies))
+#define NUM_FAMILIES NELEM(gFamilies)
/* Node private data */
struct ng_iface_private {
{ AF_ATM, NG_GIF_DEMUX_HOOK_ATM },
{ AF_NATM, NG_GIF_DEMUX_HOOK_NATM },
};
-#define NUM_FAMILIES (sizeof(gFamilies) / sizeof(*gFamilies))
+#define NUM_FAMILIES NELEM(gFamilies)
/* Per-node private data */
struct ng_gif_demux_private {
{ AF_ATM, NG_IFACE_HOOK_ATM },
{ AF_NATM, NG_IFACE_HOOK_NATM },
};
-#define NUM_FAMILIES (sizeof(gFamilies) / sizeof(*gFamilies))
+#define NUM_FAMILIES NELEM(gFamilies)
/* Node private data */
struct ng_iface_private {
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/netinet/tcp_syncache.c,v 1.5.2.14 2003/02/24 04:02:27 silby Exp $
- * $DragonFly: src/sys/netinet/tcp_syncache.c,v 1.35 2008/11/22 11:03:35 sephe Exp $
*/
#include "opt_inet.h"
tcp_secret[idx].ts_secbits[i] = karc4random();
tcp_secret[idx].ts_expire = ticks + SYNCOOKIE_TIMEOUT;
}
- for (data = sizeof(tcp_msstab) / sizeof(int) - 1; data > 0; data--)
+ for (data = NELEM(tcp_msstab) - 1; data > 0; data--)
if (tcp_msstab[data] <= sc->sc_peer_mss)
break;
data = (data << SYNCOOKIE_WNDBITS) | idx;
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/netncp/ncp_mod.c,v 1.2 1999/10/12 10:36:59 bp Exp $
- * $DragonFly: src/sys/netproto/ncp/ncp_mod.c,v 1.11 2006/12/22 23:57:54 swildner Exp $
*/
#include <sys/param.h>
#include <sys/systm.h>
{3, (sy_call_t*)sys_sncp_request}
};
-#define SC_SIZE sizeof(newent)/sizeof(struct sysent)
+#define SC_SIZE NELEM(newent)
/*
* Miscellaneous modules must have their own save areas...
*/
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/netsmb/smb_smb.c,v 1.1.2.3 2002/12/14 14:44:19 fjoe Exp $
- * $DragonFly: src/sys/netproto/smb/smb_smb.c,v 1.7 2007/08/21 17:26:47 dillon Exp $
*/
/*
* various SMB requests. Most of the routines merely packs data into mbufs.
{-1, NULL}
};
-#define SMB_DIALECT_MAX (sizeof(smb_dialects) / sizeof(struct smb_dialect) - 2)
+#define SMB_DIALECT_MAX (NELEM(smb_dialects) - 2)
static int
smb_smb_nomux(struct smb_vc *vcp, struct smb_cred *scred, const char *name)
*/
ldt_segs[LUCODE_SEL].ssd_limit = atop(VM_MAX_USER_ADDRESS - 1);
ldt_segs[LUDATA_SEL].ssd_limit = atop(VM_MAX_USER_ADDRESS - 1);
- for (x = 0; x < sizeof ldt_segs / sizeof ldt_segs[0]; x++)
+ for (x = 0; x < NELEM(ldt_segs); x++)
ssdtosd(&ldt_segs[x], &ldt[x].sd);
_default_ldt = GSEL(GLDT_SEL, SEL_KPL);
MDF_WRITEBACK
};
-#define MTRRTOMRTLEN (sizeof(amd64_mtrrtomrt) / sizeof(amd64_mtrrtomrt[0]))
+#define MTRRTOMRTLEN NELEM(amd64_mtrrtomrt)
static int
amd64_mtrr2mrt(int val)