super
exclude_supersets(struct pf_rule *super, struct pf_rule *sub)
if (super->ifname[0] == '\0')
if (super->direction == PF_INOUT)
if ((super->proto == 0 || super->proto == sub->proto) &&
super->flags == 0 && super->flagset == 0 && (sub->flags ||
sub->flags = super->flags;
sub->flagset = super->flagset;
if (super->proto == 0)
if (super->src.port_op == 0) {
if (super->dst.port_op == 0) {
if (super->src.addr.type == PF_ADDR_ADDRMASK && !super->src.neg &&
!sub->src.neg && super->src.addr.v.a.mask.addr32[0] == 0 &&
super->src.addr.v.a.mask.addr32[1] == 0 &&
super->src.addr.v.a.mask.addr32[2] == 0 &&
super->src.addr.v.a.mask.addr32[3] == 0)
else if (super->src.addr.type == PF_ADDR_ADDRMASK &&
super->src.neg == sub->src.neg &&
super->af == sub->af &&
unmask(&super->src.addr.v.a.mask, super->af) <
super->src.addr.v.a.addr.addr32[0] ==
super->src.addr.v.a.mask.addr32[0]) &&
super->src.addr.v.a.addr.addr32[1] ==
super->src.addr.v.a.mask.addr32[1]) &&
super->src.addr.v.a.addr.addr32[2] ==
super->src.addr.v.a.mask.addr32[2]) &&
super->src.addr.v.a.addr.addr32[3] ==
super->src.addr.v.a.mask.addr32[3])) {
memcpy(&sub->src.addr, &super->src.addr, sizeof(sub->src.addr));
if (super->dst.addr.type == PF_ADDR_ADDRMASK && !super->dst.neg &&
!sub->dst.neg && super->dst.addr.v.a.mask.addr32[0] == 0 &&
super->dst.addr.v.a.mask.addr32[1] == 0 &&
super->dst.addr.v.a.mask.addr32[2] == 0 &&
super->dst.addr.v.a.mask.addr32[3] == 0)
else if (super->dst.addr.type == PF_ADDR_ADDRMASK &&
super->dst.neg == sub->dst.neg &&
super->af == sub->af &&
unmask(&super->dst.addr.v.a.mask, super->af) <
super->dst.addr.v.a.addr.addr32[0] ==
super->dst.addr.v.a.mask.addr32[0]) &&
super->dst.addr.v.a.addr.addr32[1] ==
super->dst.addr.v.a.mask.addr32[1]) &&
super->dst.addr.v.a.addr.addr32[2] ==
super->dst.addr.v.a.mask.addr32[2]) &&
super->dst.addr.v.a.addr.addr32[3] ==
super->dst.addr.v.a.mask.addr32[3])) {
memcpy(&sub->dst.addr, &super->dst.addr, sizeof(sub->dst.addr));
if (super->af == 0)
inumstars = exdis(700) + rand_mod(150-super*2) + 50+super*2;
inhenergy = 30000-super*150;
inhenergy += rand_mod(3500+super*150);
obj = make_object(Star,ch,y,x,0,0,e+rand_mod(super*100+1),e/4,&root);
e = 52-super;
e + rand_mod(super*200+2) + 10000*massacre,e/4,&root);
e + rand_mod(super*200+2),e/4,&root);
super = (smarts>50?smarts-50:0);
enemshields = 10 + super/2; /* (scaled by 10) 1 @ 50 .. 3 @ 90 */
blast[y][x] += 500+super*20;
blast[y][x] += 5000+super*100;
blast[y][x] += 500+super*20;
blast[y][x] += 5000+super*100;
EXT int super;
if (massacre || madgorns || !rand_mod(53-super) )
if (massacre || rand_mod(50) < super) {
if (scandist-prob>1 && !rand_mod(51-super))
to->mass = 1000+super*20;
daddr_t super = bflag ? bflag : SBOFF / dev_bsize;
if (bread(fsreadfd, (char *)sblk.b_un.b_fs, super, (long)SBSIZE) != 0)
sblk.b_bno = super;
super *= dev_bsize;
sblk.b_bno = super / dev_bsize;
daddr_t super = 0;
super = bflag;
if (bread(fsreadfd, (char *)sblk.b_un.b_fs, super,
super = sblock_try[i] / dev_bsize;
super, (long)SBLOCKSIZE) != 0)
super *= dev_bsize;
sblk.b_bno = super / dev_bsize;
return super::create();
return super::setup();
return super::create();
return super::setup();
super::icu_dump_priority(_ipr_table);
super::dump(bit);
super::icu_dump_priority(_ipr_table);
super::dump(bit);
super::systemInfo();
if (!super::init())
if (super::setupLoader()) {
if (!super::init()) \
return super::create();
return super::setup();
super::genericPrint(_bufm);
if (!super::init())
print_batmodes(register_t super, register_t user, register_t pp)
super ? 'S' : '-', user ? 'U' : '-', accessmodes[pp]);
struct nilfs_super_block super, super2;
comp_crc = crc32_le(nilfs_rw32(nilfsdev->super.s_crc_seed),
struct nilfs_super_block *super;
nilfsdev->super.s_last_pseg = nilfsdev->super.s_first_data_block;
nilfsdev->super.s_last_cno = nilfs_rw64(1);
ri->pseg = nilfs_rw64(nilfsdev->super.s_last_pseg); /* blknr */
cno = nilfs_rw64(nilfsdev->super.s_last_cno);
super = &nilfsdev->super;
super->s_last_pseg = nilfs_rw64(ri->pseg);
super->s_last_cno = cno++;
super->s_last_seq = segsum->ss_seq;
super->s_state = nilfs_rw16(NILFS_VALID_FS);
return blocknr / nilfs_rw32(nilfsdev->super.s_blocks_per_segment);
blks_per_seg = nilfs_rw64(nilfsdev->super.s_blocks_per_segment);
*seg_start = nilfs_rw64(nilfsdev->super.s_first_data_block);
nilfs_check_superblock_crc(struct nilfs_super_block *super)
if (nilfs_rw16(super->s_magic) != NILFS_SUPER_MAGIC)
super_crc = nilfs_rw32(super->s_sum);
super->s_sum = 0;
comp_crc = crc32_le(nilfs_rw32(super->s_crc_seed),
(uint8_t *) super, nilfs_rw16(super->s_bytes));
super->s_sum = nilfs_rw32(super_crc);
struct nilfs_super_block *super, tmp_super;
super = &nilfsdev->super;
memcpy(super, (uint8_t *) bp->b_data + NILFS_SB_OFFSET_BYTES,
super = &nilfsdev->super2;
memcpy(super, (uint8_t *) bp->b_data + NILFS_SB_OFFSET_BYTES,
sb1ok = nilfs_check_superblock_crc(&nilfsdev->super);
last_cno1 = nilfs_rw64(nilfsdev->super.s_last_cno);
nilfsdev->super2 = nilfsdev->super; /* why preserve? */
nilfsdev->super = tmp_super;
log_blocksize = nilfs_rw32(nilfsdev->super.s_log_block_size);
nilfs_rw16(nilfsdev->super.s_dat_entry_size));
nilfs_rw16(nilfsdev->super.s_inode_size));
nilfsdev->mount_state = nilfs_rw16(nilfsdev->super.s_state);
last_pseg = nilfs_rw64(nilfsdev->super.s_last_pseg); /*blknr */
last_cno = nilfs_rw64(nilfsdev->super.s_last_cno);
last_seq = nilfs_rw64(nilfsdev->super.s_last_seq);
last_cno = nilfs_rw64(ump->nilfsdev->super.s_last_cno);
dlen = nilfs_rw16(ump->nilfsdev->super.s_checkpoint_size);
last_cno = nilfs_rw64(ump->nilfsdev->super.s_last_cno);
mp->mnt_dev_bshift = nilfs_rw32(nilfsdev->super.s_log_block_size) + 10;
struct bfs_super_block super;
if (!bfs->io->read(bfs->io, (uint8_t *)&super, bfs_sector))
if (!bfs_superblock_valid(&super))
bfs->data_start = super.header.data_start_byte;
bfs->data_end = super.header.data_end_byte;
bfs_superblock_valid(const struct bfs_super_block *super)
return super->header.magic == BFS_MAGIC;
for (impl = handle.impl; impl != NULL; impl = impl->super) {
const struct devhandle_impl *super,
new_impl->type = super->type;
new_impl->super = super;
const struct devhandle_impl * super;
get_inode(int fd, struct fs *super, ino_t ino)
if (!ipbuf || ino < last || ino >= last + INOCNT(super)) {
&& !(ipbuf = malloc(INOSZ(super))))
last = (ino / INOCNT(super)) * INOCNT(super);
(off_t)ino_to_fsba(super, last) << super->fs_fshift,
read(fd, ipbuf, INOSZ(super)) != (ssize_t)INOSZ(super))
if (super->fs_magic == FS_UFS1_MAGIC)
&((struct ufs1_dinode *)ipbuf)[ino % INOCNT(super)]);
&((struct ufs2_dinode *)ipbuf)[ino % INOCNT(super)]);
virtualblocks(struct fs *super, union dinode *dp)
sz = DIP(super, dp, size);
if (ffs_lblkno(super, sz) >= UFS_NDADDR) {
nblk = ffs_blkroundup(super, sz);
nblk += super->fs_bsize;
if (ffs_lblkno(super, sz) >= UFS_NDADDR) {
nblk = ffs_blkroundup(super, sz);
sz = ffs_lblkno(super, nblk);
sz = howmany(sz - UFS_NDADDR, FFS_NINDIR(super));
nblk += sz * super->fs_bsize;
sz = howmany(sz - 1, FFS_NINDIR(super));
nblk = ffs_fragroundup(super, sz);
dofsizes(int fd, struct fs *super, const char *name)
maxino = super->fs_ncg * super->fs_ipg - 1;
if ((dp = get_inode(fd, super, inode))
&& ((DIP(super, dp, mode) & IFMT) == IFREG
&& !isfree(super, dp)
sz = estimate ? virtualblocks(super, dp) :
actualblocks(super, dp);
douser(int fd, struct fs *super, const char *name)
maxino = super->fs_ncg * super->fs_ipg - 1;
if ((dp = get_inode(fd, super, inode))
&& !isfree(super, dp))
uses(DIP(super, dp, uid),
estimate ? virtualblocks(super, dp) :
actualblocks(super, dp), DIP(super, dp, atime));
donames(int fd, struct fs *super, const char *name)
maxino = super->fs_ncg * super->fs_ipg - 1;
if ((dp = get_inode(fd, super, inode))
&& !isfree(super, dp)) {
printf("%s\t", user(DIP(super, dp, uid))->name);