Page MenuHomeFreeBSD
Differential D18065

sfxge(4): add advanced function to extract FW version
ClosedPublic
Actions

Authored by arybchik on Nov 21 2018, 11:13 AM.
Tags
None
Referenced Files
Unknown Object (File)
Sun, Apr 20, 11:53 AM
Unknown Object (File)
Sun, Apr 20, 9:50 AM
Unknown Object (File)
Sun, Apr 20, 9:48 AM
Unknown Object (File)
Sun, Apr 20, 9:47 AM
Unknown Object (File)
Sun, Apr 20, 9:42 AM
Unknown Object (File)
Sun, Apr 20, 9:37 AM
Unknown Object (File)
Sun, Apr 20, 9:35 AM
Unknown Object (File)
Sun, Apr 20, 9:05 AM
View All 40 Files
Subscribers
imp

Details

Reviewers
gnn
philip
Commits
rS340795: sfxge(4): add advanced function to extract FW version
Summary

Some libefx-based drivers might need this functionality to
indicate DPCPU FW IDs as part of FW version info to assist
experienced users.

Submitted by: Ivan Malov <ivan.malov at oktetlabs.ru>
Sponsored by: Solarflare Communications, Inc.

Test Plan

amd64 tinderbox kernel builds tested
driver loaded/unloaded, interfaces up/down, traffic works fine

Diff Detail

Repository
rS FreeBSD src repository - subversion
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Event Timeline

arybchik created this revision.Nov 21 2018, 11:13 AM
Harbormaster completed remote builds in B20921: Diff 50661.Nov 21 2018, 11:13 AM
This revision was not accepted when it landed; it landed in state Needs Review.Nov 23 2018, 7:39 AM
Closed by commit rS340795: sfxge(4): add advanced function to extract FW version (authored by arybchik). · Explain Why
This revision was automatically updated to reflect the committed changes.
Herald added a subscriber: imp. · View Herald TranscriptNov 23 2018, 7:39 AM

Revision Contents
Changeset List

PathSize
head/
sys/
dev/
sfxge/
common/
57 lines
18 lines
9 lines
73 lines
48 lines

Diff 50944

View Options

head/sys/dev/sfxge/common/ef10_nic.c

