Symbol: blk
bin/pax/cpio.c
250
cpio_id(char *blk, int size)
bin/pax/cpio.c
253
(strncmp(blk, AMAGIC, sizeof(AMAGIC) - 1) != 0))
bin/pax/cpio.c
489
vcpio_id(char *blk, int size)
bin/pax/cpio.c
492
(strncmp(blk, AVMAGIC, sizeof(AVMAGIC) - 1) != 0))
bin/pax/cpio.c
506
crc_id(char *blk, int size)
bin/pax/cpio.c
509
(strncmp(blk, AVCMAGIC, (int)sizeof(AVCMAGIC) - 1) != 0))
bin/pax/cpio.c
811
bcpio_id(char *blk, int size)
bin/pax/cpio.c
819
if (((u_short)SHRT_EXT(blk)) == MAGIC)
bin/pax/cpio.c
821
if (((u_short)RSHRT_EXT(blk)) == MAGIC) {
bin/pax/tar.c
248
tar_chksm(char *blk, int len)
bin/pax/tar.c
257
pt = blk;
bin/pax/tar.c
258
stop = blk + CHK_OFFSET;
bin/pax/tar.c
269
stop = blk + len;
bin/pax/tar.c
289
tar_id(char *blk, int size)
bin/pax/tar.c
296
hd = (HD_TAR *)blk;
bin/pax/tar.c
297
uhd = (HD_USTAR *)blk;
bin/pax/tar.c
310
if (asc_ul(hd->chksum,sizeof(hd->chksum),OCT) != tar_chksm(blk,BLKMULT))
bin/pax/tar.c
673
ustar_id(char *blk, int size)
bin/pax/tar.c
679
hd = (HD_USTAR *)blk;
bin/pax/tar.c
691
if (asc_ul(hd->chksum,sizeof(hd->chksum),OCT) != tar_chksm(blk,BLKMULT))
crypto/openssh/openbsd-compat/sha1.c
43
#define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30);
crypto/openssh/openbsd-compat/sha1.c
44
#define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
crypto/openssh/openbsd-compat/sha1.c
45
#define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);
crypto/openssh/openbsd-compat/sha1.c
46
#define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);
crypto/openssl/crypto/param_build.c
399
OSSL_PARAM_ALIGNED_BLOCK *blk,
crypto/openssl/crypto/param_build.c
417
p = blk;
crypto/openssl/crypto/param_build.c
418
blk += pd->alloc_blocks;
crypto/openssl/crypto/param_build.c
453
OSSL_PARAM_ALIGNED_BLOCK *blk, *s = NULL;
crypto/openssl/crypto/param_build.c
480
blk = p_blks + (OSSL_PARAM_ALIGNED_BLOCK *)(params);
crypto/openssl/crypto/param_build.c
481
last = param_bld_convert(bld, params, blk, s);
crypto/openssl/ssl/ssl_ciph.c
2155
int mac = 0, in = 0, blk = 0, out = 0;
crypto/openssl/ssl/ssl_ciph.c
2194
blk = EVP_CIPHER_get_block_size(e_ciph);
crypto/openssl/ssl/ssl_ciph.c
2195
if (blk <= 0)
crypto/openssl/ssl/ssl_ciph.c
2202
*blocksize = (size_t)blk;
crypto/openssl/test/cipher_overhead_test.c
37
size_t mac, in, blk, ex;
crypto/openssl/test/cipher_overhead_test.c
47
if (!TEST_true(ssl_cipher_get_overhead(ciph, &mac, &in, &blk, &ex))) {
crypto/openssl/test/cipher_overhead_test.c
52
ciph->name, mac, in, blk, ex);
lib/libufs/cgroup.c
103
blk = blkmap(fs, blksfree, bbase);
lib/libufs/cgroup.c
104
ffs_fragacct(fs, blk, cgp->cg_frsum, -1);
lib/libufs/cgroup.c
117
blk = blkmap(fs, blksfree, bbase);
lib/libufs/cgroup.c
118
ffs_fragacct(fs, blk, cgp->cg_frsum, 1);
lib/libufs/cgroup.c
82
int i, cg, blk, frags, bbase;
sbin/dump/cache.c
118
while ((blk = *pblk) != NULL) {
sbin/dump/cache.c
119
if (((blk->b_Offset ^ offset) & mask) == 0)
sbin/dump/cache.c
122
pblk = &blk->b_HNext;
sbin/dump/cache.c
124
if (blk == NULL) {
sbin/dump/cache.c
125
blk = *ppblk;
sbin/dump/cache.c
127
blk->b_Offset = offset & mask;
sbin/dump/cache.c
128
n = pread(fd, blk->b_Data, BlockSize, blk->b_Offset);
sbin/dump/cache.c
130
blk->b_Offset = (off_t)-1;
sbin/dump/cache.c
131
blk = NULL;
sbin/dump/cache.c
134
if (blk) {
sbin/dump/cache.c
135
bcopy(blk->b_Data + (offset - blk->b_Offset), buf, nbytes);
sbin/dump/cache.c
136
*pblk = blk->b_HNext;
sbin/dump/cache.c
137
blk->b_HNext = BlockHash[hi];
sbin/dump/cache.c
138
BlockHash[hi] = blk;
sbin/dump/cache.c
81
Block *blk;
sbin/dump/traverse.c
569
dmpindir(union dinode *dp, ino_t ino, ufs2_daddr_t blk, int ind_level,
sbin/dump/traverse.c
578
if (blk != 0)
sbin/dump/traverse.c
579
blkread(fsbtodb(sblock, blk), (char *)&idblk,
sbin/dump/traverse.c
69
static void dmpindir(union dinode *dp, ino_t ino, ufs2_daddr_t blk, int level,
sbin/fsck_ffs/fsck.h
463
void blkerror(ino_t ino, const char *type, ufs2_daddr_t blk);
sbin/fsck_ffs/fsck.h
465
int blread(int fd, char *buf, ufs2_daddr_t blk, long size);
sbin/fsck_ffs/fsck.h
467
void blwrite(int fd, char *buf, ufs2_daddr_t blk, ssize_t size);
sbin/fsck_ffs/fsck.h
468
void blerase(int fd, ufs2_daddr_t blk, long size);
sbin/fsck_ffs/fsck.h
469
void blzero(int fd, ufs2_daddr_t blk, long size);
sbin/fsck_ffs/fsck.h
482
int chkrange(ufs2_daddr_t blk, int cnt);
sbin/fsck_ffs/fsck.h
505
void getblk(struct bufarea *bp, ufs2_daddr_t blk, long size);
sbin/fsck_ffs/fsck.h
539
void rwerror(const char *mesg, ufs2_daddr_t blk);
sbin/fsck_ffs/fsutil.c
395
getblk(struct bufarea *bp, ufs2_daddr_t blk, long size)
sbin/fsck_ffs/fsutil.c
400
dblk = fsbtodb(&sblock, blk);
sbin/fsck_ffs/fsutil.c
548
int blk;
sbin/fsck_ffs/fsutil.c
574
blk = blkmap(&sblock, blksfree, fragno);
sbin/fsck_ffs/fsutil.c
575
ffs_fragacct(&sblock, blk, cgp->cg_frsum, 1);
sbin/fsck_ffs/fsutil.c
593
rwerror(const char *mesg, ufs2_daddr_t blk)
sbin/fsck_ffs/fsutil.c
600
pfatal("CANNOT %s: %ld", mesg, (long)blk);
sbin/fsck_ffs/fsutil.c
861
blread(int fd, char *buf, ufs2_daddr_t blk, long size)
sbin/fsck_ffs/fsutil.c
867
offset = blk;
sbin/fsck_ffs/fsutil.c
885
pfatal("CANNOT READ_BLK: %ld", (long)blk);
sbin/fsck_ffs/fsutil.c
888
rwerror("READ BLK", blk);
sbin/fsck_ffs/fsutil.c
897
(intmax_t)(blk * dev_bsize + i) / secsize,
sbin/fsck_ffs/fsutil.c
898
(intmax_t)blk + i / dev_bsize);
sbin/fsck_ffs/fsutil.c
900
printf(" %jd,", (intmax_t)blk + i / dev_bsize);
sbin/fsck_ffs/fsutil.c
911
blwrite(int fd, char *buf, ufs2_daddr_t blk, ssize_t size)
sbin/fsck_ffs/fsutil.c
919
offset = blk;
sbin/fsck_ffs/fsutil.c
926
rwerror("WRITE BLK", blk);
sbin/fsck_ffs/fsutil.c
930
printf(" %jd,", (intmax_t)blk + i / dev_bsize);
sbin/fsck_ffs/fsutil.c
936
blerase(int fd, ufs2_daddr_t blk, long size)
sbin/fsck_ffs/fsutil.c
942
ioarg[0] = blk * dev_bsize;
sbin/fsck_ffs/fsutil.c
954
blzero(int fd, ufs2_daddr_t blk, long size)
sbin/fsck_ffs/fsutil.c
966
offset = blk * dev_bsize;
sbin/fsck_ffs/fsutil.c
968
rwerror("SEEK BLK", blk);
sbin/fsck_ffs/fsutil.c
972
rwerror("WRITE BLK", blk);
sbin/fsck_ffs/fsutil.c
973
blk += len / dev_bsize;
sbin/fsck_ffs/inode.c
1370
blkerror(ino_t ino, const char *type, ufs2_daddr_t blk)
sbin/fsck_ffs/inode.c
1373
pfatal("%jd %s I=%ju", (intmax_t)blk, type, (uintmax_t)ino);
sbin/fsck_ffs/inode.c
321
indir_blkatoff(ufs2_daddr_t blk, ino_t ino, ufs_lbn_t cur, ufs_lbn_t lbn,
sbin/fsck_ffs/inode.c
353
bp = getdatablk(blk, sblock.fs_bsize, BT_LEVEL1 + level);
sbin/fsck_ffs/inode.c
356
blk = IBLK(bp, i);
sbin/fsck_ffs/inode.c
358
if (cur == lbn || blk == 0) {
sbin/fsck_ffs/inode.c
363
return (blk);
sbin/fsck_ffs/inode.c
369
return (indir_blkatoff(blk, ino, cur, lbn, bpp));
sbin/fsck_ffs/inode.c
377
chkrange(ufs2_daddr_t blk, int cnt)
sbin/fsck_ffs/inode.c
381
if (cnt <= 0 || blk <= 0 || blk >= maxfsblock ||
sbin/fsck_ffs/inode.c
382
cnt > maxfsblock - blk) {
sbin/fsck_ffs/inode.c
385
(long)blk, (int)fragnum(&sblock, blk), cnt);
sbin/fsck_ffs/inode.c
389
fragnum(&sblock, blk) + cnt > sblock.fs_frag) {
sbin/fsck_ffs/inode.c
392
(long)blk, (int)fragnum(&sblock, blk), cnt);
sbin/fsck_ffs/inode.c
395
c = dtog(&sblock, blk);
sbin/fsck_ffs/inode.c
396
if (blk < cgdmin(&sblock, c)) {
sbin/fsck_ffs/inode.c
397
if ((blk + cnt) > cgsblock(&sblock, c)) {
sbin/fsck_ffs/inode.c
400
(long)blk, (long)cgdmin(&sblock, c));
sbin/fsck_ffs/inode.c
402
(long)(blk + cnt),
sbin/fsck_ffs/inode.c
408
if ((blk + cnt) > cgbase(&sblock, c+1)) {
sbin/fsck_ffs/inode.c
411
(long)blk, (long)cgdmin(&sblock, c));
sbin/fsck_ffs/inode.c
413
(long)(blk + cnt), (long)sblock.fs_fpg);
sbin/fsck_ffs/inode.c
528
ufs2_daddr_t ndb, blk;
sbin/fsck_ffs/inode.c
540
blk = ino_to_fsba(&sblock, lastinum);
sbin/fsck_ffs/inode.c
557
getblk(&inobuf, blk, size);
sbin/fsck_ffs/pass5.c
291
blk = blkmap(fs, cg_blksfree(newcg), i);
sbin/fsck_ffs/pass5.c
292
ffs_fragacct(fs, blk, newcg->cg_frsum, 1);
sbin/fsck_ffs/pass5.c
52
int c, i, j, blk, frags, basesize, mapsize;
sbin/fsck_ffs/suj.c
1005
bp = getdatablk(blk, size, BT_DIRDATA);
sbin/fsck_ffs/suj.c
1215
indir_trunc(ino_t ino, ufs_lbn_t lbn, ufs2_daddr_t blk, ufs_lbn_t lastlbn,
sbin/fsck_ffs/suj.c
1227
if (blk == 0)
sbin/fsck_ffs/suj.c
1236
bp = getdatablk(blk, fs->fs_bsize, BT_LEVEL1 + level);
sbin/fsck_ffs/suj.c
1492
ufs2_daddr_t blk;
sbin/fsck_ffs/suj.c
1505
blk = brec->jb_blkno + brec->jb_oldfrags;
sbin/fsck_ffs/suj.c
1506
isat = blk_isat(brec->jb_ino, brec->jb_lbn, blk, &frags);
sbin/fsck_ffs/suj.c
1513
"(%d)\n", JOP_OPTYPE(brec->jb_op), blk,
sbin/fsck_ffs/suj.c
1524
mask = blk_freemask(blk, brec->jb_ino, brec->jb_lbn,
sbin/fsck_ffs/suj.c
1527
blk += frags;
sbin/fsck_ffs/suj.c
1529
blk_free(brec->jb_ino, blk, mask, frags);
sbin/fsck_ffs/suj.c
1540
blk_free_lbn(blk, brec->jb_ino, brec->jb_lbn, brec->jb_frags,
sbin/fsck_ffs/suj.c
1908
ufs2_daddr_t blk;
sbin/fsck_ffs/suj.c
1918
blk = blknum(fs, blkrec->jb_blkno);
sbin/fsck_ffs/suj.c
1920
if (blkrec->jb_blkno < 0 || blk + fs->fs_frag - frag > fs->fs_size)
sbin/fsck_ffs/suj.c
1923
sblk = blk_lookup(blk, 1);
sbin/fsck_ffs/suj.c
2266
suj_add_block(ino_t ino, ufs_lbn_t lbn, ufs2_daddr_t blk, int frags)
sbin/fsck_ffs/suj.c
2269
jblocks_add(suj_jblocks, fsbtodb(fs, blk), fsbtodb(fs, frags));
sbin/fsck_ffs/suj.c
2279
ufs2_daddr_t blk;
sbin/fsck_ffs/suj.c
2297
blk = jblocks_next(suj_jblocks, size, &readsize);
sbin/fsck_ffs/suj.c
2298
if (blk == 0)
sbin/fsck_ffs/suj.c
2304
if (pread(fsreadfd, &block, size, dbtob(blk)) != size) {
sbin/fsck_ffs/suj.c
2306
(intmax_t)blk);
sbin/fsck_ffs/suj.c
238
blk_lookup(ufs2_daddr_t blk, int creat)
sbin/fsck_ffs/suj.c
244
sc = cg_lookup(dtog(fs, blk));
sbin/fsck_ffs/suj.c
245
if (sc->sc_lastblk && sc->sc_lastblk->sb_blk == blk)
sbin/fsck_ffs/suj.c
247
hd = &sc->sc_blkhash[HASH(fragstoblks(fs, blk))];
sbin/fsck_ffs/suj.c
249
if (sblk->sb_blk == blk)
sbin/fsck_ffs/suj.c
255
sblk->sb_blk = blk;
sbin/fsck_ffs/suj.c
309
blk_freemask(ufs2_daddr_t blk, ino_t ino, ufs_lbn_t lbn, int frags)
sbin/fsck_ffs/suj.c
325
sblk = blk_lookup(blknum(fs, blk), 0);
sbin/fsck_ffs/suj.c
328
off = blk - sblk->sb_blk;
sbin/fsck_ffs/suj.c
336
if (blk_overlaps(brec, blk, frags) == 0)
sbin/fsck_ffs/suj.c
338
if (blk_equals(brec, ino, lbn, blk, frags) == 1)
sbin/fsck_ffs/suj.c
345
blk, sblk->sb_blk, off, mask);
sbin/fsck_ffs/suj.c
361
blk_isindir(ufs2_daddr_t blk, ino_t ino, ufs_lbn_t lbn)
sbin/fsck_ffs/suj.c
366
sblk = blk_lookup(blk, 0);
sbin/fsck_ffs/suj.c
372
if (blk_equals(brec, ino, lbn, blk, fs->fs_frag))
sbin/fsck_ffs/suj.c
374
return (!blk_isfree(blk));
sbin/fsck_ffs/suj.c
530
blk_isat(ino_t ino, ufs_lbn_t lbn, ufs2_daddr_t blk, int *frags)
sbin/fsck_ffs/suj.c
544
return (nblk == blk);
sbin/fsck_ffs/suj.c
557
ufs2_daddr_t blk;
sbin/fsck_ffs/suj.c
572
blk = ino_blkatoff(dip, parent, lbn, &frags, NULL);
sbin/fsck_ffs/suj.c
575
bp = getdatablk(blk, blksize, BT_DIRDATA);
sbin/fsck_ffs/suj.c
602
ufs2_daddr_t blk;
sbin/fsck_ffs/suj.c
641
blk = ino_blkatoff(dip, parent, lbn, &frags, NULL);
sbin/fsck_ffs/suj.c
643
if (blk <= 0) {
sbin/fsck_ffs/suj.c
648
bp = getdatablk(blk, blksize, BT_DIRDATA);
sbin/fsck_ffs/suj.c
705
indir_visit(ino_t ino, ufs_lbn_t lbn, ufs2_daddr_t blk, uint64_t *frags,
sbin/fsck_ffs/suj.c
721
if (blk == 0)
sbin/fsck_ffs/suj.c
726
if ((flags & VISIT_ROOT) == 0 && blk_isindir(blk, ino, lbn) == 0) {
sbin/fsck_ffs/suj.c
729
blk, (uintmax_t)ino, lbn, level);
sbin/fsck_ffs/suj.c
735
bp = getdatablk(blk, fs->fs_bsize, BT_LEVEL1 + level);
sbin/fsck_ffs/suj.c
754
visitor(ino, lbn, blk, fs->fs_frag);
sbin/fsck_ffs/suj.c
826
null_visit(ino_t ino, ufs_lbn_t lbn, ufs2_daddr_t blk, int frags)
sbin/fsck_ffs/suj.c
895
blk_free_visit(ino_t ino, ufs_lbn_t lbn, ufs2_daddr_t blk, int frags)
sbin/fsck_ffs/suj.c
898
blk_free(ino, blk, blk_freemask(blk, ino, lbn, frags), frags);
sbin/fsck_ffs/suj.c
907
blk_free_lbn(ufs2_daddr_t blk, ino_t ino, ufs_lbn_t lbn, int frags, int follow)
sbin/fsck_ffs/suj.c
912
mask = blk_freemask(blk, ino, lbn, frags);
sbin/fsck_ffs/suj.c
915
indir_visit(ino, lbn, blk, &resid, blk_free_visit, VISIT_INDIR);
sbin/fsck_ffs/suj.c
917
blk_free(ino, blk, mask, frags);
sbin/fsck_ffs/suj.c
988
ino_free_children(ino_t ino, ufs_lbn_t lbn, ufs2_daddr_t blk, int frags)
sbin/fsdb/fsdb.c
55
static int founddatablk(uint64_t blk);
sbin/fsdb/fsdb.c
58
static int find_indirblks32(uint32_t blk, int ind_level, uint32_t *blknum);
sbin/fsdb/fsdb.c
59
static int find_indirblks64(uint64_t blk, int ind_level, uint64_t *blknum);
sbin/fsdb/fsdb.c
647
founddatablk(uint64_t blk)
sbin/fsdb/fsdb.c
651
(unsigned long long)fsbtodb(&sblock, blk), (uintmax_t)curinum);
sbin/fsdb/fsdb.c
661
int blk;
sbin/fsdb/fsdb.c
662
for (blk = 0; blk < size; blk++) {
sbin/fsdb/fsdb.c
663
if (buf[blk] == 0)
sbin/fsdb/fsdb.c
665
if (compare_blk32(wantedblk, buf[blk])) {
sbin/fsdb/fsdb.c
666
if (founddatablk(buf[blk]))
sbin/fsdb/fsdb.c
674
find_indirblks32(uint32_t blk, int ind_level, uint32_t *wantedblk)
sbin/fsdb/fsdb.c
680
blread(fsreadfd, (char *)idblk, fsbtodb(&sblock, blk), (int)sblock.fs_bsize);
sbin/fsdb/fsdb.c
703
int blk;
sbin/fsdb/fsdb.c
704
for (blk = 0; blk < size; blk++) {
sbin/fsdb/fsdb.c
705
if (buf[blk] == 0)
sbin/fsdb/fsdb.c
707
if (compare_blk64(wantedblk, buf[blk])) {
sbin/fsdb/fsdb.c
708
if (founddatablk(buf[blk]))
sbin/fsdb/fsdb.c
716
find_indirblks64(uint64_t blk, int ind_level, uint64_t *wantedblk)
sbin/fsdb/fsdb.c
722
blread(fsreadfd, (char *)idblk, fsbtodb(&sblock, blk), (int)sblock.fs_bsize);
sbin/fsdb/fsdb.h
33
extern int blread(int fd, char *buf, ufs2_daddr_t blk, long size);
sbin/fsdb/fsdb.h
34
extern void rwerror(const char *mesg, ufs2_daddr_t blk);
sbin/tunefs/tunefs.c
1018
blk = journal_balloc();
sbin/tunefs/tunefs.c
1019
if (blk <= 0)
sbin/tunefs/tunefs.c
1022
dp.dp1->di_db[i] = blk;
sbin/tunefs/tunefs.c
1025
dp.dp2->di_db[i] = blk;
sbin/tunefs/tunefs.c
1030
blk = journal_balloc();
sbin/tunefs/tunefs.c
1031
if (blk <= 0)
sbin/tunefs/tunefs.c
1033
blks = indir_fill(blk, i, &resid) + 1;
sbin/tunefs/tunefs.c
1039
dp.dp1->di_ib[i] = blk;
sbin/tunefs/tunefs.c
1042
dp.dp2->di_ib[i] = blk;
sbin/tunefs/tunefs.c
584
ufs2_daddr_t blk;
sbin/tunefs/tunefs.c
591
blk = cgballoc(&disk);
sbin/tunefs/tunefs.c
592
if (blk > 0)
sbin/tunefs/tunefs.c
627
if (bwrite(&disk, fsbtodb(&sblock, blk), clrbuf,
sbin/tunefs/tunefs.c
632
return (blk);
sbin/tunefs/tunefs.c
639
dir_search(ufs2_daddr_t blk, int bytes)
sbin/tunefs/tunefs.c
645
if (bread(&disk, fsbtodb(&sblock, blk), &block, bytes) <= 0) {
sbin/tunefs/tunefs.c
730
dir_insert(ufs2_daddr_t blk, off_t off, ino_t ino)
sbin/tunefs/tunefs.c
736
if (bread(&disk, fsbtodb(&sblock, blk), &block, sblock.fs_bsize) <= 0) {
sbin/tunefs/tunefs.c
749
if (bwrite(&disk, fsbtodb(&sblock, blk), &block, sblock.fs_bsize) <= 0) {
sbin/tunefs/tunefs.c
761
dir_extend(ufs2_daddr_t blk, ufs2_daddr_t nblk, off_t size, ino_t ino)
sbin/tunefs/tunefs.c
766
if (bread(&disk, fsbtodb(&sblock, blk), &block,
sbin/tunefs/tunefs.c
790
ufs2_daddr_t blk;
sbin/tunefs/tunefs.c
800
blk = 0;
sbin/tunefs/tunefs.c
814
blk = dp.dp1->di_db[lbn];
sbin/tunefs/tunefs.c
819
blk = dp.dp2->di_db[lbn];
sbin/tunefs/tunefs.c
823
if (dir_extend(blk, nblk, off, ino) == -1)
sbin/tunefs/tunefs.c
826
blk = 0;
sbin/tunefs/tunefs.c
848
if (blk) {
sbin/tunefs/tunefs.c
849
if (cgbfree(&disk, blk, size) < 0) {
sbin/tunefs/tunefs.c
859
indir_fill(ufs2_daddr_t blk, int level, int *resid)
sbin/tunefs/tunefs.c
888
if (bwrite(&disk, fsbtodb(&sblock, blk), indir.buf,
sbin/tunefs/tunefs.c
929
ufs2_daddr_t blk;
stand/common/bcache.c
187
write_strategy(void *devdata, int rw, daddr_t blk, size_t size,
stand/common/bcache.c
198
bcache_invalidate(bc, blk + i);
stand/common/bcache.c
202
return (dd->dv_strategy(dd->dv_devdata, rw, blk, size, buf, rsize));
stand/common/bcache.c
211
read_strategy(void *devdata, int rw, daddr_t blk, size_t size,
stand/common/bcache.c
237
if (BCACHE_LOOKUP(bc, (daddr_t)(blk + i))) {
stand/common/bcache.c
262
if (blk == bc->bcache_nextblkno) {
stand/common/bcache.c
270
bcopy(bc->bcache_data + (bcache_blksize * BHASH(bc, blk)), buf, size);
stand/common/bcache.c
279
p_blk = blk + i;
stand/common/bcache.c
318
if ((bc->bcache_nextblkno != blk) && ra != 0) {
stand/common/bcache.c
365
if (BCACHE_LOOKUP(bc, (daddr_t)(blk + i)))
stand/common/bcache.c
373
bcopy(bc->bcache_data + (bcache_blksize * BHASH(bc, blk)), buf, size);
stand/common/bcache.c
381
bc->bcache_nextblkno = blk + (size / DEV_BSIZE);
stand/common/bcache.c
391
bcache_strategy(void *devdata, int rw, daddr_t blk, size_t size,
stand/common/bcache.c
408
DPRINTF("bypass %zu from %jd", size / bcache_blksize, blk);
stand/common/bcache.c
411
return (dd->dv_strategy(dd->dv_devdata, rw, blk, size, buf, rsize));
stand/common/bcache.c
423
cblk = bcache_nblks - BHASH(bc, blk); /* # of blocks left */
stand/common/bcache.c
431
ret = read_strategy(devdata, rw, blk, csize, buf+total, &isize);
stand/common/bcache.c
442
blk += isize / bcache_blksize;
stand/common/bcache.c
453
return write_strategy(devdata, F_WRITE, blk, size, buf, rsize);
stand/common/bootstrap.h
84
int bcache_strategy(void *devdata, int rw, daddr_t blk, size_t size,
stand/common/dev_net.c
223
net_strategy(void *devdata, int rw, daddr_t blk, size_t size, char *buf,
stand/common/md.c
100
ofs = blk * MD_BLOCK_SIZE;
stand/common/md.c
85
md_strategy(void *devdata, int rw, daddr_t blk, size_t size,
stand/common/md.c
94
if (blk < 0 || blk >= (MD_IMAGE_SIZE / MD_BLOCK_SIZE))
stand/common/vdisk.c
247
vdisk_strategy(void *devdata, int rw, daddr_t blk, size_t size,
stand/common/vdisk.c
269
blk += offset;
stand/common/vdisk.c
271
if (lseek(vd->vdisk_fd, blk << 9, SEEK_SET) == -1)
stand/efi/libefi/efihttp.c
218
daddr_t blk __unused, size_t size __unused, char *buf __unused,
stand/efi/libefi/efihttp.c
53
static int efihttp_dev_strategy(void *devdata, int rw, daddr_t blk, size_t size,
stand/efi/libefi/efipart.c
1006
efipart_readwrite(EFI_BLOCK_IO *blkio, int rw, daddr_t blk, daddr_t nblks,
stand/efi/libefi/efipart.c
1015
if (blk < 0 || blk > blkio->Media->LastBlock)
stand/efi/libefi/efipart.c
1017
if ((blk + nblks - 1) > blkio->Media->LastBlock)
stand/efi/libefi/efipart.c
1022
status = blkio->ReadBlocks(blkio, blkio->Media->MediaId, blk,
stand/efi/libefi/efipart.c
1028
status = blkio->WriteBlocks(blkio, blkio->Media->MediaId, blk,
stand/efi/libefi/efipart.c
1037
blk, nblks, DECODE_ERROR(status));
stand/efi/libefi/efipart.c
1044
efipart_strategy(void *devdata, int rw, daddr_t blk, size_t size,
stand/efi/libefi/efipart.c
1072
return (bcache_strategy(&bcd, rw, blk + offset,
stand/efi/libefi/efipart.c
1075
return (bcache_strategy(&bcd, rw, blk, size, buf, rsize));
stand/efi/libefi/efipart.c
1079
efipart_realstrategy(void *devdata, int rw, daddr_t blk, size_t size,
stand/efi/libefi/efipart.c
1093
if (dev == NULL || blk < 0)
stand/efi/libefi/efipart.c
1107
off = blk * 512;
stand/efi/libefi/efipart.c
1171
blk = off / blkio->Media->BlockSize;
stand/efi/libefi/efipart.c
1188
rc = efipart_readwrite(blkio, rw, blk, x, blkbuf);
stand/efi/libefi/efipart.c
1205
rc = efipart_readwrite(blkio, F_READ, blk, x,
stand/efi/libefi/efipart.c
1214
rc = efipart_readwrite(blkio, F_READ, blk, x,
stand/efi/libefi/efipart.c
1229
rc = efipart_readwrite(blkio, F_WRITE, blk, x, blkbuf);
stand/efi/libefi/efipart.c
1242
blk += x;
stand/libsa/cd9660read.c
316
daddr_t blk, blk_off;
stand/libsa/cd9660read.c
322
blk = (cookie >> 32) & 0xffffffff;
stand/libsa/cd9660read.c
325
if (((blk << 32) | size) != cookie) {
stand/libsa/cd9660read.c
329
if (blk != curstart) {
stand/libsa/cd9660read.c
330
curstart = blk;
stand/libsa/ext2fs.c
137
#define fsb_to_db(fs, blk) ((blk) << (fs)->fs_fsbtodb)
stand/libsa/ext2fs.c
156
#define smalllblktosize(fs, blk) /* blk * bsize */ \
stand/libsa/ext2fs.c
157
((blk) << (fs)->fs_bshift)
stand/libsa/geli/gelidev.c
109
geli_dev_strategy(void *devdata, int rw, daddr_t blk, size_t size, char *buf,
stand/libsa/geli/gelidev.c
131
reqstart = blk * DEV_BSIZE;
stand/libsa/stand.h
162
int (*dv_strategy)(void *devdata, int rw, daddr_t blk,
stand/libsa/zfs/zfsimpl.c
2699
zap_get_leaf_byblk(fat_zap_t *zap, uint64_t blk, zap_leaf_t **lp)
stand/libsa/zfs/zfsimpl.c
2715
err = dnode_read(zap->zap_spa, zap->zap_dnode, blk << bs, (*lp)->l_phys,
stand/libsa/zfs/zfsimpl.c
2728
uint64_t blk = idx >> (bs - 3);
stand/libsa/zfs/zfsimpl.c
2736
rc = dnode_read(zap->zap_spa, zap->zap_dnode, (tbl->zt_blk + blk) << bs,
stand/libsa/zfs/zfsimpl.c
2760
uint64_t idx, blk;
stand/libsa/zfs/zfsimpl.c
2764
err = zap_idx_to_blk(zap, idx, &blk);
stand/libsa/zfs/zfsimpl.c
2767
return (zap_get_leaf_byblk(zap, blk, lp));
stand/uboot/uboot_disk.c
145
stor_strategy(void *devdata, int rw, daddr_t blk, size_t size,
stand/uboot/uboot_disk.c
168
err = stor_readdev(dev, blk + dev->d_offset, bcount, buf);
stand/uboot/uboot_disk.c
219
stor_readdev(struct disk_devdesc *dev, daddr_t blk, size_t size, char *buf)
stand/uboot/uboot_disk.c
224
debugf("reading blk=%d size=%d @ 0x%08x\n", (int)blk, size, (uint32_t)buf);
stand/uboot/uboot_disk.c
226
err = ub_dev_read(SI(dev).handle, buf, size, blk, &real_size);
sys/cam/scsi/scsi_cd.c
1954
error = cdplay(periph, args->blk, args->len);
sys/cam/scsi/scsi_cd.c
274
static int cdplay(struct cam_periph *periph, uint32_t blk,
sys/cam/scsi/scsi_cd.c
3221
cdplay(struct cam_periph *periph, uint32_t blk, uint32_t len)
sys/cam/scsi/scsi_cd.c
3243
scsi_ulto4b(blk, (uint8_t *)scsi_cmd->blk_addr);
sys/cam/scsi/scsi_cd.c
3252
scsi_ulto4b(blk, (uint8_t *)scsi_cmd->blk_addr);
sys/crypto/aesni/aesni_wrap.c
120
aesni_enc8(rounds - 1, key_schedule, blks->blk[0], blks->blk[1],
sys/crypto/aesni/aesni_wrap.c
121
blks->blk[2], blks->blk[3], blks->blk[4], blks->blk[5],
sys/crypto/aesni/aesni_wrap.c
122
blks->blk[6], blks->blk[7], tout);
sys/crypto/aesni/aesni_wrap.c
123
top->blk[0] = tout[0];
sys/crypto/aesni/aesni_wrap.c
124
top->blk[1] = tout[1];
sys/crypto/aesni/aesni_wrap.c
125
top->blk[2] = tout[2];
sys/crypto/aesni/aesni_wrap.c
126
top->blk[3] = tout[3];
sys/crypto/aesni/aesni_wrap.c
127
top->blk[4] = tout[4];
sys/crypto/aesni/aesni_wrap.c
128
top->blk[5] = tout[5];
sys/crypto/aesni/aesni_wrap.c
129
top->blk[6] = tout[6];
sys/crypto/aesni/aesni_wrap.c
130
top->blk[7] = tout[7];
sys/crypto/aesni/aesni_wrap.c
159
aesni_dec8(rounds - 1, key_schedule, blks->blk[0], blks->blk[1],
sys/crypto/aesni/aesni_wrap.c
160
blks->blk[2], blks->blk[3], blks->blk[4], blks->blk[5],
sys/crypto/aesni/aesni_wrap.c
161
blks->blk[6], blks->blk[7], tout);
sys/crypto/aesni/aesni_wrap.c
162
top->blk[0] = tout[0];
sys/crypto/aesni/aesni_wrap.c
163
top->blk[1] = tout[1];
sys/crypto/aesni/aesni_wrap.c
164
top->blk[2] = tout[2];
sys/crypto/aesni/aesni_wrap.c
165
top->blk[3] = tout[3];
sys/crypto/aesni/aesni_wrap.c
166
top->blk[4] = tout[4];
sys/crypto/aesni/aesni_wrap.c
167
top->blk[5] = tout[5];
sys/crypto/aesni/aesni_wrap.c
168
top->blk[6] = tout[6];
sys/crypto/aesni/aesni_wrap.c
169
top->blk[7] = tout[7];
sys/crypto/aesni/aesni_wrap.c
247
top->blk[0] = blks->blk[0] ^ tout[0];
sys/crypto/aesni/aesni_wrap.c
248
top->blk[1] = blks->blk[1] ^ tout[1];
sys/crypto/aesni/aesni_wrap.c
249
top->blk[2] = blks->blk[2] ^ tout[2];
sys/crypto/aesni/aesni_wrap.c
250
top->blk[3] = blks->blk[3] ^ tout[3];
sys/crypto/aesni/aesni_wrap.c
251
top->blk[4] = blks->blk[4] ^ tout[4];
sys/crypto/aesni/aesni_wrap.c
252
top->blk[5] = blks->blk[5] ^ tout[5];
sys/crypto/aesni/aesni_wrap.c
253
top->blk[6] = blks->blk[6] ^ tout[6];
sys/crypto/aesni/aesni_wrap.c
254
top->blk[7] = blks->blk[7] ^ tout[7];
sys/crypto/aesni/aesni_wrap.c
50
__m128i blk[8];
sys/crypto/aesni/aesni_wrap.c
85
aesni_dec8(rounds - 1, key_schedule, blks->blk[0], blks->blk[1],
sys/crypto/aesni/aesni_wrap.c
86
blks->blk[2], blks->blk[3], blks->blk[4], blks->blk[5],
sys/crypto/aesni/aesni_wrap.c
87
blks->blk[6], blks->blk[7], &blocks[0]);
sys/crypto/aesni/aesni_wrap.c
89
nextiv = blks->blk[j];
sys/crypto/aesni/aesni_wrap.c
90
blks->blk[j] = blocks[j] ^ ivreg;
sys/dev/bxe/bxe.c
7186
const char *blk)
sys/dev/bxe/bxe.c
7188
BLOGI(sc, "%s%s", idx ? ", " : "", blk);
sys/dev/ice/ice_ddp_common.c
1239
for (j = 0; j < hw->blk[ICE_BLK_SW].es.fvw; j++)
sys/dev/ice/ice_ddp_common.c
1509
for (i = 0; i < hw->blk[ICE_BLK_SW].es.fvw; i++) {
sys/dev/ice/ice_ddp_common.c
1613
for (j = 0; j < hw->blk[ICE_BLK_SW].es.fvw; j++)
sys/dev/ice/ice_ddp_common.c
1618
if (j >= hw->blk[ICE_BLK_SW].es.fvw)
sys/dev/ice/ice_flex_pipe.c
1020
ice_vsig_update_xlt2_sect(struct ice_hw *hw, enum ice_block blk, u16 vsi,
sys/dev/ice/ice_flex_pipe.c
1027
bld = ice_pkg_buf_alloc_single_section(hw, ice_sect_id(blk, ICE_XLT2),
sys/dev/ice/ice_flex_pipe.c
1052
int ice_vsig_update_xlt2(struct ice_hw *hw, enum ice_block blk)
sys/dev/ice/ice_flex_pipe.c
1058
if (hw->blk[blk].xlt2.vsis[vsi].changed) {
sys/dev/ice/ice_flex_pipe.c
1062
vsig = hw->blk[blk].xlt2.vsis[vsi].vsig;
sys/dev/ice/ice_flex_pipe.c
1063
status = ice_vsig_update_xlt2_sect(hw, blk, vsi, vsig);
sys/dev/ice/ice_flex_pipe.c
1067
hw->blk[blk].xlt2.vsis[vsi].changed = 0;
sys/dev/ice/ice_flex_pipe.c
1085
ice_vsig_find_vsi(struct ice_hw *hw, enum ice_block blk, u16 vsi, u16 *vsig)
sys/dev/ice/ice_flex_pipe.c
1094
*vsig = hw->blk[blk].xlt2.vsis[vsi].vsig;
sys/dev/ice/ice_flex_pipe.c
1107
static u16 ice_vsig_alloc_val(struct ice_hw *hw, enum ice_block blk, u16 vsig)
sys/dev/ice/ice_flex_pipe.c
1111
if (!hw->blk[blk].xlt2.vsig_tbl[idx].in_use) {
sys/dev/ice/ice_flex_pipe.c
1112
INIT_LIST_HEAD(&hw->blk[blk].xlt2.vsig_tbl[idx].prop_lst);
sys/dev/ice/ice_flex_pipe.c
1113
hw->blk[blk].xlt2.vsig_tbl[idx].in_use = true;
sys/dev/ice/ice_flex_pipe.c
1127
static u16 ice_vsig_alloc(struct ice_hw *hw, enum ice_block blk)
sys/dev/ice/ice_flex_pipe.c
1132
if (!hw->blk[blk].xlt2.vsig_tbl[i].in_use)
sys/dev/ice/ice_flex_pipe.c
1133
return ice_vsig_alloc_val(hw, blk, i);
sys/dev/ice/ice_flex_pipe.c
1154
ice_find_dup_props_vsig(struct ice_hw *hw, enum ice_block blk,
sys/dev/ice/ice_flex_pipe.c
1157
struct ice_xlt2 *xlt2 = &hw->blk[blk].xlt2;
sys/dev/ice/ice_flex_pipe.c
1180
ice_vsig_free(struct ice_hw *hw, enum ice_block blk, u16 vsig)
sys/dev/ice/ice_flex_pipe.c
119
static u32 ice_sect_id(enum ice_block blk, enum ice_sect sect)
sys/dev/ice/ice_flex_pipe.c
1190
if (!hw->blk[blk].xlt2.vsig_tbl[idx].in_use)
sys/dev/ice/ice_flex_pipe.c
1193
hw->blk[blk].xlt2.vsig_tbl[idx].in_use = false;
sys/dev/ice/ice_flex_pipe.c
1195
vsi_cur = hw->blk[blk].xlt2.vsig_tbl[idx].first_vsi;
sys/dev/ice/ice_flex_pipe.c
121
return ice_sect_lkup[blk][sect];
sys/dev/ice/ice_flex_pipe.c
1211
hw->blk[blk].xlt2.vsig_tbl[idx].first_vsi = NULL;
sys/dev/ice/ice_flex_pipe.c
1216
&hw->blk[blk].xlt2.vsig_tbl[idx].prop_lst,
sys/dev/ice/ice_flex_pipe.c
1225
INIT_LIST_HEAD(&hw->blk[blk].xlt2.vsig_tbl[idx].prop_lst);
sys/dev/ice/ice_flex_pipe.c
1241
ice_vsig_remove_vsi(struct ice_hw *hw, enum ice_block blk, u16 vsi, u16 vsig)
sys/dev/ice/ice_flex_pipe.c
1251
if (!hw->blk[blk].xlt2.vsig_tbl[idx].in_use)
sys/dev/ice/ice_flex_pipe.c
1258
vsi_head = &hw->blk[blk].xlt2.vsig_tbl[idx].first_vsi;
sys/dev/ice/ice_flex_pipe.c
1262
vsi_tgt = &hw->blk[blk].xlt2.vsis[vsi];
sys/dev/ice/ice_flex_pipe.c
1299
ice_vsig_add_mv_vsi(struct ice_hw *hw, enum ice_block blk, u16 vsi, u16 vsig)
sys/dev/ice/ice_flex_pipe.c
1313
if (!hw->blk[blk].xlt2.vsig_tbl[idx].in_use &&
sys/dev/ice/ice_flex_pipe.c
1317
status = ice_vsig_find_vsi(hw, blk, vsi, &orig_vsig);
sys/dev/ice/ice_flex_pipe.c
1327
status = ice_vsig_remove_vsi(hw, blk, vsi, orig_vsig);
sys/dev/ice/ice_flex_pipe.c
1336
hw->blk[blk].xlt2.vsis[vsi].vsig = vsig;
sys/dev/ice/ice_flex_pipe.c
1337
hw->blk[blk].xlt2.vsis[vsi].changed = 1;
sys/dev/ice/ice_flex_pipe.c
1340
tmp = hw->blk[blk].xlt2.vsig_tbl[idx].first_vsi;
sys/dev/ice/ice_flex_pipe.c
1341
hw->blk[blk].xlt2.vsig_tbl[idx].first_vsi =
sys/dev/ice/ice_flex_pipe.c
1342
&hw->blk[blk].xlt2.vsis[vsi];
sys/dev/ice/ice_flex_pipe.c
1343
hw->blk[blk].xlt2.vsis[vsi].next_vsi = tmp;
sys/dev/ice/ice_flex_pipe.c
1344
hw->blk[blk].xlt2.t[vsi] = vsig;
sys/dev/ice/ice_flex_pipe.c
1357
ice_find_prof_id(struct ice_hw *hw, enum ice_block blk,
sys/dev/ice/ice_flex_pipe.c
1360
struct ice_es *es = &hw->blk[blk].es;
sys/dev/ice/ice_flex_pipe.c
1382
static bool ice_prof_id_rsrc_type(enum ice_block blk, u16 *rsrc_type)
sys/dev/ice/ice_flex_pipe.c
1384
switch (blk) {
sys/dev/ice/ice_flex_pipe.c
1402
static bool ice_tcam_ent_rsrc_type(enum ice_block blk, u16 *rsrc_type)
sys/dev/ice/ice_flex_pipe.c
1404
switch (blk) {
sys/dev/ice/ice_flex_pipe.c
1428
ice_alloc_tcam_ent(struct ice_hw *hw, enum ice_block blk, bool btm,
sys/dev/ice/ice_flex_pipe.c
1433
if (!ice_tcam_ent_rsrc_type(blk, &res_type))
sys/dev/ice/ice_flex_pipe.c
1448
ice_free_tcam_ent(struct ice_hw *hw, enum ice_block blk, u16 tcam_idx)
sys/dev/ice/ice_flex_pipe.c
1452
if (!ice_tcam_ent_rsrc_type(blk, &res_type))
sys/dev/ice/ice_flex_pipe.c
1468
ice_alloc_prof_id(struct ice_hw *hw, enum ice_block blk, u8 *prof_id)
sys/dev/ice/ice_flex_pipe.c
1474
if (!ice_prof_id_rsrc_type(blk, &res_type))
sys/dev/ice/ice_flex_pipe.c
1493
ice_free_prof_id(struct ice_hw *hw, enum ice_block blk, u8 prof_id)
sys/dev/ice/ice_flex_pipe.c
1498
if (!ice_prof_id_rsrc_type(blk, &res_type))
sys/dev/ice/ice_flex_pipe.c
1511
ice_prof_inc_ref(struct ice_hw *hw, enum ice_block blk, u8 prof_id)
sys/dev/ice/ice_flex_pipe.c
1513
if (prof_id > hw->blk[blk].es.count)
sys/dev/ice/ice_flex_pipe.c
1516
hw->blk[blk].es.ref_count[prof_id]++;
sys/dev/ice/ice_flex_pipe.c
1529
ice_write_es(struct ice_hw *hw, enum ice_block blk, u8 prof_id,
sys/dev/ice/ice_flex_pipe.c
1534
off = prof_id * hw->blk[blk].es.fvw;
sys/dev/ice/ice_flex_pipe.c
1536
ice_memset(&hw->blk[blk].es.t[off], 0, hw->blk[blk].es.fvw *
sys/dev/ice/ice_flex_pipe.c
1538
hw->blk[blk].es.written[prof_id] = false;
sys/dev/ice/ice_flex_pipe.c
1540
ice_memcpy(&hw->blk[blk].es.t[off], fv, hw->blk[blk].es.fvw *
sys/dev/ice/ice_flex_pipe.c
1552
ice_prof_dec_ref(struct ice_hw *hw, enum ice_block blk, u8 prof_id)
sys/dev/ice/ice_flex_pipe.c
1554
if (prof_id > hw->blk[blk].es.count)
sys/dev/ice/ice_flex_pipe.c
1557
if (hw->blk[blk].es.ref_count[prof_id] > 0) {
sys/dev/ice/ice_flex_pipe.c
1558
if (!--hw->blk[blk].es.ref_count[prof_id]) {
sys/dev/ice/ice_flex_pipe.c
1559
ice_write_es(hw, blk, prof_id, NULL);
sys/dev/ice/ice_flex_pipe.c
1560
return ice_free_prof_id(hw, blk, prof_id);
sys/dev/ice/ice_flex_pipe.c
1615
static void ice_init_sw_xlt1_db(struct ice_hw *hw, enum ice_block blk)
sys/dev/ice/ice_flex_pipe.c
1619
for (pt = 0; pt < hw->blk[blk].xlt1.count; pt++) {
sys/dev/ice/ice_flex_pipe.c
1622
ptg = hw->blk[blk].xlt1.t[pt];
sys/dev/ice/ice_flex_pipe.c
1624
ice_ptg_alloc_val(hw, blk, ptg);
sys/dev/ice/ice_flex_pipe.c
1625
ice_ptg_add_mv_ptype(hw, blk, pt, ptg);
sys/dev/ice/ice_flex_pipe.c
1635
static void ice_init_sw_xlt2_db(struct ice_hw *hw, enum ice_block blk)
sys/dev/ice/ice_flex_pipe.c
1639
for (vsi = 0; vsi < hw->blk[blk].xlt2.count; vsi++) {
sys/dev/ice/ice_flex_pipe.c
1642
vsig = hw->blk[blk].xlt2.t[vsi];
sys/dev/ice/ice_flex_pipe.c
1644
ice_vsig_alloc_val(hw, blk, vsig);
sys/dev/ice/ice_flex_pipe.c
1645
ice_vsig_add_mv_vsi(hw, blk, vsi, vsig);
sys/dev/ice/ice_flex_pipe.c
1649
hw->blk[blk].xlt2.vsis[vsi].changed = 0;
sys/dev/ice/ice_flex_pipe.c
1715
sizeof(*hw->blk[block_id].xlt1.t);
sys/dev/ice/ice_flex_pipe.c
1716
dst = hw->blk[block_id].xlt1.t;
sys/dev/ice/ice_flex_pipe.c
1717
dst_len = hw->blk[block_id].xlt1.count *
sys/dev/ice/ice_flex_pipe.c
1718
sizeof(*hw->blk[block_id].xlt1.t);
sys/dev/ice/ice_flex_pipe.c
1728
sizeof(*hw->blk[block_id].xlt2.t);
sys/dev/ice/ice_flex_pipe.c
1729
dst = (u8 *)hw->blk[block_id].xlt2.t;
sys/dev/ice/ice_flex_pipe.c
1730
dst_len = hw->blk[block_id].xlt2.count *
sys/dev/ice/ice_flex_pipe.c
1731
sizeof(*hw->blk[block_id].xlt2.t);
sys/dev/ice/ice_flex_pipe.c
1741
sizeof(*hw->blk[block_id].prof.t);
sys/dev/ice/ice_flex_pipe.c
1742
dst = (u8 *)hw->blk[block_id].prof.t;
sys/dev/ice/ice_flex_pipe.c
1743
dst_len = hw->blk[block_id].prof.count *
sys/dev/ice/ice_flex_pipe.c
1744
sizeof(*hw->blk[block_id].prof.t);
sys/dev/ice/ice_flex_pipe.c
1754
sizeof(*hw->blk[block_id].prof_redir.t);
sys/dev/ice/ice_flex_pipe.c
1755
dst = hw->blk[block_id].prof_redir.t;
sys/dev/ice/ice_flex_pipe.c
1756
dst_len = hw->blk[block_id].prof_redir.count *
sys/dev/ice/ice_flex_pipe.c
1757
sizeof(*hw->blk[block_id].prof_redir.t);
sys/dev/ice/ice_flex_pipe.c
1767
hw->blk[block_id].es.fvw) *
sys/dev/ice/ice_flex_pipe.c
1768
sizeof(*hw->blk[block_id].es.t);
sys/dev/ice/ice_flex_pipe.c
1769
dst = (u8 *)hw->blk[block_id].es.t;
sys/dev/ice/ice_flex_pipe.c
1770
dst_len = (u32)(hw->blk[block_id].es.count *
sys/dev/ice/ice_flex_pipe.c
1771
hw->blk[block_id].es.fvw) *
sys/dev/ice/ice_flex_pipe.c
1772
sizeof(*hw->blk[block_id].es.t);
sys/dev/ice/ice_flex_pipe.c
1821
struct ice_prof_redir *prof_redir = &hw->blk[i].prof_redir;
sys/dev/ice/ice_flex_pipe.c
1822
struct ice_prof_tcam *prof = &hw->blk[i].prof;
sys/dev/ice/ice_flex_pipe.c
1823
struct ice_xlt1 *xlt1 = &hw->blk[i].xlt1;
sys/dev/ice/ice_flex_pipe.c
1824
struct ice_xlt2 *xlt2 = &hw->blk[i].xlt2;
sys/dev/ice/ice_flex_pipe.c
1825
struct ice_es *es = &hw->blk[i].es;
sys/dev/ice/ice_flex_pipe.c
1828
if (hw->blk[i].is_list_init)
sys/dev/ice/ice_flex_pipe.c
1834
hw->blk[i].is_list_init = true;
sys/dev/ice/ice_flex_pipe.c
1836
hw->blk[i].overwrite = blk_sizes[i].overwrite;
sys/dev/ice/ice_flex_pipe.c
1941
ice_fill_tbl(hw, blk_id, hw->blk[blk_id].xlt1.sid);
sys/dev/ice/ice_flex_pipe.c
1942
ice_fill_tbl(hw, blk_id, hw->blk[blk_id].xlt2.sid);
sys/dev/ice/ice_flex_pipe.c
1943
ice_fill_tbl(hw, blk_id, hw->blk[blk_id].prof.sid);
sys/dev/ice/ice_flex_pipe.c
1944
ice_fill_tbl(hw, blk_id, hw->blk[blk_id].prof_redir.sid);
sys/dev/ice/ice_flex_pipe.c
1945
ice_fill_tbl(hw, blk_id, hw->blk[blk_id].es.sid);
sys/dev/ice/ice_flex_pipe.c
1958
struct ice_es *es = &hw->blk[blk_idx].es;
sys/dev/ice/ice_flex_pipe.c
2000
static void ice_free_vsig_tbl(struct ice_hw *hw, enum ice_block blk)
sys/dev/ice/ice_flex_pipe.c
2004
if (!hw->blk[blk].xlt2.vsig_tbl)
sys/dev/ice/ice_flex_pipe.c
2008
if (hw->blk[blk].xlt2.vsig_tbl[i].in_use)
sys/dev/ice/ice_flex_pipe.c
2009
ice_vsig_free(hw, blk, i);
sys/dev/ice/ice_flex_pipe.c
2022
if (hw->blk[i].is_list_init) {
sys/dev/ice/ice_flex_pipe.c
2023
struct ice_es *es = &hw->blk[i].es;
sys/dev/ice/ice_flex_pipe.c
2031
hw->blk[i].is_list_init = false;
sys/dev/ice/ice_flex_pipe.c
2034
ice_free(hw, hw->blk[i].xlt1.ptypes);
sys/dev/ice/ice_flex_pipe.c
2035
ice_free(hw, hw->blk[i].xlt1.ptg_tbl);
sys/dev/ice/ice_flex_pipe.c
2036
ice_free(hw, hw->blk[i].xlt1.t);
sys/dev/ice/ice_flex_pipe.c
2037
ice_free(hw, hw->blk[i].xlt2.t);
sys/dev/ice/ice_flex_pipe.c
2038
ice_free(hw, hw->blk[i].xlt2.vsig_tbl);
sys/dev/ice/ice_flex_pipe.c
2039
ice_free(hw, hw->blk[i].xlt2.vsis);
sys/dev/ice/ice_flex_pipe.c
2040
ice_free(hw, hw->blk[i].prof.t);
sys/dev/ice/ice_flex_pipe.c
2041
ice_free(hw, hw->blk[i].prof_redir.t);
sys/dev/ice/ice_flex_pipe.c
2042
ice_free(hw, hw->blk[i].es.t);
sys/dev/ice/ice_flex_pipe.c
2043
ice_free(hw, hw->blk[i].es.ref_count);
sys/dev/ice/ice_flex_pipe.c
2044
ice_free(hw, hw->blk[i].es.written);
sys/dev/ice/ice_flex_pipe.c
2053
ice_memset(hw->blk, 0, sizeof(hw->blk), ICE_NONDMA_MEM);
sys/dev/ice/ice_flex_pipe.c
2065
struct ice_prof_redir *prof_redir = &hw->blk[i].prof_redir;
sys/dev/ice/ice_flex_pipe.c
2066
struct ice_prof_tcam *prof = &hw->blk[i].prof;
sys/dev/ice/ice_flex_pipe.c
2067
struct ice_xlt1 *xlt1 = &hw->blk[i].xlt1;
sys/dev/ice/ice_flex_pipe.c
2068
struct ice_xlt2 *xlt2 = &hw->blk[i].xlt2;
sys/dev/ice/ice_flex_pipe.c
2069
struct ice_es *es = &hw->blk[i].es;
sys/dev/ice/ice_flex_pipe.c
2071
if (hw->blk[i].is_list_init) {
sys/dev/ice/ice_flex_pipe.c
2147
ice_prof_gen_key(struct ice_hw *hw, enum ice_block blk, u8 ptg, u16 vsig,
sys/dev/ice/ice_flex_pipe.c
2158
switch (hw->blk[blk].prof.cdid_bits) {
sys/dev/ice/ice_flex_pipe.c
2203
ice_tcam_write_entry(struct ice_hw *hw, enum ice_block blk, u16 idx,
sys/dev/ice/ice_flex_pipe.c
2212
status = ice_prof_gen_key(hw, blk, ptg, vsig, cdid, flags, vl_msk,
sys/dev/ice/ice_flex_pipe.c
2213
dc_msk, nm_msk, hw->blk[blk].prof.t[idx].key);
sys/dev/ice/ice_flex_pipe.c
2215
hw->blk[blk].prof.t[idx].addr = CPU_TO_LE16(idx);
sys/dev/ice/ice_flex_pipe.c
2216
hw->blk[blk].prof.t[idx].prof_id = prof_id;
sys/dev/ice/ice_flex_pipe.c
2230
ice_vsig_get_ref(struct ice_hw *hw, enum ice_block blk, u16 vsig, u16 *refs)
sys/dev/ice/ice_flex_pipe.c
2237
if (!hw->blk[blk].xlt2.vsig_tbl[idx].in_use)
sys/dev/ice/ice_flex_pipe.c
2240
ptr = hw->blk[blk].xlt2.vsig_tbl[idx].first_vsi;
sys/dev/ice/ice_flex_pipe.c
2257
ice_has_prof_vsig(struct ice_hw *hw, enum ice_block blk, u16 vsig, u64 hdl)
sys/dev/ice/ice_flex_pipe.c
2262
LIST_FOR_EACH_ENTRY(ent, &hw->blk[blk].xlt2.vsig_tbl[idx].prop_lst,
sys/dev/ice/ice_flex_pipe.c
2280
ice_prof_bld_es(struct ice_hw *hw, enum ice_block blk,
sys/dev/ice/ice_flex_pipe.c
2283
u16 vec_size = hw->blk[blk].es.fvw * sizeof(struct ice_fv_word);
sys/dev/ice/ice_flex_pipe.c
2288
u16 off = tmp->prof_id * hw->blk[blk].es.fvw;
sys/dev/ice/ice_flex_pipe.c
2292
id = ice_sect_id(blk, ICE_VEC_TBL);
sys/dev/ice/ice_flex_pipe.c
2306
ice_memcpy(p->es, &hw->blk[blk].es.t[off], vec_size,
sys/dev/ice/ice_flex_pipe.c
2321
ice_prof_bld_tcam(struct ice_hw *hw, enum ice_block blk,
sys/dev/ice/ice_flex_pipe.c
2331
id = ice_sect_id(blk, ICE_PROF_TCAM);
sys/dev/ice/ice_flex_pipe.c
2346
&hw->blk[blk].prof.t[tmp->tcam_idx].key,
sys/dev/ice/ice_flex_pipe.c
2347
sizeof(hw->blk[blk].prof.t->key),
sys/dev/ice/ice_flex_pipe.c
2361
ice_prof_bld_xlt1(enum ice_block blk, struct ice_buf_build *bld,
sys/dev/ice/ice_flex_pipe.c
2371
id = ice_sect_id(blk, ICE_XLT1);
sys/dev/ice/ice_flex_pipe.c
2396
ice_prof_bld_xlt2(enum ice_block blk, struct ice_buf_build *bld,
sys/dev/ice/ice_flex_pipe.c
2409
id = ice_sect_id(blk, ICE_XLT2);
sys/dev/ice/ice_flex_pipe.c
2438
ice_upd_prof_hw(struct ice_hw *hw, enum ice_block blk,
sys/dev/ice/ice_flex_pipe.c
2488
status = ice_prof_bld_es(hw, blk, b, chgs);
sys/dev/ice/ice_flex_pipe.c
2494
status = ice_prof_bld_tcam(hw, blk, b, chgs);
sys/dev/ice/ice_flex_pipe.c
2500
status = ice_prof_bld_xlt1(blk, b, chgs);
sys/dev/ice/ice_flex_pipe.c
2506
status = ice_prof_bld_xlt2(blk, b, chgs);
sys/dev/ice/ice_flex_pipe.c
2545
ice_add_prof(struct ice_hw *hw, enum ice_block blk, u64 id,
sys/dev/ice/ice_flex_pipe.c
2556
ice_acquire_lock(&hw->blk[blk].es.prof_map_lock);
sys/dev/ice/ice_flex_pipe.c
2559
status = ice_find_prof_id(hw, blk, es, &prof_id);
sys/dev/ice/ice_flex_pipe.c
2562
status = ice_alloc_prof_id(hw, blk, &prof_id);
sys/dev/ice/ice_flex_pipe.c
2567
ice_write_es(hw, blk, prof_id, es);
sys/dev/ice/ice_flex_pipe.c
2570
ice_prof_inc_ref(hw, blk, prof_id);
sys/dev/ice/ice_flex_pipe.c
2590
if (ice_ptg_find_ptype(hw, blk, ptype, &ptg))
sys/dev/ice/ice_flex_pipe.c
2604
LIST_ADD(&prof->list, &hw->blk[blk].es.prof_map);
sys/dev/ice/ice_flex_pipe.c
2608
ice_release_lock(&hw->blk[blk].es.prof_map_lock);
sys/dev/ice/ice_flex_pipe.c
2622
ice_search_prof_id(struct ice_hw *hw, enum ice_block blk, u64 id)
sys/dev/ice/ice_flex_pipe.c
2627
LIST_FOR_EACH_ENTRY(map, &hw->blk[blk].es.prof_map, ice_prof_map, list)
sys/dev/ice/ice_flex_pipe.c
2644
ice_set_prof_context(struct ice_hw *hw, enum ice_block blk, u64 id, u64 cntxt)
sys/dev/ice/ice_flex_pipe.c
2649
ice_acquire_lock(&hw->blk[blk].es.prof_map_lock);
sys/dev/ice/ice_flex_pipe.c
2650
entry = ice_search_prof_id(hw, blk, id);
sys/dev/ice/ice_flex_pipe.c
2655
ice_release_lock(&hw->blk[blk].es.prof_map_lock);
sys/dev/ice/ice_flex_pipe.c
2667
ice_get_prof_context(struct ice_hw *hw, enum ice_block blk, u64 id, u64 *cntxt)
sys/dev/ice/ice_flex_pipe.c
2672
ice_acquire_lock(&hw->blk[blk].es.prof_map_lock);
sys/dev/ice/ice_flex_pipe.c
2673
entry = ice_search_prof_id(hw, blk, id);
sys/dev/ice/ice_flex_pipe.c
2678
ice_release_lock(&hw->blk[blk].es.prof_map_lock);
sys/dev/ice/ice_flex_pipe.c
2689
ice_vsig_prof_id_count(struct ice_hw *hw, enum ice_block blk, u16 vsig)
sys/dev/ice/ice_flex_pipe.c
2694
LIST_FOR_EACH_ENTRY(p, &hw->blk[blk].xlt2.vsig_tbl[idx].prop_lst,
sys/dev/ice/ice_flex_pipe.c
2708
ice_rel_tcam_idx(struct ice_hw *hw, enum ice_block blk, u16 idx)
sys/dev/ice/ice_flex_pipe.c
2717
status = ice_tcam_write_entry(hw, blk, idx, 0, 0, 0, 0, 0, vl_msk,
sys/dev/ice/ice_flex_pipe.c
2723
status = ice_free_tcam_ent(hw, blk, idx);
sys/dev/ice/ice_flex_pipe.c
2735
ice_rem_prof_id(struct ice_hw *hw, enum ice_block blk,
sys/dev/ice/ice_flex_pipe.c
2744
status = ice_rel_tcam_idx(hw, blk,
sys/dev/ice/ice_flex_pipe.c
2761
ice_rem_vsig(struct ice_hw *hw, enum ice_block blk, u16 vsig,
sys/dev/ice/ice_flex_pipe.c
2770
&hw->blk[blk].xlt2.vsig_tbl[idx].prop_lst,
sys/dev/ice/ice_flex_pipe.c
2774
status = ice_rem_prof_id(hw, blk, d);
sys/dev/ice/ice_flex_pipe.c
2783
vsi_cur = hw->blk[blk].xlt2.vsig_tbl[idx].first_vsi;
sys/dev/ice/ice_flex_pipe.c
2799
p->vsi = (u16)(vsi_cur - hw->blk[blk].xlt2.vsis);
sys/dev/ice/ice_flex_pipe.c
2806
return ice_vsig_free(hw, blk, vsig);
sys/dev/ice/ice_flex_pipe.c
2818
ice_rem_prof_id_vsig(struct ice_hw *hw, enum ice_block blk, u16 vsig, u64 hdl,
sys/dev/ice/ice_flex_pipe.c
2825
&hw->blk[blk].xlt2.vsig_tbl[idx].prop_lst,
sys/dev/ice/ice_flex_pipe.c
2830
if (ice_vsig_prof_id_count(hw, blk, vsig) == 1)
sys/dev/ice/ice_flex_pipe.c
2832
return ice_rem_vsig(hw, blk, vsig, chg);
sys/dev/ice/ice_flex_pipe.c
2834
status = ice_rem_prof_id(hw, blk, p);
sys/dev/ice/ice_flex_pipe.c
2852
ice_rem_flow_all(struct ice_hw *hw, enum ice_block blk, u64 id)
sys/dev/ice/ice_flex_pipe.c
2862
if (hw->blk[blk].xlt2.vsig_tbl[i].in_use) {
sys/dev/ice/ice_flex_pipe.c
2863
if (ice_has_prof_vsig(hw, blk, i, id)) {
sys/dev/ice/ice_flex_pipe.c
2864
status = ice_rem_prof_id_vsig(hw, blk, i, id,
sys/dev/ice/ice_flex_pipe.c
2871
status = ice_upd_prof_hw(hw, blk, &chg);
sys/dev/ice/ice_flex_pipe.c
2892
int ice_rem_prof(struct ice_hw *hw, enum ice_block blk, u64 id)
sys/dev/ice/ice_flex_pipe.c
2897
ice_acquire_lock(&hw->blk[blk].es.prof_map_lock);
sys/dev/ice/ice_flex_pipe.c
2899
pmap = ice_search_prof_id(hw, blk, id);
sys/dev/ice/ice_flex_pipe.c
2906
status = ice_rem_flow_all(hw, blk, pmap->profile_cookie);
sys/dev/ice/ice_flex_pipe.c
2911
ice_prof_dec_ref(hw, blk, pmap->prof_id);
sys/dev/ice/ice_flex_pipe.c
2917
ice_release_lock(&hw->blk[blk].es.prof_map_lock);
sys/dev/ice/ice_flex_pipe.c
2929
ice_get_prof(struct ice_hw *hw, enum ice_block blk, u64 hdl,
sys/dev/ice/ice_flex_pipe.c
2937
ice_acquire_lock(&hw->blk[blk].es.prof_map_lock);
sys/dev/ice/ice_flex_pipe.c
2939
map = ice_search_prof_id(hw, blk, hdl);
sys/dev/ice/ice_flex_pipe.c
2946
if (!hw->blk[blk].es.written[map->prof_id]) {
sys/dev/ice/ice_flex_pipe.c
2962
hw->blk[blk].es.written[map->prof_id] = true;
sys/dev/ice/ice_flex_pipe.c
2968
ice_release_lock(&hw->blk[blk].es.prof_map_lock);
sys/dev/ice/ice_flex_pipe.c
2983
ice_get_profs_vsig(struct ice_hw *hw, enum ice_block blk, u16 vsig,
sys/dev/ice/ice_flex_pipe.c
2989
LIST_FOR_EACH_ENTRY(ent1, &hw->blk[blk].xlt2.vsig_tbl[idx].prop_lst,
sys/dev/ice/ice_flex_pipe.c
3021
ice_add_prof_to_lst(struct ice_hw *hw, enum ice_block blk,
sys/dev/ice/ice_flex_pipe.c
3029
ice_acquire_lock(&hw->blk[blk].es.prof_map_lock);
sys/dev/ice/ice_flex_pipe.c
3030
map = ice_search_prof_id(hw, blk, hdl);
sys/dev/ice/ice_flex_pipe.c
3055
ice_release_lock(&hw->blk[blk].es.prof_map_lock);
sys/dev/ice/ice_flex_pipe.c
3068
ice_move_vsi(struct ice_hw *hw, enum ice_block blk, u16 vsi, u16 vsig,
sys/dev/ice/ice_flex_pipe.c
3079
status = ice_vsig_find_vsi(hw, blk, vsi, &orig_vsig);
sys/dev/ice/ice_flex_pipe.c
3081
status = ice_vsig_add_mv_vsi(hw, blk, vsi, vsig);
sys/dev/ice/ice_flex_pipe.c
3128
ice_prof_tcam_ena_dis(struct ice_hw *hw, enum ice_block blk, bool enable,
sys/dev/ice/ice_flex_pipe.c
3141
status = ice_rel_tcam_idx(hw, blk, tcam->tcam_idx);
sys/dev/ice/ice_flex_pipe.c
3154
status = ice_alloc_tcam_ent(hw, blk, true, &tcam->tcam_idx);
sys/dev/ice/ice_flex_pipe.c
3163
status = ice_tcam_write_entry(hw, blk, tcam->tcam_idx, tcam->prof_id,
sys/dev/ice/ice_flex_pipe.c
3196
ice_adj_prof_priorities(struct ice_hw *hw, enum ice_block blk, u16 vsig,
sys/dev/ice/ice_flex_pipe.c
3216
LIST_FOR_EACH_ENTRY(t, &hw->blk[blk].xlt2.vsig_tbl[idx].prop_lst,
sys/dev/ice/ice_flex_pipe.c
3233
status = ice_prof_tcam_ena_dis(hw, blk, false,
sys/dev/ice/ice_flex_pipe.c
3243
status = ice_prof_tcam_ena_dis(hw, blk, true,
sys/dev/ice/ice_flex_pipe.c
3269
ice_add_prof_id_vsig(struct ice_hw *hw, enum ice_block blk, u16 vsig, u64 hdl,
sys/dev/ice/ice_flex_pipe.c
3283
if (ice_has_prof_vsig(hw, blk, vsig, hdl))
sys/dev/ice/ice_flex_pipe.c
3291
ice_acquire_lock(&hw->blk[blk].es.prof_map_lock);
sys/dev/ice/ice_flex_pipe.c
3293
map = ice_search_prof_id(hw, blk, hdl);
sys/dev/ice/ice_flex_pipe.c
3315
status = ice_alloc_tcam_ent(hw, blk, true, &tcam_idx);
sys/dev/ice/ice_flex_pipe.c
3334
status = ice_tcam_write_entry(hw, blk, t->tcam[i].tcam_idx,
sys/dev/ice/ice_flex_pipe.c
3351
&hw->blk[blk].xlt2.vsig_tbl[vsig_idx].prop_lst);
sys/dev/ice/ice_flex_pipe.c
3354
&hw->blk[blk].xlt2.vsig_tbl[vsig_idx].prop_lst);
sys/dev/ice/ice_flex_pipe.c
3356
ice_release_lock(&hw->blk[blk].es.prof_map_lock);
sys/dev/ice/ice_flex_pipe.c
3360
ice_release_lock(&hw->blk[blk].es.prof_map_lock);
sys/dev/ice/ice_flex_pipe.c
3375
ice_create_prof_id_vsig(struct ice_hw *hw, enum ice_block blk, u16 vsi, u64 hdl,
sys/dev/ice/ice_flex_pipe.c
3386
new_vsig = ice_vsig_alloc(hw, blk);
sys/dev/ice/ice_flex_pipe.c
3392
status = ice_move_vsi(hw, blk, vsi, new_vsig, chg);
sys/dev/ice/ice_flex_pipe.c
3396
status = ice_add_prof_id_vsig(hw, blk, new_vsig, hdl, false, chg);
sys/dev/ice/ice_flex_pipe.c
3425
ice_create_vsig_from_lst(struct ice_hw *hw, enum ice_block blk, u16 vsi,
sys/dev/ice/ice_flex_pipe.c
3433
vsig = ice_vsig_alloc(hw, blk);
sys/dev/ice/ice_flex_pipe.c
3437
status = ice_move_vsi(hw, blk, vsi, vsig, chg);
sys/dev/ice/ice_flex_pipe.c
3443
status = ice_add_prof_id_vsig(hw, blk, vsig, t->profile_cookie,
sys/dev/ice/ice_flex_pipe.c
3462
ice_find_prof_vsig(struct ice_hw *hw, enum ice_block blk, u64 hdl, u16 *vsig)
sys/dev/ice/ice_flex_pipe.c
3477
status = ice_find_dup_props_vsig(hw, blk, &lst, vsig);
sys/dev/ice/ice_flex_pipe.c
3500
ice_add_vsi_flow(struct ice_hw *hw, enum ice_block blk, u16 vsi, u16 vsig)
sys/dev/ice/ice_flex_pipe.c
3513
status = ice_move_vsi(hw, blk, vsi, vsig, &chg);
sys/dev/ice/ice_flex_pipe.c
3516
status = ice_upd_prof_hw(hw, blk, &chg);
sys/dev/ice/ice_flex_pipe.c
3538
ice_add_prof_id_flow(struct ice_hw *hw, enum ice_block blk, u16 vsi, u64 hdl)
sys/dev/ice/ice_flex_pipe.c
3551
status = ice_get_prof(hw, blk, hdl, &chg);
sys/dev/ice/ice_flex_pipe.c
3556
status = ice_vsig_find_vsi(hw, blk, vsi, &vsig);
sys/dev/ice/ice_flex_pipe.c
3569
if (ice_has_prof_vsig(hw, blk, vsig, hdl)) {
sys/dev/ice/ice_flex_pipe.c
3575
status = ice_vsig_get_ref(hw, blk, vsig, &ref);
sys/dev/ice/ice_flex_pipe.c
3583
status = ice_get_profs_vsig(hw, blk, vsig, &union_lst);
sys/dev/ice/ice_flex_pipe.c
3587
status = ice_add_prof_to_lst(hw, blk, &union_lst, hdl);
sys/dev/ice/ice_flex_pipe.c
3592
status = ice_find_dup_props_vsig(hw, blk, &union_lst, &vsig);
sys/dev/ice/ice_flex_pipe.c
3595
status = ice_move_vsi(hw, blk, vsi, vsig, &chg);
sys/dev/ice/ice_flex_pipe.c
3603
status = ice_rem_vsig(hw, blk, or_vsig, &chg);
sys/dev/ice/ice_flex_pipe.c
3613
status = ice_add_prof_id_vsig(hw, blk, vsig, hdl, false,
sys/dev/ice/ice_flex_pipe.c
3619
status = ice_adj_prof_priorities(hw, blk, vsig, &chg);
sys/dev/ice/ice_flex_pipe.c
3624
status = ice_create_vsig_from_lst(hw, blk, vsi,
sys/dev/ice/ice_flex_pipe.c
3631
status = ice_adj_prof_priorities(hw, blk, vsig, &chg);
sys/dev/ice/ice_flex_pipe.c
3638
if (ice_find_prof_vsig(hw, blk, hdl, &vsig)) {
sys/dev/ice/ice_flex_pipe.c
3641
status = ice_move_vsi(hw, blk, vsi, vsig, &chg);
sys/dev/ice/ice_flex_pipe.c
3647
status = ice_create_prof_id_vsig(hw, blk, vsi, hdl,
sys/dev/ice/ice_flex_pipe.c
3656
status = ice_upd_prof_hw(hw, blk, &chg);
sys/dev/ice/ice_flex_pipe.c
3685
ice_add_flow(struct ice_hw *hw, enum ice_block blk, u16 vsi[], u8 count,
sys/dev/ice/ice_flex_pipe.c
3693
status = ice_add_prof_id_flow(hw, blk, vsi[i], id);
sys/dev/ice/ice_flex_pipe.c
3734
ice_rem_prof_id_flow(struct ice_hw *hw, enum ice_block blk, u16 vsi, u64 hdl)
sys/dev/ice/ice_flex_pipe.c
3746
status = ice_vsig_find_vsi(hw, blk, vsi, &vsig);
sys/dev/ice/ice_flex_pipe.c
3753
last_profile = ice_vsig_prof_id_count(hw, blk, vsig) == 1;
sys/dev/ice/ice_flex_pipe.c
3754
status = ice_vsig_get_ref(hw, blk, vsig, &ref);
sys/dev/ice/ice_flex_pipe.c
3770
status = ice_rem_vsig(hw, blk, vsig, &chg);
sys/dev/ice/ice_flex_pipe.c
3774
status = ice_rem_prof_id_vsig(hw, blk, vsig,
sys/dev/ice/ice_flex_pipe.c
3780
status = ice_adj_prof_priorities(hw, blk, vsig,
sys/dev/ice/ice_flex_pipe.c
3788
status = ice_get_profs_vsig(hw, blk, vsig, &copy);
sys/dev/ice/ice_flex_pipe.c
3798
status = ice_move_vsi(hw, blk, vsi,
sys/dev/ice/ice_flex_pipe.c
3803
} else if (!ice_find_dup_props_vsig(hw, blk, &copy,
sys/dev/ice/ice_flex_pipe.c
3812
status = ice_move_vsi(hw, blk, vsi, vsig, &chg);
sys/dev/ice/ice_flex_pipe.c
3820
status = ice_create_vsig_from_lst(hw, blk, vsi,
sys/dev/ice/ice_flex_pipe.c
3827
status = ice_adj_prof_priorities(hw, blk, vsig,
sys/dev/ice/ice_flex_pipe.c
3839
status = ice_upd_prof_hw(hw, blk, &chg);
sys/dev/ice/ice_flex_pipe.c
3868
ice_rem_flow(struct ice_hw *hw, enum ice_block blk, u16 vsi[], u8 count,
sys/dev/ice/ice_flex_pipe.c
3876
status = ice_rem_prof_id_flow(hw, blk, vsi[i], id);
sys/dev/ice/ice_flex_pipe.c
703
ice_find_prot_off(struct ice_hw *hw, enum ice_block blk, u8 prof, u16 fv_idx,
sys/dev/ice/ice_flex_pipe.c
708
if (prof >= hw->blk[blk].es.count)
sys/dev/ice/ice_flex_pipe.c
711
if (fv_idx >= hw->blk[blk].es.fvw)
sys/dev/ice/ice_flex_pipe.c
714
fv_ext = hw->blk[blk].es.t + (prof * hw->blk[blk].es.fvw);
sys/dev/ice/ice_flex_pipe.c
732
int ice_ptg_update_xlt1(struct ice_hw *hw, enum ice_block blk)
sys/dev/ice/ice_flex_pipe.c
739
bld = ice_pkg_buf_alloc_single_section(hw, ice_sect_id(blk, ICE_XLT1),
sys/dev/ice/ice_flex_pipe.c
749
sect->value[index] = hw->blk[blk].xlt1.ptypes[index].ptg;
sys/dev/ice/ice_flex_pipe.c
770
ice_ptg_find_ptype(struct ice_hw *hw, enum ice_block blk, u16 ptype, u8 *ptg)
sys/dev/ice/ice_flex_pipe.c
775
*ptg = hw->blk[blk].xlt1.ptypes[ptype].ptg;
sys/dev/ice/ice_flex_pipe.c
788
static void ice_ptg_alloc_val(struct ice_hw *hw, enum ice_block blk, u8 ptg)
sys/dev/ice/ice_flex_pipe.c
790
hw->blk[blk].xlt1.ptg_tbl[ptg].in_use = true;
sys/dev/ice/ice_flex_pipe.c
802
void ice_ptg_free(struct ice_hw *hw, enum ice_block blk, u8 ptg)
sys/dev/ice/ice_flex_pipe.c
806
hw->blk[blk].xlt1.ptg_tbl[ptg].in_use = false;
sys/dev/ice/ice_flex_pipe.c
807
p = hw->blk[blk].xlt1.ptg_tbl[ptg].first_ptype;
sys/dev/ice/ice_flex_pipe.c
815
hw->blk[blk].xlt1.ptg_tbl[ptg].first_ptype = NULL;
sys/dev/ice/ice_flex_pipe.c
829
ice_ptg_remove_ptype(struct ice_hw *hw, enum ice_block blk, u16 ptype, u8 ptg)
sys/dev/ice/ice_flex_pipe.c
837
if (!hw->blk[blk].xlt1.ptg_tbl[ptg].in_use)
sys/dev/ice/ice_flex_pipe.c
841
if (!hw->blk[blk].xlt1.ptg_tbl[ptg].first_ptype)
sys/dev/ice/ice_flex_pipe.c
845
p = hw->blk[blk].xlt1.ptg_tbl[ptg].first_ptype;
sys/dev/ice/ice_flex_pipe.c
846
ch = &hw->blk[blk].xlt1.ptg_tbl[ptg].first_ptype;
sys/dev/ice/ice_flex_pipe.c
848
if (ptype == (p - hw->blk[blk].xlt1.ptypes)) {
sys/dev/ice/ice_flex_pipe.c
857
hw->blk[blk].xlt1.ptypes[ptype].ptg = ICE_DEFAULT_PTG;
sys/dev/ice/ice_flex_pipe.c
858
hw->blk[blk].xlt1.ptypes[ptype].next_ptype = NULL;
sys/dev/ice/ice_flex_pipe.c
876
ice_ptg_add_mv_ptype(struct ice_hw *hw, enum ice_block blk, u16 ptype, u8 ptg)
sys/dev/ice/ice_flex_pipe.c
884
if (!hw->blk[blk].xlt1.ptg_tbl[ptg].in_use && ptg != ICE_DEFAULT_PTG)
sys/dev/ice/ice_flex_pipe.c
887
status = ice_ptg_find_ptype(hw, blk, ptype, &original_ptg);
sys/dev/ice/ice_flex_pipe.c
897
ice_ptg_remove_ptype(hw, blk, ptype, original_ptg);
sys/dev/ice/ice_flex_pipe.c
904
hw->blk[blk].xlt1.ptypes[ptype].next_ptype =
sys/dev/ice/ice_flex_pipe.c
905
hw->blk[blk].xlt1.ptg_tbl[ptg].first_ptype;
sys/dev/ice/ice_flex_pipe.c
906
hw->blk[blk].xlt1.ptg_tbl[ptg].first_ptype =
sys/dev/ice/ice_flex_pipe.c
907
&hw->blk[blk].xlt1.ptypes[ptype];
sys/dev/ice/ice_flex_pipe.c
909
hw->blk[blk].xlt1.ptypes[ptype].ptg = ptg;
sys/dev/ice/ice_flex_pipe.c
910
hw->blk[blk].xlt1.t[ptype] = ptg;
sys/dev/ice/ice_flex_pipe.h
38
ice_find_prot_off(struct ice_hw *hw, enum ice_block blk, u8 prof, u16 fv_idx,
sys/dev/ice/ice_flex_pipe.h
63
int ice_ptg_update_xlt1(struct ice_hw *hw, enum ice_block blk);
sys/dev/ice/ice_flex_pipe.h
64
void ice_ptg_free(struct ice_hw *hw, enum ice_block blk, u8 ptg);
sys/dev/ice/ice_flex_pipe.h
67
int ice_vsig_update_xlt2(struct ice_hw *hw, enum ice_block blk);
sys/dev/ice/ice_flex_pipe.h
69
ice_vsig_find_vsi(struct ice_hw *hw, enum ice_block blk, u16 vsi, u16 *vsig);
sys/dev/ice/ice_flex_pipe.h
71
ice_add_prof(struct ice_hw *hw, enum ice_block blk, u64 id,
sys/dev/ice/ice_flex_pipe.h
74
ice_search_prof_id(struct ice_hw *hw, enum ice_block blk, u64 id);
sys/dev/ice/ice_flex_pipe.h
76
ice_add_vsi_flow(struct ice_hw *hw, enum ice_block blk, u16 vsi, u16 vsig);
sys/dev/ice/ice_flex_pipe.h
78
ice_add_prof_id_flow(struct ice_hw *hw, enum ice_block blk, u16 vsi, u64 hdl);
sys/dev/ice/ice_flex_pipe.h
80
ice_rem_prof_id_flow(struct ice_hw *hw, enum ice_block blk, u16 vsi, u64 hdl);
sys/dev/ice/ice_flex_pipe.h
82
ice_set_prof_context(struct ice_hw *hw, enum ice_block blk, u64 id, u64 cntxt);
sys/dev/ice/ice_flex_pipe.h
84
ice_get_prof_context(struct ice_hw *hw, enum ice_block blk, u64 id, u64 *cntxt);
sys/dev/ice/ice_flex_pipe.h
90
ice_add_flow(struct ice_hw *hw, enum ice_block blk, u16 vsi[], u8 count,
sys/dev/ice/ice_flex_pipe.h
93
ice_rem_flow(struct ice_hw *hw, enum ice_block blk, u16 vsi[], u8 count,
sys/dev/ice/ice_flex_pipe.h
96
ice_rem_prof(struct ice_hw *hw, enum ice_block blk, u64 id);
sys/dev/ice/ice_flow.c
1006
ice_flow_assoc_vsig_vsi(struct ice_hw *hw, enum ice_block blk, u16 vsi_handle,
sys/dev/ice/ice_flow.c
1011
if (!ice_is_vsi_valid(hw, vsi_handle) || blk >= ICE_BLK_COUNT)
sys/dev/ice/ice_flow.c
1014
ice_acquire_lock(&hw->fl_profs_locks[blk]);
sys/dev/ice/ice_flow.c
1015
status = ice_add_vsi_flow(hw, blk, ice_get_hw_vsi_num(hw, vsi_handle),
sys/dev/ice/ice_flow.c
1017
ice_release_lock(&hw->fl_profs_locks[blk]);
sys/dev/ice/ice_flow.c
1033
ice_flow_assoc_prof(struct ice_hw *hw, enum ice_block blk,
sys/dev/ice/ice_flow.c
1039
status = ice_add_prof_id_flow(hw, blk,
sys/dev/ice/ice_flow.c
1064
ice_flow_disassoc_prof(struct ice_hw *hw, enum ice_block blk,
sys/dev/ice/ice_flow.c
1070
status = ice_rem_prof_id_flow(hw, blk,
sys/dev/ice/ice_flow.c
1097
ice_flow_add_prof(struct ice_hw *hw, enum ice_block blk, enum ice_flow_dir dir,
sys/dev/ice/ice_flow.c
1117
ice_acquire_lock(&hw->fl_profs_locks[blk]);
sys/dev/ice/ice_flow.c
1119
status = ice_flow_add_prof_sync(hw, blk, dir, prof_id, segs, segs_cnt,
sys/dev/ice/ice_flow.c
1122
LIST_ADD(&(*prof)->l_entry, &hw->fl_profs[blk]);
sys/dev/ice/ice_flow.c
1124
ice_release_lock(&hw->fl_profs_locks[blk]);
sys/dev/ice/ice_flow.c
1136
ice_flow_rem_prof(struct ice_hw *hw, enum ice_block blk, u64 prof_id)
sys/dev/ice/ice_flow.c
1141
ice_acquire_lock(&hw->fl_profs_locks[blk]);
sys/dev/ice/ice_flow.c
1143
prof = ice_flow_find_prof_id(hw, blk, prof_id);
sys/dev/ice/ice_flow.c
1150
status = ice_flow_rem_prof_sync(hw, blk, prof);
sys/dev/ice/ice_flow.c
1153
ice_release_lock(&hw->fl_profs_locks[blk]);
sys/dev/ice/ice_flow.c
1364
const enum ice_block blk = ICE_BLK_RSS;
sys/dev/ice/ice_flow.c
1372
if (LIST_EMPTY(&hw->fl_profs[blk]))
sys/dev/ice/ice_flow.c
1376
LIST_FOR_EACH_ENTRY_SAFE(p, t, &hw->fl_profs[blk], ice_flow_prof,
sys/dev/ice/ice_flow.c
1381
ret = ice_vsig_find_vsi(hw, blk,
sys/dev/ice/ice_flow.c
1388
status = ice_flow_disassoc_prof(hw, blk, p, vsi_handle);
sys/dev/ice/ice_flow.c
1393
status = ice_flow_rem_prof(hw, blk, p->id);
sys/dev/ice/ice_flow.c
1551
const enum ice_block blk = ICE_BLK_RSS;
sys/dev/ice/ice_flow.c
1578
prof = ice_flow_find_prof_conds(hw, blk, ICE_FLOW_RX, segs, segs_cnt,
sys/dev/ice/ice_flow.c
1590
prof = ice_flow_find_prof_conds(hw, blk, ICE_FLOW_RX, segs, segs_cnt,
sys/dev/ice/ice_flow.c
1593
status = ice_flow_disassoc_prof(hw, blk, prof, vsi_handle);
sys/dev/ice/ice_flow.c
1601
status = ice_flow_rem_prof(hw, blk, prof->id);
sys/dev/ice/ice_flow.c
1610
prof = ice_flow_find_prof_conds(hw, blk, ICE_FLOW_RX, segs, segs_cnt,
sys/dev/ice/ice_flow.c
1614
status = ice_flow_assoc_prof(hw, blk, prof, vsi_handle);
sys/dev/ice/ice_flow.c
1623
status = ice_flow_add_prof(hw, blk, ICE_FLOW_RX,
sys/dev/ice/ice_flow.c
1631
status = ice_flow_assoc_prof(hw, blk, prof, vsi_handle);
sys/dev/ice/ice_flow.c
1636
ice_flow_rem_prof(hw, blk, prof->id);
sys/dev/ice/ice_flow.c
1701
const enum ice_block blk = ICE_BLK_RSS;
sys/dev/ice/ice_flow.c
1720
prof = ice_flow_find_prof_conds(hw, blk, ICE_FLOW_RX, segs, segs_cnt,
sys/dev/ice/ice_flow.c
1728
status = ice_flow_disassoc_prof(hw, blk, prof, vsi_handle);
sys/dev/ice/ice_flow.c
1738
status = ice_flow_rem_prof(hw, blk, prof->id);
sys/dev/ice/ice_flow.c
393
enum ice_block blk;
sys/dev/ice/ice_flow.c
565
u8 fv_words = (u8)hw->blk[params->blk].es.fvw;
sys/dev/ice/ice_flow.c
693
if (hw->blk[params->blk].es.reverse)
sys/dev/ice/ice_flow.c
759
switch (params->blk) {
sys/dev/ice/ice_flow.c
785
ice_flow_find_prof_conds(struct ice_hw *hw, enum ice_block blk,
sys/dev/ice/ice_flow.c
791
ice_acquire_lock(&hw->fl_profs_locks[blk]);
sys/dev/ice/ice_flow.c
792
LIST_FOR_EACH_ENTRY(p, &hw->fl_profs[blk], ice_flow_prof, l_entry)
sys/dev/ice/ice_flow.c
821
ice_release_lock(&hw->fl_profs_locks[blk]);
sys/dev/ice/ice_flow.c
835
ice_flow_find_prof(struct ice_hw *hw, enum ice_block blk, enum ice_flow_dir dir,
sys/dev/ice/ice_flow.c
840
p = ice_flow_find_prof_conds(hw, blk, dir, segs, segs_cnt,
sys/dev/ice/ice_flow.c
853
ice_flow_find_prof_id(struct ice_hw *hw, enum ice_block blk, u64 prof_id)
sys/dev/ice/ice_flow.c
857
LIST_FOR_EACH_ENTRY(p, &hw->fl_profs[blk], ice_flow_prof, l_entry)
sys/dev/ice/ice_flow.c
872
ice_flow_get_hw_prof(struct ice_hw *hw, enum ice_block blk, u64 prof_id,
sys/dev/ice/ice_flow.c
878
ice_acquire_lock(&hw->blk[blk].es.prof_map_lock);
sys/dev/ice/ice_flow.c
879
map = ice_search_prof_id(hw, blk, prof_id);
sys/dev/ice/ice_flow.c
884
ice_release_lock(&hw->blk[blk].es.prof_map_lock);
sys/dev/ice/ice_flow.c
903
ice_flow_add_prof_sync(struct ice_hw *hw, enum ice_block blk,
sys/dev/ice/ice_flow.c
933
params->blk = blk;
sys/dev/ice/ice_flow.c
952
status = ice_add_prof(hw, blk, prof_id, params->ptypes, params->es);
sys/dev/ice/ice_flow.c
979
ice_flow_rem_prof_sync(struct ice_hw *hw, enum ice_block blk,
sys/dev/ice/ice_flow.c
985
status = ice_rem_prof(hw, blk, prof->id);
sys/dev/ice/ice_flow.h
331
ice_flow_find_prof(struct ice_hw *hw, enum ice_block blk, enum ice_flow_dir dir,
sys/dev/ice/ice_flow.h
334
ice_flow_assoc_vsig_vsi(struct ice_hw *hw, enum ice_block blk, u16 vsi_handle,
sys/dev/ice/ice_flow.h
337
ice_flow_get_hw_prof(struct ice_hw *hw, enum ice_block blk, u64 prof_id,
sys/dev/ice/ice_type.h
1193
struct ice_blk_info blk[ICE_BLK_COUNT];
sys/dev/mrsas/mrsas_fp.c
1756
u_int64_t blk;
sys/dev/mrsas/mrsas_fp.c
1768
blk = mega_div64_32((row - quad->logStart), quad->diff);
sys/dev/mrsas/mrsas_fp.c
1769
blk = (blk + quad->offsetInSpan) << raid->stripeShift;
sys/dev/mrsas/mrsas_fp.c
1770
*span_blk = blk;
sys/dev/mrsas/mrsas_fp.c
692
u_int64_t blk;
sys/dev/mrsas/mrsas_fp.c
694
blk = mega_div64_32
sys/dev/mrsas/mrsas_fp.c
697
blk = (blk + le64toh(quad->offsetInSpan))
sys/dev/mrsas/mrsas_fp.c
699
*span_blk = blk;
sys/dev/sfxge/common/ef10_nic.c
914
uint32_t buf, blk;
sys/dev/sfxge/common/ef10_nic.c
940
for (blk = 0; blk < blk_per_buf; blk++) {
sys/dev/sfxge/common/ef10_nic.c
941
if ((*map & (1u << blk)) == 0) {
sys/dev/sfxge/common/ef10_nic.c
942
*map |= (1u << blk);
sys/dev/sfxge/common/ef10_nic.c
953
*blknump = blk;
sys/dev/sfxge/common/ef10_nic.c
955
*offsetp = blk * (*sizep);
sys/dev/sound/pci/emu10k1.c
1343
struct emu_memblk *blk;
sys/dev/sound/pci/emu10k1.c
1362
blk = malloc(sizeof(*blk), M_DEVBUF, M_NOWAIT);
sys/dev/sound/pci/emu10k1.c
1363
if (blk == NULL)
sys/dev/sound/pci/emu10k1.c
1365
buf = emu_malloc(sc, sz, &blk->buf_addr, &blk->buf_map);
sys/dev/sound/pci/emu10k1.c
1366
*addr = blk->buf_addr;
sys/dev/sound/pci/emu10k1.c
1368
free(blk, M_DEVBUF);
sys/dev/sound/pci/emu10k1.c
1371
blk->buf = buf;
sys/dev/sound/pci/emu10k1.c
1372
blk->pte_start = start;
sys/dev/sound/pci/emu10k1.c
1373
blk->pte_size = blksz;
sys/dev/sound/pci/emu10k1.c
1375
printf("buf %p, pte_start %d, pte_size %d\n", blk->buf,
sys/dev/sound/pci/emu10k1.c
1376
blk->pte_start, blk->pte_size);
sys/dev/sound/pci/emu10k1.c
1381
tmp = (uint32_t)(blk->buf_addr + ofs);
sys/dev/sound/pci/emu10k1.c
1389
SLIST_INSERT_HEAD(&mem->blocks, blk, link);
sys/dev/sound/pci/emu10k1.c
1398
struct emu_memblk *blk, *i;
sys/dev/sound/pci/emu10k1.c
1400
blk = NULL;
sys/dev/sound/pci/emu10k1.c
1403
blk = i;
sys/dev/sound/pci/emu10k1.c
1405
if (blk == NULL)
sys/dev/sound/pci/emu10k1.c
1407
SLIST_REMOVE(&mem->blocks, blk, emu_memblk, link);
sys/dev/sound/pci/emu10k1.c
1408
emu_free(sc, buf, blk->buf_map);
sys/dev/sound/pci/emu10k1.c
1410
for (idx = blk->pte_start; idx < blk->pte_start + blk->pte_size; idx++) {
sys/dev/sound/pci/emu10k1.c
1414
free(blk, M_DEVBUF);
sys/dev/sound/pci/emu10k1.c
1422
struct emu_memblk *blk, *i;
sys/dev/sound/pci/emu10k1.c
1424
blk = NULL;
sys/dev/sound/pci/emu10k1.c
1427
blk = i;
sys/dev/sound/pci/emu10k1.c
1429
if (blk == NULL)
sys/dev/sound/pci/emu10k1.c
1431
return blk->pte_start;
sys/dev/sound/pci/emu10kx.c
1085
struct emu_memblk *blk;
sys/dev/sound/pci/emu10kx.c
1112
blk = malloc(sizeof(*blk), M_DEVBUF, M_NOWAIT);
sys/dev/sound/pci/emu10kx.c
1113
if (blk == NULL) {
sys/dev/sound/pci/emu10kx.c
1118
bzero(blk, sizeof(*blk));
sys/dev/sound/pci/emu10kx.c
1119
membuf = emu_malloc(mem, sz, &blk->buf_addr, &blk->buf_map);
sys/dev/sound/pci/emu10kx.c
1120
*addr = blk->buf_addr;
sys/dev/sound/pci/emu10kx.c
1124
free(blk, M_DEVBUF);
sys/dev/sound/pci/emu10kx.c
1127
blk->buf = membuf;
sys/dev/sound/pci/emu10kx.c
1128
blk->pte_start = start;
sys/dev/sound/pci/emu10kx.c
1129
blk->pte_size = blksz;
sys/dev/sound/pci/emu10kx.c
1130
strncpy(blk->owner, owner, 15);
sys/dev/sound/pci/emu10kx.c
1131
blk->owner[15] = '\0';
sys/dev/sound/pci/emu10kx.c
1135
tmp = (uint32_t) (blk->buf_addr + ofs);
sys/dev/sound/pci/emu10kx.c
1139
SLIST_INSERT_HEAD(&mem->blocks, blk, link);
sys/dev/sound/pci/emu10kx.c
1147
struct emu_memblk *blk, *i;
sys/dev/sound/pci/emu10kx.c
1149
blk = NULL;
sys/dev/sound/pci/emu10kx.c
1152
blk = i;
sys/dev/sound/pci/emu10kx.c
1154
if (blk == NULL)
sys/dev/sound/pci/emu10kx.c
1156
SLIST_REMOVE(&mem->blocks, blk, emu_memblk, link);
sys/dev/sound/pci/emu10kx.c
1157
emu_free(mem, membuf, blk->buf_map);
sys/dev/sound/pci/emu10kx.c
1159
for (idx = blk->pte_start; idx < blk->pte_start + blk->pte_size; idx++) {
sys/dev/sound/pci/emu10kx.c
1163
free(blk, M_DEVBUF);
sys/dev/sound/pci/emu10kx.c
1170
struct emu_memblk *blk, *i;
sys/dev/sound/pci/emu10kx.c
1172
blk = NULL;
sys/dev/sound/pci/emu10kx.c
1175
blk = i;
sys/dev/sound/pci/emu10kx.c
1177
if (blk == NULL)
sys/dev/sound/pci/emu10kx.c
1179
return (blk->pte_start);
sys/dev/sound/pci/emu10kx.c
2888
struct emu_memblk *blk;
sys/dev/sound/pci/emu10kx.c
2924
SLIST_FOREACH(blk, &sc->mem.blocks, link)
sys/dev/sound/pci/emu10kx.c
2925
if (blk != NULL)
sys/dev/sound/pci/emu10kx.c
2926
device_printf(sc->dev, "lost %d for %s\n", blk->pte_size, blk->owner);
sys/dev/sound/pci/envy24.c
1206
uint16_t blk;
sys/dev/sound/pci/envy24.c
1212
blk = sc->blk[0];
sys/dev/sound/pci/envy24.c
1217
blk = sc->blk[1];
sys/dev/sound/pci/envy24.c
1222
cnt = blk - 1;
sys/dev/sound/pci/envy24.c
1224
device_printf(sc->dev, "envy24_updintr():blk = %d, cnt = %d\n", blk, cnt);
sys/dev/sound/pci/envy24.c
1597
ch->blk = 10240;
sys/dev/sound/pci/envy24.c
164
uint16_t blk[2]; /* transfer check blocksize(dword) */
sys/dev/sound/pci/envy24.c
1655
ch->blk *= ch->unit / emltab[i].unit;
sys/dev/sound/pci/envy24.c
1657
ch->blk /= emltab[i].unit / ch->unit;
sys/dev/sound/pci/envy24.c
1664
bsize = ch->blk * 4 / ENVY24_PLAY_BUFUNIT;
sys/dev/sound/pci/envy24.c
1666
bsize = ch->blk * 4 / ENVY24_REC_BUFUNIT;
sys/dev/sound/pci/envy24.c
1732
ch->blk = prev / ch->unit;
sys/dev/sound/pci/envy24.c
1734
ch->blk *= ENVY24_PLAY_BUFUNIT / 4;
sys/dev/sound/pci/envy24.c
1736
ch->blk *= ENVY24_REC_BUFUNIT / 4;
sys/dev/sound/pci/envy24.c
1740
bsize = ch->blk * 4 / ENVY24_PLAY_BUFUNIT;
sys/dev/sound/pci/envy24.c
1742
bsize = ch->blk * 4 / ENVY24_REC_BUFUNIT;
sys/dev/sound/pci/envy24.c
1795
sc->blk[slot] = ch->blk;
sys/dev/sound/pci/envy24.c
1799
ch->offset = ((ptr / ch->blk + 1) * ch->blk %
sys/dev/sound/pci/envy24.c
1801
if (ch->blk < sc->blk[slot])
sys/dev/sound/pci/envy24.c
1802
sc->blk[slot] = ch->blk;
sys/dev/sound/pci/envy24.c
1847
else if (ch->blk == sc->blk[slot]) {
sys/dev/sound/pci/envy24.c
1848
sc->blk[slot] = ENVY24_SAMPLE_NUM / 2;
sys/dev/sound/pci/envy24.c
1852
sc->chan[i].blk < sc->blk[slot])
sys/dev/sound/pci/envy24.c
1853
sc->blk[slot] = sc->chan[i].blk;
sys/dev/sound/pci/envy24.c
1855
if (ch->blk != sc->blk[slot])
sys/dev/sound/pci/envy24.c
2074
ptr -= ptr % sc->blk[0];
sys/dev/sound/pci/envy24.c
2083
device_printf(sc->dev, "envy24_intr(): chan[%d].blk = %d\n", i, ch->blk);
sys/dev/sound/pci/envy24.c
2085
if (ch->run && ch->blk <= feed) {
sys/dev/sound/pci/envy24.c
2100
ptr -= ptr % sc->blk[1];
sys/dev/sound/pci/envy24.c
2104
if (ch->run && ch->blk <= feed) {
sys/dev/sound/pci/envy24.c
2237
sc->blk[0] = sc->blk[1] = 0;
sys/dev/sound/pci/envy24.c
82
uint32_t blk; /* hw block size(dword) */
sys/dev/sound/pci/envy24ht.c
1160
uint16_t blk;
sys/dev/sound/pci/envy24ht.c
1166
blk = sc->blk[0];
sys/dev/sound/pci/envy24ht.c
1171
blk = sc->blk[1];
sys/dev/sound/pci/envy24ht.c
1176
cnt = blk - 1;
sys/dev/sound/pci/envy24ht.c
1178
device_printf(sc->dev, "envy24ht_updintr():blk = %d, cnt = %d\n", blk, cnt);
sys/dev/sound/pci/envy24ht.c
1508
ch->blk = 10240;
sys/dev/sound/pci/envy24ht.c
1566
ch->blk *= ch->unit / emltab[i].unit;
sys/dev/sound/pci/envy24ht.c
1568
ch->blk /= emltab[i].unit / ch->unit;
sys/dev/sound/pci/envy24ht.c
1575
bsize = ch->blk * 4 / ENVY24HT_PLAY_BUFUNIT;
sys/dev/sound/pci/envy24ht.c
1577
bsize = ch->blk * 4 / ENVY24HT_REC_BUFUNIT;
sys/dev/sound/pci/envy24ht.c
163
uint16_t blk[2]; /* transfer check blocksize(dword) */
sys/dev/sound/pci/envy24ht.c
1643
ch->blk = prev / ch->unit;
sys/dev/sound/pci/envy24ht.c
1645
ch->blk *= ENVY24HT_PLAY_BUFUNIT / 4;
sys/dev/sound/pci/envy24ht.c
1647
ch->blk *= ENVY24HT_REC_BUFUNIT / 4;
sys/dev/sound/pci/envy24ht.c
1651
bsize = ch->blk * 4 / ENVY24HT_PLAY_BUFUNIT;
sys/dev/sound/pci/envy24ht.c
1653
bsize = ch->blk * 4 / ENVY24HT_REC_BUFUNIT;
sys/dev/sound/pci/envy24ht.c
1706
sc->blk[slot] = ch->blk;
sys/dev/sound/pci/envy24ht.c
1710
ch->offset = ((ptr / ch->blk + 1) * ch->blk %
sys/dev/sound/pci/envy24ht.c
1712
if (ch->blk < sc->blk[slot])
sys/dev/sound/pci/envy24ht.c
1713
sc->blk[slot] = ch->blk;
sys/dev/sound/pci/envy24ht.c
1988
ptr -= ptr % sc->blk[0];
sys/dev/sound/pci/envy24ht.c
1997
device_printf(sc->dev, "envy24ht_intr(): chan[%d].blk = %d\n", i, ch->blk);
sys/dev/sound/pci/envy24ht.c
1999
if (ch->run && ch->blk <= feed) {
sys/dev/sound/pci/envy24ht.c
2014
ptr -= ptr % sc->blk[1];
sys/dev/sound/pci/envy24ht.c
2018
if (ch->run && ch->blk <= feed) {
sys/dev/sound/pci/envy24ht.c
2153
sc->blk[0] = sc->blk[1] = 0;
sys/dev/sound/pci/envy24ht.c
91
uint32_t blk; /* hw block size(dword) */
sys/fs/cd9660/iso.h
270
#define lblktosize(imp, blk) ((blk) << (imp)->im_bshift)
sys/fs/ext2fs/ext2_alloc.c
157
daddr_t blk;
sys/fs/ext2fs/ext2_alloc.c
162
blk = ext2_hashalloc(ip, ino_to_cg(fs, ip->i_number), 0, fs->e2fs_bsize,
sys/fs/ext2fs/ext2_alloc.c
164
if (0 == blk) {
sys/fs/ext2fs/ext2_alloc.c
169
return (blk);
sys/fs/ext2fs/ext2_extents.c
102
blk = ext4_ext_index_pblock(ex);
sys/fs/ext2fs/ext2_extents.c
103
error = ext4_ext_blk_check(ip, blk);
sys/fs/ext2fs/ext2_extents.c
108
fsbtodb(fs, blk), (int)fs->e2fs_bsize, NOCRED, &bp)) != 0) {
sys/fs/ext2fs/ext2_extents.c
124
e4fs_daddr_t blk;
sys/fs/ext2fs/ext2_extents.c
127
blk = ext4_ext_extent_pblock(ep);
sys/fs/ext2fs/ext2_extents.c
128
error = ext4_ext_blk_check(ip, blk);
sys/fs/ext2fs/ext2_extents.c
135
(uint64_t)blk);
sys/fs/ext2fs/ext2_extents.c
232
e4fs_daddr_t blk;
sys/fs/ext2fs/ext2_extents.c
234
blk = le32toh(index->ei_leaf_lo);
sys/fs/ext2fs/ext2_extents.c
235
blk |= (e4fs_daddr_t)le16toh(index->ei_leaf_hi) << 32;
sys/fs/ext2fs/ext2_extents.c
237
return (blk);
sys/fs/ext2fs/ext2_extents.c
251
e4fs_daddr_t blk;
sys/fs/ext2fs/ext2_extents.c
253
blk = le32toh(extent->e_start_lo);
sys/fs/ext2fs/ext2_extents.c
254
blk |= (e4fs_daddr_t)le16toh(extent->e_start_hi) << 32;
sys/fs/ext2fs/ext2_extents.c
256
return (blk);
sys/fs/ext2fs/ext2_extents.c
384
e4fs_daddr_t blk = ext4_ext_extent_pblock(ext);
sys/fs/ext2fs/ext2_extents.c
391
return (ext4_inode_block_validate(ip, blk, len));
sys/fs/ext2fs/ext2_extents.c
397
e4fs_daddr_t blk = ext4_ext_index_pblock(ext_idx);
sys/fs/ext2fs/ext2_extents.c
399
return (ext4_inode_block_validate(ip, blk, 1));
sys/fs/ext2fs/ext2_extents.c
491
ext4_ext_binsearch_index(struct ext4_extent_path *path, int blk)
sys/fs/ext2fs/ext2_extents.c
506
if (blk < le32toh(m->ei_blk))
sys/fs/ext2fs/ext2_extents.c
516
ext4_ext_binsearch_ext(struct ext4_extent_path *path, int blk)
sys/fs/ext2fs/ext2_extents.c
534
if (blk < le32toh(m->e_blk))
sys/fs/ext2fs/ext2_extents.c
545
struct buf *bp, uint64_t blk)
sys/fs/ext2fs/ext2_extents.c
553
path->ep_blk = blk;
sys/fs/ext2fs/ext2_extents.c
602
uint64_t blk;
sys/fs/ext2fs/ext2_extents.c
633
blk = ext4_ext_index_pblock(path[ppos].ep_index);
sys/fs/ext2fs/ext2_extents.c
637
error = bread(ip->i_devvp, fsbtodb(ip->i_e2fs, blk),
sys/fs/ext2fs/ext2_extents.c
652
ext4_ext_fill_path_bdata(&path[ppos], bp, blk);
sys/fs/ext2fs/ext2_extents.c
70
ext4_ext_blk_check(struct inode *ip, e4fs_daddr_t blk)
sys/fs/ext2fs/ext2_extents.c
720
ext4_ext_put_in_cache(struct inode *ip, uint32_t blk,
sys/fs/ext2fs/ext2_extents.c
727
ip->i_ext_cache.ec_blk = blk;
sys/fs/ext2fs/ext2_extents.c
748
e2fs_daddr_t blk = le32toh(ex->e_blk);
sys/fs/ext2fs/ext2_extents.c
750
if (block > blk)
sys/fs/ext2fs/ext2_extents.c
751
return (pblk + (block - blk));
sys/fs/ext2fs/ext2_extents.c
753
return (pblk - (blk - block));
sys/fs/ext2fs/ext2_extents.c
76
if (blk < fs->e2fs->e2fs_first_dblock || blk >= fs->e2fs_bcount)
sys/fs/ext2fs/ext2_extents.c
814
uint64_t blk;
sys/fs/ext2fs/ext2_extents.c
823
blk = path->ep_blk;
sys/fs/ext2fs/ext2_extents.c
824
bp = getblk(ip->i_devvp, fsbtodb(fs, blk),
sys/fs/ext2fs/ext2_extents.c
841
uint32_t lblk, e4fs_daddr_t blk)
sys/fs/ext2fs/ext2_extents.c
878
ext4_index_store_pblock(idx, blk);
sys/fs/ext2fs/ext2_extents.c
88
e4fs_daddr_t blk;
sys/fs/ext2fs/ext2_extents.c
888
e4fs_daddr_t blk = ext2_alloc_meta(ip);
sys/fs/ext2fs/ext2_extents.c
889
if (blk) {
sys/fs/ext2fs/ext2_extents.c
895
return (blk);
sys/fs/ext2fs/ext2_extents.c
899
ext4_ext_blkfree(struct inode *ip, uint64_t blk, int count, int flags)
sys/fs/ext2fs/ext2_extents.c
908
ext2_blkfree(ip, blk + i, fs->e2fs_bsize);
sys/fs/ext2fs/ext2_htree.c
162
ext2_htree_set_block(struct ext2fs_htree_entry *ep, uint32_t blk)
sys/fs/ext2fs/ext2_htree.c
164
ep->h_blk = htole32(blk);
sys/fs/ext2fs/ext2_htree.c
361
uint32_t blk;
sys/fs/ext2fs/ext2_htree.c
381
blk = ext2_htree_get_block(leaf_node);
sys/fs/ext2fs/ext2_htree.c
382
if (ext2_blkatoff(vp, blk * bsize, NULL, &bp) != 0) {
sys/fs/ext2fs/ext2_htree.c
387
*offp = blk * bsize;
sys/fs/ext2fs/ext2_htree.c
389
*prevoffp = blk * bsize;
sys/fs/ext2fs/ext2_htree.c
390
*endusefulp = blk * bsize;
sys/fs/ext2fs/ext2_htree.c
466
uint32_t hash, uint32_t blk)
sys/fs/ext2fs/ext2_htree.c
476
ext2_htree_set_block(target, blk);
sys/fs/ext2fs/ext2_htree.c
486
uint32_t hash, uint32_t blk)
sys/fs/ext2fs/ext2_htree.c
491
ext2_htree_insert_entry_to_level(level, hash, blk);
sys/fs/ext2fs/ext2_htree.c
80
uint32_t hash, uint32_t blk);
sys/fs/ext2fs/ext2_htree.c
82
uint32_t hash, uint32_t blk);
sys/fs/ext2fs/ext2_htree.c
85
uint32_t blk);
sys/fs/ext2fs/fs.h
133
#define lblktosize(fs, blk) /* calculates (blk * fs->fs_bsize) */ \
sys/fs/ext2fs/fs.h
134
((blk) << (fs->e2fs_bshift))
sys/fs/tarfs/tarfs.h
81
struct tarfs_blk *blk;
sys/fs/tarfs/tarfs_subr.c
221
tnp->blk = malloc(sizeof(*tnp->blk), M_TARFSBLK, M_WAITOK);
sys/fs/tarfs/tarfs_subr.c
222
tnp->blk[0].i = 0;
sys/fs/tarfs/tarfs_subr.c
223
tnp->blk[0].o = 0;
sys/fs/tarfs/tarfs_subr.c
224
tnp->blk[0].l = tnp->physize;
sys/fs/tarfs/tarfs_subr.c
265
struct tarfs_blk *blk = NULL;
sys/fs/tarfs/tarfs_subr.c
311
blk = malloc(sizeof(*blk) * nblk, M_TARFSBLK, M_WAITOK | M_ZERO);
sys/fs/tarfs/tarfs_subr.c
315
blk[i].i = nmap * TARFS_BLOCKSIZE;
sys/fs/tarfs/tarfs_subr.c
317
blk[i].i = blk[i - 1].i + blk[i - 1].l;
sys/fs/tarfs/tarfs_subr.c
322
blk[i].o = n;
sys/fs/tarfs/tarfs_subr.c
327
blk[i].l = n;
sys/fs/tarfs/tarfs_subr.c
329
i, blk[i].i, blk[i].o, blk[i].l);
sys/fs/tarfs/tarfs_subr.c
337
if (blk[i].l == 0) {
sys/fs/tarfs/tarfs_subr.c
339
} else if (blk[i].i % TARFS_BLOCKSIZE != 0 ||
sys/fs/tarfs/tarfs_subr.c
340
blk[i].o % TARFS_BLOCKSIZE != 0) {
sys/fs/tarfs/tarfs_subr.c
348
if (i > 0 && blk[i].o < blk[i - 1].o + blk[i - 1].l) {
sys/fs/tarfs/tarfs_subr.c
356
if (blk[i].i + blk[i].l > tnp->physize ||
sys/fs/tarfs/tarfs_subr.c
357
blk[i].o + blk[i].l > realsize) {
sys/fs/tarfs/tarfs_subr.c
365
free(tnp->blk, M_TARFSBLK);
sys/fs/tarfs/tarfs_subr.c
367
tnp->blk = blk;
sys/fs/tarfs/tarfs_subr.c
374
free(blk, M_TARFSBLK);
sys/fs/tarfs/tarfs_subr.c
408
if (tnp->blk != NULL)
sys/fs/tarfs/tarfs_subr.c
409
free(tnp->blk, M_TARFSBLK);
sys/fs/tarfs/tarfs_subr.c
429
if (uiop->uio_offset > tnp->blk[i].o + tnp->blk[i].l) {
sys/fs/tarfs/tarfs_subr.c
434
uiop->uio_offset < tnp->blk[i].o) {
sys/fs/tarfs/tarfs_subr.c
436
copylen = tnp->blk[i].o - uiop->uio_offset;
sys/fs/tarfs/tarfs_subr.c
455
uiop->uio_offset < tnp->blk[i].o + tnp->blk[i].l) {
sys/fs/tarfs/tarfs_subr.c
457
copylen = tnp->blk[i].l;
sys/fs/tarfs/tarfs_subr.c
461
auio.uio_offset = tnp->offset + tnp->blk[i].i +
sys/fs/tarfs/tarfs_subr.c
462
uiop->uio_offset - tnp->blk[i].o;
sys/fs/tarfs/tarfs_vnops.c
154
bs = tnp->blk[i].o;
sys/fs/tarfs/tarfs_vnops.c
155
be = tnp->blk[i].o + tnp->blk[i].l;
sys/fs/tarfs/tarfs_vnops.c
163
0 : tnp->blk[i - 1].o + tnp->blk[i - 1].l),
sys/fs/udf/udf_vnops.c
433
#define lblktosize(udfmp, blk) ((blk) << (udfmp)->bshift)
sys/geom/part/g_part_apm.c
187
apm_read_ent(struct g_consumer *cp, uint32_t blk, struct apm_ent *ent,
sys/geom/part/g_part_apm.c
195
buf = g_read_data(cp, pp->sectorsize * blk, pp->sectorsize, &error);
sys/geom/part/g_part_ldm.c
701
struct ldm_xvblk *blk;
sys/geom/part/g_part_ldm.c
705
LIST_FOREACH(blk, &db->xvblks, entry)
sys/geom/part/g_part_ldm.c
706
if (blk->group == vh->group)
sys/geom/part/g_part_ldm.c
708
if (blk == NULL) {
sys/geom/part/g_part_ldm.c
709
blk = g_malloc(sizeof(*blk), M_WAITOK | M_ZERO);
sys/geom/part/g_part_ldm.c
710
blk->group = vh->group;
sys/geom/part/g_part_ldm.c
711
blk->size = size * vh->count + 16;
sys/geom/part/g_part_ldm.c
712
blk->data = g_malloc(blk->size, M_WAITOK | M_ZERO);
sys/geom/part/g_part_ldm.c
713
blk->map = 0xFF << vh->count;
sys/geom/part/g_part_ldm.c
714
LIST_INSERT_HEAD(&db->xvblks, blk, entry);
sys/geom/part/g_part_ldm.c
716
if ((blk->map & (1 << vh->index)) != 0) {
sys/geom/part/g_part_ldm.c
721
memcpy(blk->data + size * vh->index + 16, p + 16, size);
sys/geom/part/g_part_ldm.c
722
blk->map |= 1 << vh->index;
sys/geom/part/g_part_ldm.c
773
struct ldm_vblk *blk;
sys/geom/part/g_part_ldm.c
779
blk = g_malloc(sizeof(*blk), M_WAITOK | M_ZERO);
sys/geom/part/g_part_ldm.c
780
blk->type = p[LDM_VBLK_TYPE_OFF];
sys/geom/part/g_part_ldm.c
781
offset = ldm_vnum_get(p, LDM_VBLK_OID_OFF, &blk->u.id, size);
sys/geom/part/g_part_ldm.c
791
switch (blk->type) {
sys/geom/part/g_part_ldm.c
813
&blk->u.comp.vol_id, size);
sys/geom/part/g_part_ldm.c
834
blk->u.part.start = be64dec(p + offset + 12);
sys/geom/part/g_part_ldm.c
835
blk->u.part.offset = be64dec(p + offset + 20);
sys/geom/part/g_part_ldm.c
836
offset = ldm_vnum_get(p, offset + 28, &blk->u.part.size, size);
sys/geom/part/g_part_ldm.c
841
offset = ldm_vnum_get(p, offset, &blk->u.part.comp_id, size);
sys/geom/part/g_part_ldm.c
846
offset = ldm_vnum_get(p, offset, &blk->u.part.disk_id, size);
sys/geom/part/g_part_ldm.c
863
error = parse_uuid(vstr, &blk->u.disk.guid);
sys/geom/part/g_part_ldm.c
866
LIST_INSERT_HEAD(&db->disks, &blk->u.disk, entry);
sys/geom/part/g_part_ldm.c
876
strncpy(blk->u.disk_group.name, vstr,
sys/geom/part/g_part_ldm.c
877
sizeof(blk->u.disk_group.name));
sys/geom/part/g_part_ldm.c
883
error = parse_uuid(name, &blk->u.disk_group.guid);
sys/geom/part/g_part_ldm.c
888
LIST_INSERT_HEAD(&db->groups, &blk->u.disk_group, entry);
sys/geom/part/g_part_ldm.c
898
be_uuid_dec(p + offset, &blk->u.disk.guid);
sys/geom/part/g_part_ldm.c
899
LIST_INSERT_HEAD(&db->disks, &blk->u.disk, entry);
sys/geom/part/g_part_ldm.c
909
strncpy(blk->u.disk_group.name, vstr,
sys/geom/part/g_part_ldm.c
910
sizeof(blk->u.disk_group.name));
sys/geom/part/g_part_ldm.c
911
be_uuid_dec(p + offset, &blk->u.disk.guid);
sys/geom/part/g_part_ldm.c
912
LIST_INSERT_HEAD(&db->groups, &blk->u.disk_group, entry);
sys/geom/part/g_part_ldm.c
942
blk->u.vol.number = p[offset + 16];
sys/geom/part/g_part_ldm.c
948
offset = ldm_vnum_get(p, offset + 16, &blk->u.vol.size, size);
sys/geom/part/g_part_ldm.c
957
blk->u.vol.part_type = p[offset + 4];
sys/geom/part/g_part_ldm.c
961
if (volume->number > blk->u.vol.number)
sys/geom/part/g_part_ldm.c
966
LIST_INSERT_AFTER(last, &blk->u.vol, entry);
sys/geom/part/g_part_ldm.c
968
LIST_INSERT_HEAD(&db->volumes, &blk->u.vol, entry);
sys/geom/part/g_part_ldm.c
971
LDM_DEBUG(1, "unknown VBLK type 0x%02x\n", blk->type);
sys/geom/part/g_part_ldm.c
974
LIST_INSERT_HEAD(&db->vblks, blk, entry);
sys/geom/part/g_part_ldm.c
978
errstr, blk->type);
sys/geom/part/g_part_ldm.c
980
g_free(blk);
sys/geom/uzip/g_uzip.c
175
size_t blk, blkofs, usz;
sys/geom/uzip/g_uzip.c
179
blk = ofs / sc->blksz;
sys/geom/uzip/g_uzip.c
181
if (blk == sc->last_blk) {
sys/geom/uzip/g_uzip.c
356
size_t blk, blkofs, len, ulen, firstblk;
sys/geom/uzip/g_uzip.c
376
firstblk = blk = ofs / sc->blksz;
sys/geom/uzip/g_uzip.c
378
data = bp->bio_data + sc->toc[blk].offset % pp->sectorsize;
sys/geom/uzip/g_uzip.c
381
if (blk > firstblk && !BLK_IS_CONT(sc, blk)) {
sys/geom/uzip/g_uzip.c
382
DPRINTF_BLK(GUZ_DBG_IO, blk, ("%s/%s: %p: backref'ed "
sys/geom/uzip/g_uzip.c
384
__func__, gp->name, bp2, (u_int)blk));
sys/geom/uzip/g_uzip.c
388
len = sc->toc[blk].blen;
sys/geom/uzip/g_uzip.c
400
if (err != 0 && sc->toc[blk].last != 0) {
sys/geom/uzip/g_uzip.c
406
sc->toc[blk].blen = 0;
sys/geom/uzip/g_uzip.c
419
gp->name, sc->dcp, (uintmax_t)blk,
sys/geom/uzip/g_uzip.c
423
sc->last_blk = blk;
sys/geom/uzip/g_uzip.c
442
blk++;
sys/geom/uzip/g_uzip.c
671
uint32_t i, total_offsets, offsets_read, blk;
sys/geom/uzip/g_uzip.c
819
for (blk = 1; offsets_read < total_offsets; blk++) {
sys/geom/uzip/g_uzip.c
824
cp, blk * pp->sectorsize, pp->sectorsize, NULL);
sys/geom/uzip/g_uzip.c
830
gp->name, nread, blk));
sys/geom/uzip/g_uzip.c
842
"sectors\n", gp->name, offsets_read, blk));
sys/kern/kern_lockf.c
2639
struct lockf_entry *lf, *blk;
sys/kern/kern_lockf.c
2652
blk = e->le_to;
sys/kern/kern_lockf.c
2653
printf("\n\t\tlock request %p for ", (void *)blk);
sys/kern/kern_lockf.c
2654
lf_print_owner(blk->lf_owner);
sys/kern/kern_lockf.c
2656
blk->lf_type == F_RDLCK ? "shared" :
sys/kern/kern_lockf.c
2657
blk->lf_type == F_WRLCK ? "exclusive" :
sys/kern/kern_lockf.c
2658
blk->lf_type == F_UNLCK ? "unlock" :
sys/kern/kern_lockf.c
2659
"unknown", (intmax_t)blk->lf_start,
sys/kern/kern_lockf.c
2660
(intmax_t)blk->lf_end);
sys/kern/kern_lockf.c
2661
if (!LIST_EMPTY(&blk->lf_inedges))
sys/kern/subr_blist.c
1004
if (blk != 0)
sys/kern/subr_blist.c
1005
endBlk = ummin(endBlk, blk);
sys/kern/subr_blist.c
1007
blk = allocBlk & -radix;
sys/kern/subr_blist.c
1009
while (blk < endBlk) {
sys/kern/subr_blist.c
1010
digit = (blk / radix) & BLIST_MASK;
sys/kern/subr_blist.c
1012
blk += radix;
sys/kern/subr_blist.c
1013
count = ummin(blk, endBlk) - allocBlk;
sys/kern/subr_blist.c
1018
allocBlk = blk;
sys/kern/subr_blist.c
1026
blst_radix_print(blmeta_t *scan, daddr_t blk, daddr_t radix, int tab)
sys/kern/subr_blist.c
1036
(long long)blk, (long long)BLIST_RADIX,
sys/kern/subr_blist.c
1047
(long long)blk, (long long)radix * BLIST_RADIX,
sys/kern/subr_blist.c
1061
blst_radix_print(&scan[1 + digit * skip], blk + digit * radix,
sys/kern/subr_blist.c
1130
daddr_t blk = blist_alloc(bl, &count, maxcount);
sys/kern/subr_blist.c
1132
(long long)blk, count);
sys/kern/subr_blist.c
130
static daddr_t blst_leaf_alloc(blmeta_t *scan, daddr_t blk,
sys/kern/subr_blist.c
137
static void blst_copy(blmeta_t *scan, daddr_t blk, daddr_t radix,
sys/kern/subr_blist.c
139
static daddr_t blst_leaf_fill(blmeta_t *scan, daddr_t blk, int count);
sys/kern/subr_blist.c
143
static void blst_radix_print(blmeta_t *scan, daddr_t blk, daddr_t radix,
sys/kern/subr_blist.c
265
daddr_t blk, cursor;
sys/kern/subr_blist.c
279
blk = blst_meta_alloc(bl->bl_root, cursor, count, maxcount,
sys/kern/subr_blist.c
281
if (blk != SWAPBLK_NONE) {
sys/kern/subr_blist.c
283
bl->bl_cursor = blk + *count;
sys/kern/subr_blist.c
286
return (blk);
sys/kern/subr_blist.c
590
daddr_t blk;
sys/kern/subr_blist.c
594
for (blk = start; blk - start < maxcount; blk += BLIST_RADIX) {
sys/kern/subr_blist.c
598
((blk / radix) & BLIST_MASK) == 0)
sys/kern/subr_blist.c
607
avail = blk - start + bitpos(~scan->bm_bitmap);
sys/kern/subr_blist.c
626
blk -= BLIST_RADIX;
sys/kern/subr_blist.c
642
blk -= BLIST_RADIX;
sys/kern/subr_blist.c
644
(digit = ((blk / radix) & BLIST_MASK)) == 0;
sys/kern/subr_blist.c
653
if (blk == start)
sys/kern/subr_blist.c
669
blst_leaf_alloc(blmeta_t *scan, daddr_t blk, int *count, int maxcount)
sys/kern/subr_blist.c
702
if ((blk & BLIST_MASK) != 0) {
sys/kern/subr_blist.c
703
if ((~mask & bitrange(0, blk & BLIST_MASK)) != 0) {
sys/kern/subr_blist.c
705
bighint += blk & BLIST_MASK;
sys/kern/subr_blist.c
706
mask |= bitrange(0, blk & BLIST_MASK);
sys/kern/subr_blist.c
712
blk -= blk & BLIST_MASK;
sys/kern/subr_blist.c
742
hi = blst_next_leaf_alloc(scan, blk, count1, maxcount);
sys/kern/subr_blist.c
759
return (blk + lo);
sys/kern/subr_blist.c
774
daddr_t blk, i, r, skip;
sys/kern/subr_blist.c
781
blk = cursor & -(radix * BLIST_RADIX);
sys/kern/subr_blist.c
782
scan_from_start = (cursor == blk);
sys/kern/subr_blist.c
800
cursor = blk;
sys/kern/subr_blist.c
820
cursor = blk;
sys/kern/subr_blist.c
839
blst_leaf_free(blmeta_t *scan, daddr_t blk, int count)
sys/kern/subr_blist.c
849
mask = bitrange(blk & BLIST_MASK, count);
sys/kern/subr_blist.c
852
(uintmax_t)blk, count, (uintmax_t)scan->bm_bitmap & mask));
sys/kern/subr_blist.c
869
daddr_t blk, endBlk, i, skip;
sys/kern/subr_blist.c
884
blk = (freeBlk + radix * BLIST_RADIX) & -(radix * BLIST_RADIX);
sys/kern/subr_blist.c
889
if (blk != 0)
sys/kern/subr_blist.c
890
endBlk = ummin(endBlk, blk);
sys/kern/subr_blist.c
892
blk = freeBlk & -radix;
sys/kern/subr_blist.c
893
digit = (blk / radix) & BLIST_MASK;
sys/kern/subr_blist.c
896
for (i = 1 + digit * skip; blk < endBlk; i += skip) {
sys/kern/subr_blist.c
897
blk += radix;
sys/kern/subr_blist.c
898
count = ummin(blk, endBlk) - freeBlk;
sys/kern/subr_blist.c
900
freeBlk = blk;
sys/kern/subr_blist.c
911
blst_copy(blmeta_t *scan, daddr_t blk, daddr_t radix, blist_t dest,
sys/kern/subr_blist.c
924
blist_free(dest, blk, count);
sys/kern/subr_blist.c
930
blist_free(dest, blk + i, 1);
sys/kern/subr_blist.c
947
endBlk = blk + count;
sys/kern/subr_blist.c
949
for (i = 1; blk < endBlk; i += skip) {
sys/kern/subr_blist.c
950
blk += radix;
sys/kern/subr_blist.c
952
if (blk >= endBlk)
sys/kern/subr_blist.c
953
count -= blk - endBlk;
sys/kern/subr_blist.c
954
blst_copy(&scan[i], blk - radix,
sys/kern/subr_blist.c
967
blst_leaf_fill(blmeta_t *scan, daddr_t blk, int count)
sys/kern/subr_blist.c
972
mask = bitrange(blk & BLIST_MASK, count);
sys/kern/subr_blist.c
992
daddr_t blk, endBlk, i, nblks, skip;
sys/kern/subr_blist.c
999
blk = (allocBlk + radix * BLIST_RADIX) & -(radix * BLIST_RADIX);
sys/netinet/sctp_uio.h
914
struct sctp_blk_args blk;
sys/netinet/sctputil.c
550
sctp_clog.x.blk.onsb = asoc->total_output_queue_size;
sys/netinet/sctputil.c
551
sctp_clog.x.blk.send_sent_qcnt = (uint16_t)(asoc->send_queue_cnt + asoc->sent_queue_cnt);
sys/netinet/sctputil.c
552
sctp_clog.x.blk.peer_rwnd = asoc->peers_rwnd;
sys/netinet/sctputil.c
553
sctp_clog.x.blk.stream_qcnt = (uint16_t)asoc->stream_queue_cnt;
sys/netinet/sctputil.c
554
sctp_clog.x.blk.chunks_on_oque = (uint16_t)asoc->chunks_on_out_queue;
sys/netinet/sctputil.c
555
sctp_clog.x.blk.flight_size = (uint16_t)(asoc->total_flight / 1024);
sys/netinet/sctputil.c
556
sctp_clog.x.blk.sndlen = (uint32_t)sendlen;
sys/netinet/tcp_stacks/bbr.c
7027
struct sackblk blk;
sys/netinet/tcp_stacks/bbr.c
7029
blk.start = start;
sys/netinet/tcp_stacks/bbr.c
7030
blk.end = end;
sys/netinet/tcp_stacks/bbr.c
7031
sack_filter_reject(&bbr->r_ctl.bbr_sf, &blk);
sys/netinet/tcp_stacks/bbr.c
7097
struct sackblk blk;
sys/netinet/tcp_stacks/bbr.c
7099
blk.start = start;
sys/netinet/tcp_stacks/bbr.c
7100
blk.end = end;
sys/netinet/tcp_stacks/bbr.c
7101
sack_filter_reject(&bbr->r_ctl.bbr_sf, &blk);
sys/netinet/tcp_subr.c
1186
register_tcp_functions_as_names(struct tcp_function_block *blk, int wait,
sys/netinet/tcp_subr.c
1204
if ((blk->tfb_tcp_output == NULL) ||
sys/netinet/tcp_subr.c
1205
(blk->tfb_tcp_do_segment == NULL) ||
sys/netinet/tcp_subr.c
1206
(blk->tfb_tcp_ctloutput == NULL) ||
sys/netinet/tcp_subr.c
1207
(blk->tfb_tcp_handoff_ok == NULL) ||
sys/netinet/tcp_subr.c
1208
(strlen(blk->tfb_tcp_block_name) == 0)) {
sys/netinet/tcp_subr.c
1226
if (find_tcp_fb_locked(blk, NULL) != NULL) {
sys/netinet/tcp_subr.c
1231
if (blk->tfb_flags & TCP_FUNC_BEING_REMOVED) {
sys/netinet/tcp_subr.c
1235
refcount_init(&blk->tfb_refcnt, 0);
sys/netinet/tcp_subr.c
1236
blk->tfb_id = atomic_fetchadd_int(&next_tcp_stack_id, 1);
sys/netinet/tcp_subr.c
1245
f[i]->tf_fb = blk;
sys/netinet/tcp_subr.c
1276
register_tcp_functions_as_name(struct tcp_function_block *blk, const char *name,
sys/netinet/tcp_subr.c
1286
name_list[0] = blk->tfb_tcp_block_name;
sys/netinet/tcp_subr.c
1287
rv = register_tcp_functions_as_names(blk, wait, name_list, &num_names);
sys/netinet/tcp_subr.c
1298
register_tcp_functions(struct tcp_function_block *blk, int wait)
sys/netinet/tcp_subr.c
1301
return (register_tcp_functions_as_name(blk, NULL, wait));
sys/netinet/tcp_subr.c
1322
deregister_tcp_functions(struct tcp_function_block *blk, bool quiesce,
sys/netinet/tcp_subr.c
1328
if (blk == &tcp_def_funcblk) {
sys/netinet/tcp_subr.c
1336
if (blk == V_tcp_func_set_ptr) {
sys/netinet/tcp_subr.c
1347
blk->tfb_flags |= TCP_FUNC_BEING_REMOVED;
sys/netinet/tcp_subr.c
1352
if (force && blk->tfb_refcnt) {
sys/netinet/tcp_subr.c
1367
if (tp == NULL || tp->t_fb != blk)
sys/netinet/tcp_subr.c
1377
if (blk->tfb_refcnt) {
sys/netinet/tcp_subr.c
1388
while (find_tcp_fb_locked(blk, &f) != NULL) {
sys/netinet/tcp_subr.c
395
struct tcp_function_block *blk = NULL;
sys/netinet/tcp_subr.c
400
blk = f->tf_fb;
sys/netinet/tcp_subr.c
404
return (blk);
sys/netinet/tcp_subr.c
408
find_tcp_fb_locked(struct tcp_function_block *blk, struct tcp_function **s)
sys/netinet/tcp_subr.c
415
if (f->tf_fb == blk) {
sys/netinet/tcp_subr.c
416
rblk = blk;
sys/netinet/tcp_subr.c
429
struct tcp_function_block *blk;
sys/netinet/tcp_subr.c
432
blk = find_tcp_functions_locked(fs);
sys/netinet/tcp_subr.c
433
if (blk)
sys/netinet/tcp_subr.c
434
refcount_acquire(&blk->tfb_refcnt);
sys/netinet/tcp_subr.c
436
return (blk);
sys/netinet/tcp_subr.c
440
find_and_ref_tcp_fb(struct tcp_function_block *blk)
sys/netinet/tcp_subr.c
445
rblk = find_tcp_fb_locked(blk, NULL);
sys/netinet/tcp_subr.c
454
find_tcp_function_alias(struct tcp_function_block *blk,
sys/netinet/tcp_subr.c
463
if ((f->tf_fb == blk) &&
sys/netinet/tcp_subr.c
464
(strncmp(f->tf_name, blk->tfb_tcp_block_name,
sys/netinet/tcp_subr.c
663
struct tcp_function_block *blk;
sys/netinet/tcp_subr.c
668
blk = find_tcp_fb_locked(V_tcp_func_set_ptr, NULL);
sys/netinet/tcp_subr.c
669
if (blk != NULL) {
sys/netinet/tcp_subr.c
671
strcpy(fs.function_set_name, blk->tfb_tcp_block_name);
sys/netinet/tcp_subr.c
672
fs.pcbcnt = blk->tfb_refcnt;
sys/netinet/tcp_subr.c
683
blk = find_tcp_functions_locked(&fs);
sys/netinet/tcp_subr.c
684
if ((blk == NULL) ||
sys/netinet/tcp_subr.c
685
(blk->tfb_flags & TCP_FUNC_BEING_REMOVED)) {
sys/netinet/tcp_subr.c
689
if ((blk->tfb_flags & TCP_FUNC_DEFAULT_OK) == 0) {
sys/netinet/tcp_subr.c
693
V_tcp_func_set_ptr = blk;
sys/netinet/tcp_usrreq.c
1675
struct tcp_function_block *blk;
sys/netinet/tcp_usrreq.c
1685
blk = find_and_ref_tcp_functions(&fsn);
sys/netinet/tcp_usrreq.c
1686
if (blk == NULL) {
sys/netinet/tcp_usrreq.c
1690
if (tp->t_fb == blk) {
sys/netinet/tcp_usrreq.c
1692
refcount_release(&blk->tfb_refcnt);
sys/netinet/tcp_usrreq.c
1696
if (blk->tfb_flags & TCP_FUNC_BEING_REMOVED) {
sys/netinet/tcp_usrreq.c
1697
refcount_release(&blk->tfb_refcnt);
sys/netinet/tcp_usrreq.c
1701
error = (*blk->tfb_tcp_handoff_ok)(tp);
sys/netinet/tcp_usrreq.c
1703
refcount_release(&blk->tfb_refcnt);
sys/netinet/tcp_usrreq.c
1713
if (blk->tfb_tcp_fb_init) {
sys/netinet/tcp_usrreq.c
1714
error = (*blk->tfb_tcp_fb_init)(tp, &ptr);
sys/netinet/tcp_usrreq.c
1720
refcount_release(&blk->tfb_refcnt);
sys/netinet/tcp_usrreq.c
1754
tp->t_fb = blk;
sys/netinet/tcp_var.h
1436
int register_tcp_functions(struct tcp_function_block *blk, int wait);
sys/netinet/tcp_var.h
1437
int register_tcp_functions_as_names(struct tcp_function_block *blk,
sys/netinet/tcp_var.h
1439
int register_tcp_functions_as_name(struct tcp_function_block *blk,
sys/netinet/tcp_var.h
1441
int deregister_tcp_functions(struct tcp_function_block *blk, bool quiesce,
sys/netinet/tcp_var.h
1444
int find_tcp_function_alias(struct tcp_function_block *blk, struct tcp_function_set *fs);
sys/opencrypto/cryptosoft.c
100
unsigned char blk[EALG_MAX_BLOCK_LEN];
sys/opencrypto/cryptosoft.c
1004
memset(blk, 0, POLY1305_BLOCK_LEN);
sys/opencrypto/cryptosoft.c
1005
exf->update(ctx, blk, POLY1305_BLOCK_LEN -
sys/opencrypto/cryptosoft.c
1029
crypto_cursor_copydata(&cc_in, blksz, blk);
sys/opencrypto/cryptosoft.c
1030
inblk = blk;
sys/opencrypto/cryptosoft.c
1035
outblk = blk;
sys/opencrypto/cryptosoft.c
1045
if (inblk == blk) {
sys/opencrypto/cryptosoft.c
1053
if (outblk == blk) {
sys/opencrypto/cryptosoft.c
1054
crypto_cursor_copyback(&cc_out, blksz, blk);
sys/opencrypto/cryptosoft.c
1063
crypto_cursor_copydata(&cc_in, resid, blk);
sys/opencrypto/cryptosoft.c
1064
exf->encrypt_last(ctx, blk, blk, resid);
sys/opencrypto/cryptosoft.c
1065
crypto_cursor_copyback(&cc_out, resid, blk);
sys/opencrypto/cryptosoft.c
1066
exf->update(ctx, blk, resid);
sys/opencrypto/cryptosoft.c
1073
memset(blk, 0, POLY1305_BLOCK_LEN);
sys/opencrypto/cryptosoft.c
1074
exf->update(ctx, blk, POLY1305_BLOCK_LEN -
sys/opencrypto/cryptosoft.c
1079
blkp = (uint64_t *)blk;
sys/opencrypto/cryptosoft.c
1082
exf->update(ctx, blk, sizeof(uint64_t) * 2);
sys/opencrypto/cryptosoft.c
1111
crypto_cursor_copydata(&cc_in, blksz, blk);
sys/opencrypto/cryptosoft.c
1112
inblk = blk;
sys/opencrypto/cryptosoft.c
1116
outblk = blk;
sys/opencrypto/cryptosoft.c
1125
if (inblk == blk) {
sys/opencrypto/cryptosoft.c
1133
if (outblk == blk) {
sys/opencrypto/cryptosoft.c
1134
crypto_cursor_copyback(&cc_out, blksz, blk);
sys/opencrypto/cryptosoft.c
1144
crypto_cursor_copydata(&cc_in, resid, blk);
sys/opencrypto/cryptosoft.c
1145
exf->decrypt_last(ctx, blk, blk, resid);
sys/opencrypto/cryptosoft.c
1146
crypto_cursor_copyback(&cc_out, resid, blk);
sys/opencrypto/cryptosoft.c
141
crypto_read_iv(crp, blk);
sys/opencrypto/cryptosoft.c
142
exf->reinit(ctx, blk, csp->csp_ivlen);
sys/opencrypto/cryptosoft.c
173
crypto_cursor_copydata(&cc_in, blksz, blk);
sys/opencrypto/cryptosoft.c
174
inblk = blk;
sys/opencrypto/cryptosoft.c
178
outblk = blk;
sys/opencrypto/cryptosoft.c
189
if (inblk == blk) {
sys/opencrypto/cryptosoft.c
197
if (outblk == blk) {
sys/opencrypto/cryptosoft.c
198
crypto_cursor_copyback(&cc_out, blksz, blk);
sys/opencrypto/cryptosoft.c
217
crypto_cursor_copydata(&cc_in, resid, blk);
sys/opencrypto/cryptosoft.c
218
inblk = blk;
sys/opencrypto/cryptosoft.c
221
outblk = blk;
sys/opencrypto/cryptosoft.c
229
crypto_cursor_copyback(&cc_out, resid, blk);
sys/opencrypto/cryptosoft.c
233
explicit_bzero(blk, sizeof(blk));
sys/opencrypto/cryptosoft.c
328
u_char *blk = (u_char *)s.blkbuf;
sys/opencrypto/cryptosoft.c
352
crypto_read_iv(crp, blk);
sys/opencrypto/cryptosoft.c
354
axf->Reinit(&s.ctx, blk, ivlen);
sys/opencrypto/cryptosoft.c
364
crypto_cursor_copydata(&cc, len, blk);
sys/opencrypto/cryptosoft.c
365
inblk = blk;
sys/opencrypto/cryptosoft.c
370
memset(blk, 0, blksz);
sys/opencrypto/cryptosoft.c
371
crypto_cursor_copydata(&cc, resid, blk);
sys/opencrypto/cryptosoft.c
372
axf->Update(&s.ctx, blk, blksz);
sys/opencrypto/cryptosoft.c
376
memset(blk, 0, blksz);
sys/opencrypto/cryptosoft.c
377
blkp = (uint32_t *)blk + 1;
sys/opencrypto/cryptosoft.c
379
axf->Update(&s.ctx, blk, blksz);
sys/opencrypto/cryptosoft.c
406
u_char *blk = (u_char *)s.blkbuf;
sys/opencrypto/cryptosoft.c
444
memset(blk, 0, blksz);
sys/opencrypto/cryptosoft.c
445
memcpy(blk, (char *)crp->crp_aad + inlen,
sys/opencrypto/cryptosoft.c
447
exf->update(ctx, blk, blksz);
sys/opencrypto/cryptosoft.c
460
crypto_cursor_copydata(&cc_in, inlen, blk);
sys/opencrypto/cryptosoft.c
461
inblk = blk;
sys/opencrypto/cryptosoft.c
466
memset(blk, 0, blksz);
sys/opencrypto/cryptosoft.c
467
crypto_cursor_copydata(&cc_in, resid, blk);
sys/opencrypto/cryptosoft.c
468
exf->update(ctx, blk, blksz);
sys/opencrypto/cryptosoft.c
489
crypto_cursor_copydata(&cc_in, blksz, blk);
sys/opencrypto/cryptosoft.c
490
inblk = blk;
sys/opencrypto/cryptosoft.c
496
outblk = blk;
sys/opencrypto/cryptosoft.c
506
if (outblk == blk) {
sys/opencrypto/cryptosoft.c
507
crypto_cursor_copyback(&cc_out, blksz, blk);
sys/opencrypto/cryptosoft.c
519
if (inblk == blk) {
sys/opencrypto/cryptosoft.c
528
crypto_cursor_copydata(&cc_in, resid, blk);
sys/opencrypto/cryptosoft.c
530
exf->encrypt_last(ctx, blk, blk, resid);
sys/opencrypto/cryptosoft.c
531
crypto_cursor_copyback(&cc_out, resid, blk);
sys/opencrypto/cryptosoft.c
533
exf->update(ctx, blk, resid);
sys/opencrypto/cryptosoft.c
537
memset(blk, 0, blksz);
sys/opencrypto/cryptosoft.c
538
blkp = (uint32_t *)blk + 1;
sys/opencrypto/cryptosoft.c
540
blkp = (uint32_t *)blk + 3;
sys/opencrypto/cryptosoft.c
542
exf->update(ctx, blk, blksz);
sys/opencrypto/cryptosoft.c
570
crypto_cursor_copydata(&cc_in, blksz, blk);
sys/opencrypto/cryptosoft.c
571
inblk = blk;
sys/opencrypto/cryptosoft.c
575
outblk = blk;
sys/opencrypto/cryptosoft.c
584
if (inblk == blk) {
sys/opencrypto/cryptosoft.c
592
if (outblk == blk) {
sys/opencrypto/cryptosoft.c
593
crypto_cursor_copyback(&cc_out, blksz, blk);
sys/opencrypto/cryptosoft.c
603
crypto_cursor_copydata(&cc_in, resid, blk);
sys/opencrypto/cryptosoft.c
604
exf->decrypt_last(ctx, blk, blk, resid);
sys/opencrypto/cryptosoft.c
605
crypto_cursor_copyback(&cc_out, resid, blk);
sys/opencrypto/cryptosoft.c
659
build_ccm_aad_length(u_int aad_length, uint8_t *blk)
sys/opencrypto/cryptosoft.c
662
be16enc(blk, aad_length);
sys/opencrypto/cryptosoft.c
665
blk[0] = 0xff;
sys/opencrypto/cryptosoft.c
666
blk[1] = 0xfe;
sys/opencrypto/cryptosoft.c
667
be32enc(blk + 2, aad_length);
sys/opencrypto/cryptosoft.c
677
u_char blk[CCM_CBC_BLOCK_LEN];
sys/opencrypto/cryptosoft.c
704
swa->sw_mlen, s.blk);
sys/opencrypto/cryptosoft.c
705
axf->Update(&s.ctx, s.blk, CCM_CBC_BLOCK_LEN);
sys/opencrypto/cryptosoft.c
707
len = build_ccm_aad_length(crp->crp_payload_length, s.blk);
sys/opencrypto/cryptosoft.c
708
axf->Update(&s.ctx, s.blk, len);
sys/opencrypto/cryptosoft.c
740
u_char *blk = (u_char *)s.blkbuf;
sys/opencrypto/cryptosoft.c
780
crp->crp_payload_length, swa->sw_mlen, blk);
sys/opencrypto/cryptosoft.c
781
exf->update(ctx, blk, CCM_CBC_BLOCK_LEN);
sys/opencrypto/cryptosoft.c
785
len = build_ccm_aad_length(crp->crp_aad_length, blk);
sys/opencrypto/cryptosoft.c
786
exf->update(ctx, blk, len);
sys/opencrypto/cryptosoft.c
797
memset(blk, 0, CCM_CBC_BLOCK_LEN);
sys/opencrypto/cryptosoft.c
798
exf->update(ctx, blk, len);
sys/opencrypto/cryptosoft.c
819
crypto_cursor_copydata(&cc_in, blksz, blk);
sys/opencrypto/cryptosoft.c
820
inblk = blk;
sys/opencrypto/cryptosoft.c
826
outblk = blk;
sys/opencrypto/cryptosoft.c
836
if (outblk == blk) {
sys/opencrypto/cryptosoft.c
837
crypto_cursor_copyback(&cc_out, blksz, blk);
sys/opencrypto/cryptosoft.c
854
exf->decrypt(ctx, inblk, blk);
sys/opencrypto/cryptosoft.c
855
exf->update(ctx, blk, todo);
sys/opencrypto/cryptosoft.c
858
if (inblk == blk) {
sys/opencrypto/cryptosoft.c
867
crypto_cursor_copydata(&cc_in, resid, blk);
sys/opencrypto/cryptosoft.c
869
exf->update(ctx, blk, resid);
sys/opencrypto/cryptosoft.c
870
exf->encrypt_last(ctx, blk, blk, resid);
sys/opencrypto/cryptosoft.c
871
crypto_cursor_copyback(&cc_out, resid, blk);
sys/opencrypto/cryptosoft.c
873
exf->decrypt_last(ctx, blk, blk, resid);
sys/opencrypto/cryptosoft.c
874
exf->update(ctx, blk, resid);
sys/opencrypto/cryptosoft.c
907
crypto_cursor_copydata(&cc_in, blksz, blk);
sys/opencrypto/cryptosoft.c
908
inblk = blk;
sys/opencrypto/cryptosoft.c
912
outblk = blk;
sys/opencrypto/cryptosoft.c
921
if (inblk == blk) {
sys/opencrypto/cryptosoft.c
929
if (outblk == blk) {
sys/opencrypto/cryptosoft.c
930
crypto_cursor_copyback(&cc_out, blksz, blk);
sys/opencrypto/cryptosoft.c
940
crypto_cursor_copydata(&cc_in, resid, blk);
sys/opencrypto/cryptosoft.c
941
exf->decrypt_last(ctx, blk, blk, resid);
sys/opencrypto/cryptosoft.c
942
crypto_cursor_copyback(&cc_out, resid, blk);
sys/opencrypto/cryptosoft.c
965
u_char *blk = (u_char *)s.blkbuf;
sys/opencrypto/xform_sha1.c
100
SHA1Final_int(uint8_t *blk, void *ctx)
sys/opencrypto/xform_sha1.c
102
SHA1Final(blk, ctx);
sys/sys/cdio.h
122
int blk;
sys/ufs/ffs/ffs_alloc.c
2286
int i, blk, frags, bbase, error;
sys/ufs/ffs/ffs_alloc.c
2368
blk = blkmap(fs, blksfree, bbase);
sys/ufs/ffs/ffs_alloc.c
2369
ffs_fragacct(fs, blk, cgp->cg_frsum, -1);
sys/ufs/ffs/ffs_alloc.c
2389
blk = blkmap(fs, blksfree, bbase);
sys/ufs/ffs/ffs_alloc.c
2390
ffs_fragacct(fs, blk, cgp->cg_frsum, 1);
sys/ufs/ffs/ffs_alloc.c
2964
int blk, field, subfield, pos;
sys/ufs/ffs/ffs_alloc.c
3000
blk = blkmap(fs, blksfree, bno);
sys/ufs/ffs/ffs_alloc.c
3001
blk <<= 1;
sys/ufs/ffs/ffs_alloc.c
3005
if ((blk & field) == subfield)
sys/ufs/ffs/ffs_softdep.c
11109
int frags, blk;
sys/ufs/ffs/ffs_softdep.c
11136
blk = blkmap(fs, blksfree, bbase);
sys/ufs/ffs/ffs_softdep.c
11137
ffs_fragacct(fs, blk, cgp->cg_frsum, -1);
sys/ufs/ffs/ffs_softdep.c
11143
blk = blkmap(fs, blksfree, bbase);
sys/ufs/ffs/ffs_softdep.c
11144
ffs_fragacct(fs, blk, cgp->cg_frsum, 1);
sys/ufs/ffs/ffs_softdep.c
12087
int frags, blk;
sys/ufs/ffs/ffs_softdep.c
12113
blk = blkmap(fs, blksfree, bbase);
sys/ufs/ffs/ffs_softdep.c
12114
ffs_fragacct(fs, blk, cgp->cg_frsum, -1);
sys/ufs/ffs/ffs_softdep.c
12120
blk = blkmap(fs, blksfree, bbase);
sys/ufs/ffs/ffs_softdep.c
12121
ffs_fragacct(fs, blk, cgp->cg_frsum, 1);
sys/ufs/ffs/fs.h
701
#define lblktosize(fs, blk) /* calculates ((off_t)blk * fs->fs_bsize) */ \
sys/ufs/ffs/fs.h
702
(((off_t)(blk)) << (fs)->fs_bshift)
sys/ufs/ffs/fs.h
704
#define smalllblktosize(fs, blk) /* calculates (blk * fs->fs_bsize) */ \
sys/ufs/ffs/fs.h
705
((blk) << (fs)->fs_bshift)
sys/vm/swap_pager.c
1018
daddr_t blk, npages;
sys/vm/swap_pager.c
1021
blk = range->start;
sys/vm/swap_pager.c
1027
if (swp_pager_isondev(blk, sp)) {
sys/vm/swap_pager.c
1035
blist_free(sp->sw_blist, blk - sp->sw_first,
sys/vm/swap_pager.c
1119
daddr_t addr, blk;
sys/vm/swap_pager.c
1128
blk = swp_pager_getswapspace(&n);
sys/vm/swap_pager.c
1129
if (blk == SWAPBLK_NONE) {
sys/vm/swap_pager.c
1136
start + i + j, blk + j, false);
sys/vm/swap_pager.c
1212
daddr_t blk, blk0;
sys/vm/swap_pager.c
1234
blk = swp_pager_meta_lookup(blks, pindex - i);
sys/vm/swap_pager.c
1235
if (blk != blk0 - i)
sys/vm/swap_pager.c
1246
blk = swp_pager_meta_lookup(blks, pindex + i);
sys/vm/swap_pager.c
1247
if (blk != blk0 + i)
sys/vm/swap_pager.c
1569
daddr_t addr, blk;
sys/vm/swap_pager.c
1601
blk = swp_pager_getswapspace(&n);
sys/vm/swap_pager.c
1602
if (blk == SWAPBLK_NONE) {
sys/vm/swap_pager.c
1620
mreq->pindex, blk + j, false);
sys/vm/swap_pager.c
1639
bp->b_blkno = blk;
sys/vm/swap_pager.c
1867
swp_pager_force_dirty(struct page_range *range, vm_page_t m, daddr_t *blk)
sys/vm/swap_pager.c
1871
swp_pager_update_freerange(range, *blk);
sys/vm/swap_pager.c
1872
*blk = SWAPBLK_NONE;
sys/vm/swap_pager.c
2273
daddr_t blk, d[SWAP_META_PAGES];
sys/vm/swap_pager.c
2296
blk = swp_pager_meta_build(&dstblks, dstobject,
sys/vm/swap_pager.c
2298
if (blk == sb->d[i]) {
sys/vm/swap_pager.c
2304
d[i] = blk;
sys/vm/swap_pager.c
2306
} else if (blk != SWAPBLK_NONE) {
sys/vm/swap_pager.c
932
daddr_t blk;
sys/vm/swap_pager.c
938
blk = SWAPBLK_NONE;
sys/vm/swap_pager.c
947
blk = blist_alloc(sp->sw_blist, &npages, mpages);
sys/vm/swap_pager.c
948
if (blk != SWAPBLK_NONE)
sys/vm/swap_pager.c
958
if (blk != SWAPBLK_NONE) {
sys/vm/swap_pager.c
960
blk += sp->sw_first;
sys/vm/swap_pager.c
974
return (blk);
sys/vm/swap_pager.c
978
swp_pager_isondev(daddr_t blk, struct swdevt *sp)
sys/vm/swap_pager.c
981
return (blk >= sp->sw_first && blk < sp->sw_end);
tests/sys/fs/fusefs/mknod.cc
145
TEST_F(Mknod, blk)
tools/tools/bootparttest/bootparttest.c
39
static int disk_strategy(void *devdata, int rw, daddr_t blk,
tools/tools/bootparttest/bootparttest.c
47
int (*dv_strategy)(void *devdata, int rw, daddr_t blk,
tools/tools/bootparttest/bootparttest.c
68
disk_strategy(void *devdata, int rw, daddr_t blk, size_t size, char *buf,
tools/tools/bootparttest/bootparttest.c
79
(long long)blk, (long long)dev->d_offset);
tools/tools/bootparttest/bootparttest.c
81
(blk + dev->d_offset) * disk.sectorsize);
usr.bin/mkimg/apm.c
54
apm_metadata(u_int where, lba_t blk)
usr.bin/mkimg/apm.c
57
blk += (where == SCHEME_META_IMG_START) ? nparts + 2 : 0;
usr.bin/mkimg/apm.c
58
return (round_block(blk));
usr.bin/mkimg/bsd.c
52
bsd_metadata(u_int where, lba_t blk)
usr.bin/mkimg/bsd.c
56
blk += BSD_BOOTBLOCK_SIZE / secsz;
usr.bin/mkimg/bsd.c
58
blk = round_cylinder(blk);
usr.bin/mkimg/bsd.c
60
blk = round_block(blk);
usr.bin/mkimg/bsd.c
61
return (blk);
usr.bin/mkimg/ebr.c
51
ebr_metadata(u_int where, lba_t blk)
usr.bin/mkimg/ebr.c
54
blk += (where == SCHEME_META_PART_BEFORE) ? 1 : 0;
usr.bin/mkimg/ebr.c
55
return (round_track(blk));
usr.bin/mkimg/gpt.c
154
gpt_metadata(u_int where, lba_t blk)
usr.bin/mkimg/gpt.c
158
blk += gpt_tblsz();
usr.bin/mkimg/gpt.c
159
blk += (where == SCHEME_META_IMG_START) ? 2 : 1;
usr.bin/mkimg/gpt.c
161
return (round_block(blk));
usr.bin/mkimg/image.c
134
image_chunk_find(lba_t blk)
usr.bin/mkimg/image.c
139
ch = (last != NULL && last->ch_block <= blk)
usr.bin/mkimg/image.c
142
if (ch->ch_block <= blk &&
usr.bin/mkimg/image.c
143
(lba_t)(ch->ch_block + (ch->ch_size / secsz)) > blk) {
usr.bin/mkimg/image.c
170
image_chunk_memory(struct chunk *ch, lba_t blk)
usr.bin/mkimg/image.c
179
if (ch->ch_block < blk) {
usr.bin/mkimg/image.c
186
ch->ch_size = (blk - ch->ch_block) * secsz;
usr.bin/mkimg/image.c
187
new->ch_block = blk;
usr.bin/mkimg/image.c
251
image_chunk_append(lba_t blk, size_t sz, off_t ofs, int fd)
usr.bin/mkimg/image.c
258
blk == (lba_t)(ch->ch_block + (ch->ch_size / secsz)) &&
usr.bin/mkimg/image.c
263
blk = ch->ch_block + (ch->ch_size / secsz);
usr.bin/mkimg/image.c
271
ch->ch_block = blk;
usr.bin/mkimg/image.c
282
image_chunk_copyin(lba_t blk, void *buf, size_t sz, off_t ofs, int fd)
usr.bin/mkimg/image.c
291
error = image_chunk_skipto(blk + 1);
usr.bin/mkimg/image.c
293
error = image_chunk_append(blk, secsz, ofs, fd);
usr.bin/mkimg/image.c
294
blk++;
usr.bin/mkimg/image.c
350
image_copyin_stream(lba_t blk, int fd, uint64_t *sizep)
usr.bin/mkimg/image.c
378
error = image_chunk_copyin(blk, &buffer[iof], rdsz, swofs,
usr.bin/mkimg/image.c
390
blk += (rdsz + secsz - 1) / secsz;
usr.bin/mkimg/image.c
399
image_copyin_mapped(lba_t blk, int fd, uint64_t *sizep)
usr.bin/mkimg/image.c
415
return (image_copyin_stream(blk, fd, sizep));
usr.bin/mkimg/image.c
450
blk += (pos - hole) / secsz;
usr.bin/mkimg/image.c
451
error = image_chunk_skipto(blk);
usr.bin/mkimg/image.c
466
error = image_chunk_copyin(blk, buf,
usr.bin/mkimg/image.c
472
blk += sz / secsz;
usr.bin/mkimg/image.c
493
image_copyin(lba_t blk, int fd, uint64_t *sizep)
usr.bin/mkimg/image.c
498
error = image_chunk_skipto(blk);
usr.bin/mkimg/image.c
501
error = image_copyin_stream(blk, fd, sizep);
usr.bin/mkimg/image.c
503
error = image_copyin_mapped(blk, fd, sizep);
usr.bin/mkimg/image.c
603
image_copyout_region(int fd, lba_t blk, lba_t size)
usr.bin/mkimg/image.c
613
ch = image_chunk_find(blk);
usr.bin/mkimg/image.c
618
ofs = (blk - ch->ch_block) * secsz;
usr.bin/mkimg/image.c
636
blk += sz / secsz;
usr.bin/mkimg/image.c
642
image_data(lba_t blk, lba_t size)
usr.bin/mkimg/image.c
648
ch = image_chunk_find(blk);
usr.bin/mkimg/image.c
654
if (lim >= blk + size)
usr.bin/mkimg/image.c
656
size -= lim - blk;
usr.bin/mkimg/image.c
657
blk = lim;
usr.bin/mkimg/image.c
670
image_set_size(lba_t blk)
usr.bin/mkimg/image.c
674
error = image_chunk_skipto(blk);
usr.bin/mkimg/image.c
676
image_size = blk;
usr.bin/mkimg/image.c
681
image_write(lba_t blk, void *buf, ssize_t len)
usr.bin/mkimg/image.c
687
ch = image_chunk_find(blk);
usr.bin/mkimg/image.c
694
ch = image_chunk_memory(ch, blk);
usr.bin/mkimg/image.c
701
blk++;
usr.bin/mkimg/image.h
36
int image_copyin(lba_t blk, int fd, uint64_t *sizep);
usr.bin/mkimg/image.h
39
int image_copyout_region(int fd, lba_t blk, lba_t size);
usr.bin/mkimg/image.h
41
int image_data(lba_t blk, lba_t size);
usr.bin/mkimg/image.h
44
int image_set_size(lba_t blk);
usr.bin/mkimg/image.h
45
int image_write(lba_t blk, void *buf, ssize_t len);
usr.bin/mkimg/mbr.c
55
mbr_metadata(u_int where, lba_t blk)
usr.bin/mkimg/mbr.c
58
blk += (where == SCHEME_META_IMG_START) ? 1 : 0;
usr.bin/mkimg/mbr.c
59
return (round_track(blk));
usr.bin/mkimg/qcow.c
138
lba_t blk, blkofs, blk_imgsz;
usr.bin/mkimg/qcow.c
224
blk = n * blk_clstrsz;
usr.bin/mkimg/qcow.c
225
if (image_data(blk, blk_clstrsz)) {
usr.bin/mkimg/qcow.c
278
blk = blkofs + (lba_t)l2idx * blk_clstrsz;
usr.bin/mkimg/qcow.c
279
if (blk >= blk_imgsz)
usr.bin/mkimg/qcow.c
281
if (image_data(blk, blk_clstrsz)) {
usr.bin/mkimg/qcow.c
315
blk = n * blk_clstrsz;
usr.bin/mkimg/qcow.c
316
if (image_data(blk, blk_clstrsz)) {
usr.bin/mkimg/qcow.c
317
error = image_copyout_region(fd, blk, blk_clstrsz);
usr.bin/mkimg/vhd.c
279
lba_t blk, blkcnt, nblks;
usr.bin/mkimg/vhd.c
314
blk = entry * blkcnt;
usr.bin/mkimg/vhd.c
315
if (image_data(blk, blkcnt)) {
usr.bin/mkimg/vhd.c
331
blk = 0;
usr.bin/mkimg/vhd.c
335
while (blk < nblks) {
usr.bin/mkimg/vhd.c
336
if (!image_data(blk, blkcnt)) {
usr.bin/mkimg/vhd.c
337
blk += blkcnt;
usr.bin/mkimg/vhd.c
345
if (blk + blkcnt > nblks)
usr.bin/mkimg/vhd.c
346
blkcnt = nblks - blk;
usr.bin/mkimg/vhd.c
347
error = image_copyout_region(fd, blk, blkcnt);
usr.bin/mkimg/vhd.c
350
blk += blkcnt;
usr.bin/tcopy/tcopy.cc
570
getspace(size_t blk)
usr.bin/tcopy/tcopy.cc
574
assert(blk > 0);
usr.bin/tcopy/tcopy.cc
575
if ((bp = malloc(blk)) == NULL)
usr.sbin/cdcontrol/cdcontrol.c
1065
play_blocks(int blk, int len)
usr.sbin/cdcontrol/cdcontrol.c
1069
t.blk = blk;
usr.sbin/cdcontrol/cdcontrol.c
142
static int play_blocks(int blk, int len);
usr.sbin/cdcontrol/cdcontrol.c
500
int blk, len = 0;
usr.sbin/cdcontrol/cdcontrol.c
502
if (2 != sscanf (arg, "#%d%d", &blk, &len) &&
usr.sbin/cdcontrol/cdcontrol.c
503
1 != sscanf (arg, "#%d", &blk))
usr.sbin/cdcontrol/cdcontrol.c
510
toc_buffer[n].addr.msf.frame) - blk;
usr.sbin/cdcontrol/cdcontrol.c
512
len = ntohl(toc_buffer[n].addr.lba) - blk;
usr.sbin/cdcontrol/cdcontrol.c
514
return play_blocks (blk, len);
usr.sbin/dumpcis/readcis.c
335
char blk[5];
usr.sbin/dumpcis/readcis.c
343
if (read(fd, blk, 5) != 5)
usr.sbin/dumpcis/readcis.c
345
if (blk[0] == CIS_LINKTARGET &&
usr.sbin/dumpcis/readcis.c
346
blk[1] == 0x3 &&
usr.sbin/dumpcis/readcis.c
347
blk[2] == 'C' &&
usr.sbin/dumpcis/readcis.c
348
blk[3] == 'I' &&
usr.sbin/dumpcis/readcis.c
349
blk[4] == 'S')
usr.sbin/makefs/ffs/ffs_alloc.c
428
int i, error, cg, blk, frags, bbase;
usr.sbin/makefs/ffs/ffs_alloc.c
470
blk = blkmap(fs, cg_blksfree_swap(cgp, needswap), bbase);
usr.sbin/makefs/ffs/ffs_alloc.c
471
ffs_fragacct_swap(fs, blk, cgp->cg_frsum, -1, needswap);
usr.sbin/makefs/ffs/ffs_alloc.c
489
blk = blkmap(fs, cg_blksfree_swap(cgp, needswap), bbase);
usr.sbin/makefs/ffs/ffs_alloc.c
490
ffs_fragacct_swap(fs, blk, cgp->cg_frsum, 1, needswap);
usr.sbin/makefs/ffs/ffs_alloc.c
531
int blk, field, subfield, pos;
usr.sbin/makefs/ffs/ffs_alloc.c
573
blk = blkmap(fs, cg_blksfree_swap(cgp, needswap), bno);
usr.sbin/makefs/ffs/ffs_alloc.c
574
blk <<= 1;
usr.sbin/makefs/ffs/ffs_alloc.c
578
if ((blk & field) == subfield)