Show First 20 Lines • Show All 201 Lines • ▼ Show 20 Lines#elif defined(UFS2_ONLY)
fs.fs_sblockloc == sblock_try[n]) fs.fs_sblockloc == sblock_try[n])
#else #else
fs.fs_magic == FS_UFS1_MAGIC || fs.fs_magic == FS_UFS1_MAGIC ||
(fs.fs_magic == FS_UFS2_MAGIC && (fs.fs_magic == FS_UFS2_MAGIC &&
fs.fs_sblockloc == sblock_try[n]) fs.fs_sblockloc == sblock_try[n])
#endif #endif
) && ) &&
fs.fs_bsize <= MAXBSIZE && fs.fs_bsize <= MAXBSIZE &&
fs.fs_bsize >= sizeof(struct fs)) fs.fs_bsize >= (int32_t)sizeof(struct fs))
break; break;
} }
if (sblock_try[n] == -1) { if (sblock_try[n] == -1) {
return -1; return -1;
} }
dsk_meta++; dsk_meta++;
} else } else
memcpy(&fs, dmadat->sbbuf, sizeof(struct fs)); memcpy(&fs, dmadat->sbbuf, sizeof(struct fs));
if (!inode) if (!inode)
return 0; return 0;
if (inomap != inode) { if (inomap != inode) {
n = IPERVBLK(&fs); n = IPERVBLK(&fs);
if (dskread(blkbuf, INO_TO_VBA(&fs, n, inode), DBPERVBLK)) if (dskread(blkbuf, INO_TO_VBA(&fs, n, inode), DBPERVBLK))
return -1; return -1;
n = INO_TO_VBO(n, inode); n = INO_TO_VBO(n, inode);
#if defined(UFS1_ONLY) #if defined(UFS1_ONLY)
memcpy(&dp1, (struct ufs1_dinode *)blkbuf + n, memcpy(&dp1, (struct ufs1_dinode *)blkbuf + n,
sizeof(struct ufs1_dinode)); sizeof(struct ufs1_dinode));
#elif defined(UFS2_ONLY) #elif defined(UFS2_ONLY)
memcpy(&dp2, (struct ufs2_dinode *)blkbuf + n, memcpy(&dp2, (struct ufs2_dinode *)blkbuf + n,
sizeof(struct ufs2_dinode)); sizeof(struct ufs2_dinode));
#else #else
if (fs.fs_magic == FS_UFS1_MAGIC) if (fs.fs_magic == FS_UFS1_MAGIC)
memcpy(&dp1, (struct ufs1_dinode *)blkbuf + n, memcpy(&dp1, (struct ufs1_dinode *)(void *)blkbuf + n,
sizeof(struct ufs1_dinode)); sizeof(struct ufs1_dinode));
else else
memcpy(&dp2, (struct ufs2_dinode *)blkbuf + n, memcpy(&dp2, (struct ufs2_dinode *)(void *)blkbuf + n,
sizeof(struct ufs2_dinode)); sizeof(struct ufs2_dinode));
#endif #endif
inomap = inode; inomap = inode;
fs_off = 0; fs_off = 0;
blkmap = indmap = 0; blkmap = indmap = 0;
} }
s = buf; s = buf;
size = DIP(di_size); size = DIP(di_size);
Show All 32 Lines#else
} else } else
memcpy(&addr2, (ufs2_daddr_t *)indbuf + n, memcpy(&addr2, (ufs2_daddr_t *)indbuf + n,
sizeof(ufs2_daddr_t)); sizeof(ufs2_daddr_t));
#endif #endif
} else } else
return -1; return -1;
vbaddr = fsbtodb(&fs, addr2) + (off >> VBLKSHIFT) * DBPERVBLK; vbaddr = fsbtodb(&fs, addr2) + (off >> VBLKSHIFT) * DBPERVBLK;
vboff = off & VBLKMASK; vboff = off & VBLKMASK;
n = sblksize(&fs, size, lbn) - (off & ~VBLKMASK); n = sblksize(&fs, (off_t)size, lbn) - (off & ~VBLKMASK);
if (n > VBLKSIZE) if (n > VBLKSIZE)
n = VBLKSIZE; n = VBLKSIZE;
if (blkmap != vbaddr) { if (blkmap != vbaddr) {
if (dskread(blkbuf, vbaddr, n >> DEV_BSHIFT)) if (dskread(blkbuf, vbaddr, n >> DEV_BSHIFT))
return -1; return -1;
blkmap = vbaddr; blkmap = vbaddr;
} }
n -= vboff; n -= vboff;
Show All 9 Lines
View Options

head/sys/dev/sfxge/common/efx.h

Show First 20 Lines • Show All 201 Lines • ▼ Show 20 Lines#elif defined(UFS2_ONLY)
fs.fs_sblockloc == sblock_try[n]) fs.fs_sblockloc == sblock_try[n])
#else #else
fs.fs_magic == FS_UFS1_MAGIC || fs.fs_magic == FS_UFS1_MAGIC ||
(fs.fs_magic == FS_UFS2_MAGIC && (fs.fs_magic == FS_UFS2_MAGIC &&
fs.fs_sblockloc == sblock_try[n]) fs.fs_sblockloc == sblock_try[n])
#endif #endif
) && ) &&
fs.fs_bsize <= MAXBSIZE && fs.fs_bsize <= MAXBSIZE &&
fs.fs_bsize >= sizeof(struct fs)) fs.fs_bsize >= (int32_t)sizeof(struct fs))
break; break;
} }
if (sblock_try[n] == -1) { if (sblock_try[n] == -1) {
return -1; return -1;
} }
dsk_meta++; dsk_meta++;
} else } else
memcpy(&fs, dmadat->sbbuf, sizeof(struct fs)); memcpy(&fs, dmadat->sbbuf, sizeof(struct fs));
if (!inode) if (!inode)
return 0; return 0;
if (inomap != inode) { if (inomap != inode) {
n = IPERVBLK(&fs); n = IPERVBLK(&fs);
if (dskread(blkbuf, INO_TO_VBA(&fs, n, inode), DBPERVBLK)) if (dskread(blkbuf, INO_TO_VBA(&fs, n, inode), DBPERVBLK))
return -1; return -1;
n = INO_TO_VBO(n, inode); n = INO_TO_VBO(n, inode);
#if defined(UFS1_ONLY) #if defined(UFS1_ONLY)
memcpy(&dp1, (struct ufs1_dinode *)blkbuf + n, memcpy(&dp1, (struct ufs1_dinode *)blkbuf + n,
sizeof(struct ufs1_dinode)); sizeof(struct ufs1_dinode));
#elif defined(UFS2_ONLY) #elif defined(UFS2_ONLY)
memcpy(&dp2, (struct ufs2_dinode *)blkbuf + n, memcpy(&dp2, (struct ufs2_dinode *)blkbuf + n,
sizeof(struct ufs2_dinode)); sizeof(struct ufs2_dinode));
#else #else
if (fs.fs_magic == FS_UFS1_MAGIC) if (fs.fs_magic == FS_UFS1_MAGIC)
memcpy(&dp1, (struct ufs1_dinode *)blkbuf + n, memcpy(&dp1, (struct ufs1_dinode *)(void *)blkbuf + n,
sizeof(struct ufs1_dinode)); sizeof(struct ufs1_dinode));
else else
memcpy(&dp2, (struct ufs2_dinode *)blkbuf + n, memcpy(&dp2, (struct ufs2_dinode *)(void *)blkbuf + n,
sizeof(struct ufs2_dinode)); sizeof(struct ufs2_dinode));
#endif #endif
inomap = inode; inomap = inode;
fs_off = 0; fs_off = 0;
blkmap = indmap = 0; blkmap = indmap = 0;
} }
s = buf; s = buf;
size = DIP(di_size); size = DIP(di_size);
Show All 32 Lines#else
} else } else
memcpy(&addr2, (ufs2_daddr_t *)indbuf + n, memcpy(&addr2, (ufs2_daddr_t *)indbuf + n,
sizeof(ufs2_daddr_t)); sizeof(ufs2_daddr_t));
#endif #endif
} else } else
return -1; return -1;
vbaddr = fsbtodb(&fs, addr2) + (off >> VBLKSHIFT) * DBPERVBLK; vbaddr = fsbtodb(&fs, addr2) + (off >> VBLKSHIFT) * DBPERVBLK;
vboff = off & VBLKMASK; vboff = off & VBLKMASK;
n = sblksize(&fs, size, lbn) - (off & ~VBLKMASK); n = sblksize(&fs, (off_t)size, lbn) - (off & ~VBLKMASK);
if (n > VBLKSIZE) if (n > VBLKSIZE)
n = VBLKSIZE; n = VBLKSIZE;
if (blkmap != vbaddr) { if (blkmap != vbaddr) {
if (dskread(blkbuf, vbaddr, n >> DEV_BSHIFT)) if (dskread(blkbuf, vbaddr, n >> DEV_BSHIFT))
return -1; return -1;
blkmap = vbaddr; blkmap = vbaddr;
} }
n -= vboff; n -= vboff;
Show All 9 Lines
View Options

head/sys/dev/sfxge/common/efx_mcdi.h

Show First 20 Lines • Show All 201 Lines • ▼ Show 20 Lines#elif defined(UFS2_ONLY)
fs.fs_sblockloc == sblock_try[n]) fs.fs_sblockloc == sblock_try[n])
#else #else
fs.fs_magic == FS_UFS1_MAGIC || fs.fs_magic == FS_UFS1_MAGIC ||
(fs.fs_magic == FS_UFS2_MAGIC && (fs.fs_magic == FS_UFS2_MAGIC &&
fs.fs_sblockloc == sblock_try[n]) fs.fs_sblockloc == sblock_try[n])
#endif #endif
) && ) &&
fs.fs_bsize <= MAXBSIZE && fs.fs_bsize <= MAXBSIZE &&
fs.fs_bsize >= sizeof(struct fs)) fs.fs_bsize >= (int32_t)sizeof(struct fs))
break; break;
} }
if (sblock_try[n] == -1) { if (sblock_try[n] == -1) {
return -1; return -1;
} }
dsk_meta++; dsk_meta++;
} else } else
memcpy(&fs, dmadat->sbbuf, sizeof(struct fs)); memcpy(&fs, dmadat->sbbuf, sizeof(struct fs));
if (!inode) if (!inode)
return 0; return 0;
if (inomap != inode) { if (inomap != inode) {
n = IPERVBLK(&fs); n = IPERVBLK(&fs);
if (dskread(blkbuf, INO_TO_VBA(&fs, n, inode), DBPERVBLK)) if (dskread(blkbuf, INO_TO_VBA(&fs, n, inode), DBPERVBLK))
return -1; return -1;
n = INO_TO_VBO(n, inode); n = INO_TO_VBO(n, inode);
#if defined(UFS1_ONLY) #if defined(UFS1_ONLY)
memcpy(&dp1, (struct ufs1_dinode *)blkbuf + n, memcpy(&dp1, (struct ufs1_dinode *)blkbuf + n,
sizeof(struct ufs1_dinode)); sizeof(struct ufs1_dinode));
#elif defined(UFS2_ONLY) #elif defined(UFS2_ONLY)
memcpy(&dp2, (struct ufs2_dinode *)blkbuf + n, memcpy(&dp2, (struct ufs2_dinode *)blkbuf + n,
sizeof(struct ufs2_dinode)); sizeof(struct ufs2_dinode));
#else #else
if (fs.fs_magic == FS_UFS1_MAGIC) if (fs.fs_magic == FS_UFS1_MAGIC)
memcpy(&dp1, (struct ufs1_dinode *)blkbuf + n, memcpy(&dp1, (struct ufs1_dinode *)(void *)blkbuf + n,
sizeof(struct ufs1_dinode)); sizeof(struct ufs1_dinode));
else else
memcpy(&dp2, (struct ufs2_dinode *)blkbuf + n, memcpy(&dp2, (struct ufs2_dinode *)(void *)blkbuf + n,
sizeof(struct ufs2_dinode)); sizeof(struct ufs2_dinode));
#endif #endif
inomap = inode; inomap = inode;
fs_off = 0; fs_off = 0;
blkmap = indmap = 0; blkmap = indmap = 0;
} }
s = buf; s = buf;
size = DIP(di_size); size = DIP(di_size);
Show All 32 Lines#else
} else } else
memcpy(&addr2, (ufs2_daddr_t *)indbuf + n, memcpy(&addr2, (ufs2_daddr_t *)indbuf + n,
sizeof(ufs2_daddr_t)); sizeof(ufs2_daddr_t));
#endif #endif
} else } else
return -1; return -1;
vbaddr = fsbtodb(&fs, addr2) + (off >> VBLKSHIFT) * DBPERVBLK; vbaddr = fsbtodb(&fs, addr2) + (off >> VBLKSHIFT) * DBPERVBLK;
vboff = off & VBLKMASK; vboff = off & VBLKMASK;
n = sblksize(&fs, size, lbn) - (off & ~VBLKMASK); n = sblksize(&fs, (off_t)size, lbn) - (off & ~VBLKMASK);
if (n > VBLKSIZE) if (n > VBLKSIZE)
n = VBLKSIZE; n = VBLKSIZE;
if (blkmap != vbaddr) { if (blkmap != vbaddr) {
if (dskread(blkbuf, vbaddr, n >> DEV_BSHIFT)) if (dskread(blkbuf, vbaddr, n >> DEV_BSHIFT))
return -1; return -1;
blkmap = vbaddr; blkmap = vbaddr;
} }
n -= vboff; n -= vboff;
Show All 9 Lines
View Options

head/sys/dev/sfxge/common/efx_mcdi.c

Show First 20 Lines • Show All 201 Lines • ▼ Show 20 Lines#elif defined(UFS2_ONLY)
fs.fs_sblockloc == sblock_try[n]) fs.fs_sblockloc == sblock_try[n])
#else #else
fs.fs_magic == FS_UFS1_MAGIC || fs.fs_magic == FS_UFS1_MAGIC ||
(fs.fs_magic == FS_UFS2_MAGIC && (fs.fs_magic == FS_UFS2_MAGIC &&
fs.fs_sblockloc == sblock_try[n]) fs.fs_sblockloc == sblock_try[n])
#endif #endif
) && ) &&
fs.fs_bsize <= MAXBSIZE && fs.fs_bsize <= MAXBSIZE &&
fs.fs_bsize >= sizeof(struct fs)) fs.fs_bsize >= (int32_t)sizeof(struct fs))
break; break;
} }
if (sblock_try[n] == -1) { if (sblock_try[n] == -1) {
return -1; return -1;
} }
dsk_meta++; dsk_meta++;
} else } else
memcpy(&fs, dmadat->sbbuf, sizeof(struct fs)); memcpy(&fs, dmadat->sbbuf, sizeof(struct fs));
if (!inode) if (!inode)
return 0; return 0;
if (inomap != inode) { if (inomap != inode) {
n = IPERVBLK(&fs); n = IPERVBLK(&fs);
if (dskread(blkbuf, INO_TO_VBA(&fs, n, inode), DBPERVBLK)) if (dskread(blkbuf, INO_TO_VBA(&fs, n, inode), DBPERVBLK))
return -1; return -1;
n = INO_TO_VBO(n, inode); n = INO_TO_VBO(n, inode);
#if defined(UFS1_ONLY) #if defined(UFS1_ONLY)
memcpy(&dp1, (struct ufs1_dinode *)blkbuf + n, memcpy(&dp1, (struct ufs1_dinode *)blkbuf + n,
sizeof(struct ufs1_dinode)); sizeof(struct ufs1_dinode));
#elif defined(UFS2_ONLY) #elif defined(UFS2_ONLY)
memcpy(&dp2, (struct ufs2_dinode *)blkbuf + n, memcpy(&dp2, (struct ufs2_dinode *)blkbuf + n,
sizeof(struct ufs2_dinode)); sizeof(struct ufs2_dinode));
#else #else
if (fs.fs_magic == FS_UFS1_MAGIC) if (fs.fs_magic == FS_UFS1_MAGIC)
memcpy(&dp1, (struct ufs1_dinode *)blkbuf + n, memcpy(&dp1, (struct ufs1_dinode *)(void *)blkbuf + n,
sizeof(struct ufs1_dinode)); sizeof(struct ufs1_dinode));
else else
memcpy(&dp2, (struct ufs2_dinode *)blkbuf + n, memcpy(&dp2, (struct ufs2_dinode *)(void *)blkbuf + n,
sizeof(struct ufs2_dinode)); sizeof(struct ufs2_dinode));
#endif #endif
inomap = inode; inomap = inode;
fs_off = 0; fs_off = 0;
blkmap = indmap = 0; blkmap = indmap = 0;
} }
s = buf; s = buf;
size = DIP(di_size); size = DIP(di_size);
Show All 32 Lines#else
} else } else
memcpy(&addr2, (ufs2_daddr_t *)indbuf + n, memcpy(&addr2, (ufs2_daddr_t *)indbuf + n,
sizeof(ufs2_daddr_t)); sizeof(ufs2_daddr_t));
#endif #endif
} else } else
return -1; return -1;
vbaddr = fsbtodb(&fs, addr2) + (off >> VBLKSHIFT) * DBPERVBLK; vbaddr = fsbtodb(&fs, addr2) + (off >> VBLKSHIFT) * DBPERVBLK;
vboff = off & VBLKMASK; vboff = off & VBLKMASK;
n = sblksize(&fs, size, lbn) - (off & ~VBLKMASK); n = sblksize(&fs, (off_t)size, lbn) - (off & ~VBLKMASK);
if (n > VBLKSIZE) if (n > VBLKSIZE)
n = VBLKSIZE; n = VBLKSIZE;
if (blkmap != vbaddr) { if (blkmap != vbaddr) {
if (dskread(blkbuf, vbaddr, n >> DEV_BSHIFT)) if (dskread(blkbuf, vbaddr, n >> DEV_BSHIFT))
return -1; return -1;
blkmap = vbaddr; blkmap = vbaddr;
} }
n -= vboff; n -= vboff;
Show All 9 Lines
View Options

head/sys/dev/sfxge/common/efx_nic.c

Show First 20 Lines • Show All 201 Lines • ▼ Show 20 Lines#elif defined(UFS2_ONLY)
fs.fs_sblockloc == sblock_try[n]) fs.fs_sblockloc == sblock_try[n])
#else #else
fs.fs_magic == FS_UFS1_MAGIC || fs.fs_magic == FS_UFS1_MAGIC ||
(fs.fs_magic == FS_UFS2_MAGIC && (fs.fs_magic == FS_UFS2_MAGIC &&
fs.fs_sblockloc == sblock_try[n]) fs.fs_sblockloc == sblock_try[n])
#endif #endif
) && ) &&
fs.fs_bsize <= MAXBSIZE && fs.fs_bsize <= MAXBSIZE &&
fs.fs_bsize >= sizeof(struct fs)) fs.fs_bsize >= (int32_t)sizeof(struct fs))
break; break;
} }
if (sblock_try[n] == -1) { if (sblock_try[n] == -1) {
return -1; return -1;
} }
dsk_meta++; dsk_meta++;
} else } else
memcpy(&fs, dmadat->sbbuf, sizeof(struct fs)); memcpy(&fs, dmadat->sbbuf, sizeof(struct fs));
if (!inode) if (!inode)
return 0; return 0;
if (inomap != inode) { if (inomap != inode) {
n = IPERVBLK(&fs); n = IPERVBLK(&fs);
if (dskread(blkbuf, INO_TO_VBA(&fs, n, inode), DBPERVBLK)) if (dskread(blkbuf, INO_TO_VBA(&fs, n, inode), DBPERVBLK))
return -1; return -1;
n = INO_TO_VBO(n, inode); n = INO_TO_VBO(n, inode);
#if defined(UFS1_ONLY) #if defined(UFS1_ONLY)
memcpy(&dp1, (struct ufs1_dinode *)blkbuf + n, memcpy(&dp1, (struct ufs1_dinode *)blkbuf + n,
sizeof(struct ufs1_dinode)); sizeof(struct ufs1_dinode));
#elif defined(UFS2_ONLY) #elif defined(UFS2_ONLY)
memcpy(&dp2, (struct ufs2_dinode *)blkbuf + n, memcpy(&dp2, (struct ufs2_dinode *)blkbuf + n,
sizeof(struct ufs2_dinode)); sizeof(struct ufs2_dinode));
#else #else
if (fs.fs_magic == FS_UFS1_MAGIC) if (fs.fs_magic == FS_UFS1_MAGIC)
memcpy(&dp1, (struct ufs1_dinode *)blkbuf + n, memcpy(&dp1, (struct ufs1_dinode *)(void *)blkbuf + n,
sizeof(struct ufs1_dinode)); sizeof(struct ufs1_dinode));
else else
memcpy(&dp2, (struct ufs2_dinode *)blkbuf + n, memcpy(&dp2, (struct ufs2_dinode *)(void *)blkbuf + n,
sizeof(struct ufs2_dinode)); sizeof(struct ufs2_dinode));
#endif #endif
inomap = inode; inomap = inode;
fs_off = 0; fs_off = 0;
blkmap = indmap = 0; blkmap = indmap = 0;
} }
s = buf; s = buf;
size = DIP(di_size); size = DIP(di_size);
Show All 32 Lines#else
} else } else
memcpy(&addr2, (ufs2_daddr_t *)indbuf + n, memcpy(&addr2, (ufs2_daddr_t *)indbuf + n,
sizeof(ufs2_daddr_t)); sizeof(ufs2_daddr_t));
#endif #endif
} else } else
return -1; return -1;
vbaddr = fsbtodb(&fs, addr2) + (off >> VBLKSHIFT) * DBPERVBLK; vbaddr = fsbtodb(&fs, addr2) + (off >> VBLKSHIFT) * DBPERVBLK;
vboff = off & VBLKMASK; vboff = off & VBLKMASK;
n = sblksize(&fs, size, lbn) - (off & ~VBLKMASK); n = sblksize(&fs, (off_t)size, lbn) - (off & ~VBLKMASK);
if (n > VBLKSIZE) if (n > VBLKSIZE)
n = VBLKSIZE; n = VBLKSIZE;
if (blkmap != vbaddr) { if (blkmap != vbaddr) {
if (dskread(blkbuf, vbaddr, n >> DEV_BSHIFT)) if (dskread(blkbuf, vbaddr, n >> DEV_BSHIFT))
return -1; return -1;
blkmap = vbaddr; blkmap = vbaddr;
} }
n -= vboff; n -= vboff;
Show All 9 Lines