sbin/fsck_hammer2/test.c

104

} volume;

sbin/fsck_hammer2/test.c

121

} volume;

sbin/fsck_hammer2/test.c

631

(uintmax_t)bstats->volume.total_inode,

sbin/fsck_hammer2/test.c

632

(uintmax_t)bstats->volume.total_indirect,

sbin/fsck_hammer2/test.c

633

(uintmax_t)bstats->volume.total_data,

sbin/fsck_hammer2/test.c

634

(uintmax_t)bstats->volume.total_dirent,

sbin/fsck_hammer2/test.c

751

bstats->volume.total_inode += dstats->volume.total_inode;

sbin/fsck_hammer2/test.c

752

bstats->volume.total_indirect += dstats->volume.total_indirect;

sbin/fsck_hammer2/test.c

753

bstats->volume.total_data += dstats->volume.total_data;

sbin/fsck_hammer2/test.c

754

bstats->volume.total_dirent += dstats->volume.total_dirent;

sbin/fsck_hammer2/test.c

775

dst->volume.total_inode += src->volume.total_inode;

sbin/fsck_hammer2/test.c

776

dst->volume.total_indirect += src->volume.total_indirect;

sbin/fsck_hammer2/test.c

777

dst->volume.total_data += src->volume.total_data;

sbin/fsck_hammer2/test.c

778

dst->volume.total_dirent += src->volume.total_dirent;

sbin/fsck_hammer2/test.c

858

bstats->volume.total_inode++;

sbin/fsck_hammer2/test.c

859

dstats->volume.total_inode++;

sbin/fsck_hammer2/test.c

862

bstats->volume.total_indirect++;

sbin/fsck_hammer2/test.c

863

dstats->volume.total_indirect++;

sbin/fsck_hammer2/test.c

866

bstats->volume.total_data++;

sbin/fsck_hammer2/test.c

867

dstats->volume.total_data++;

sbin/fsck_hammer2/test.c

870

bstats->volume.total_dirent++;

sbin/fsck_hammer2/test.c

871

dstats->volume.total_dirent++;

sbin/hammer/blockmap.c

101

--volume->ondisk->vol0_stat_freebigblocks;

sbin/hammer/blockmap.c

117

volume_info_t volume;

sbin/hammer/blockmap.c

129

volume = get_root_volume();

sbin/hammer/blockmap.c

131

blockmap = &volume->ondisk->vol0_blockmap[zone];

sbin/hammer/blockmap.c

132

freemap = &volume->ondisk->vol0_blockmap[HAMMER_ZONE_FREEMAP_INDEX];

sbin/hammer/blockmap.c

180

--volume->ondisk->vol0_stat_freebigblocks;

sbin/hammer/blockmap.c

44

bootstrap_bigblock(volume_info_t volume)

sbin/hammer/blockmap.c

48

assert_volume_offset(volume);

sbin/hammer/blockmap.c

49

result_offset = volume->vol_free_off;

sbin/hammer/blockmap.c

51

volume->vol_free_off += HAMMER_BIGBLOCK_SIZE;

sbin/hammer/blockmap.c

60

alloc_undo_bigblock(volume_info_t volume)

sbin/hammer/blockmap.c

72

assert(volume->vol_no == HAMMER_ROOT_VOLNO);

sbin/hammer/blockmap.c

74

result_offset = bootstrap_bigblock(volume);

sbin/hammer/blockmap.c

75

freemap = &volume->ondisk->vol0_blockmap[HAMMER_ZONE_FREEMAP_INDEX];

sbin/hammer/cmd_blockmap.c

224

volume_info_t volume;

sbin/hammer/cmd_blockmap.c

229

volume = get_root_volume();

sbin/hammer/cmd_blockmap.c

230

node_offset = volume->ondisk->vol0_btree_root;

sbin/hammer/cmd_blockmap.c

231

freemap = &volume->ondisk->vol0_blockmap[HAMMER_ZONE_FREEMAP_INDEX];

sbin/hammer/cmd_blockmap.c

232

undomap = &volume->ondisk->vol0_blockmap[HAMMER_ZONE_UNDO_INDEX];

sbin/hammer/cmd_blockmap.c

234

print_blockmap(volume);

sbin/hammer/cmd_recover.c

126

volume_info_t volume;

sbin/hammer/cmd_recover.c

201

volume = get_volume(i);

sbin/hammer/cmd_recover.c

202

if (volume == NULL)

sbin/hammer/cmd_recover.c

206

volume->vol_no, sizetostr(volume->size));

sbin/hammer/cmd_recover.c

207

off = HAMMER_ENCODE_RAW_BUFFER(volume->vol_no, 0);

sbin/hammer/cmd_recover.c

208

off_end = off + HAMMER_VOL_BUF_SIZE(volume->ondisk);

sbin/hammer/cmd_recover.c

758

volume_info_t volume;

sbin/hammer/cmd_recover.c

771

volume = get_root_volume();

sbin/hammer/cmd_recover.c

772

rootmap = &volume->ondisk->vol0_blockmap[zone];

sbin/hammer/cmd_recover.c

824

volume_info_t volume;

sbin/hammer/cmd_recover.c

837

volume = get_root_volume();

sbin/hammer/cmd_recover.c

838

rootmap = &volume->ondisk->vol0_blockmap[zone];

sbin/hammer/cmd_show.c

101

volume_info_t volume;

sbin/hammer/cmd_show.c

1038

volume_info_t volume;

sbin/hammer/cmd_show.c

1046

volume = get_root_volume();

sbin/hammer/cmd_show.c

1047

rootmap = &volume->ondisk->vol0_blockmap[HAMMER_ZONE_UNDO_INDEX];

sbin/hammer/cmd_show.c

1049

print_blockmap(volume);

sbin/hammer/cmd_show.c

105

volume = get_root_volume();

sbin/hammer/cmd_show.c

106

ondisk = volume->ondisk;

sbin/hammer/cmd_show.c

108

print_blockmap(volume);

sbin/hammer/cmd_strip.c

115

volume = get_volume(i);

sbin/hammer/cmd_strip.c

116

if (volume) {

sbin/hammer/cmd_strip.c

117

bzero(volume->ondisk, sizeof(*volume->ondisk));

sbin/hammer/cmd_strip.c

118

memcpy(&volume->ondisk->vol_signature, "STRIPPED", 8);

sbin/hammer/cmd_strip.c

119

printf("Stripped volume header %s\n", volume->name);

sbin/hammer/cmd_strip.c

181

volume_info_t volume;

sbin/hammer/cmd_strip.c

187

volume = get_root_volume();

sbin/hammer/cmd_strip.c

189

if (volume && volume->ondisk->vol_signature == HAMMER_FSBUF_VOLUME)

sbin/hammer/cmd_strip.c

194

if (volume && volume->ondisk->vol_label[0]) {

sbin/hammer/cmd_strip.c

196

volume->ondisk->vol_label);

sbin/hammer/cmd_strip.c

44

volume_info_t volume;

sbin/hammer/cmd_strip.c

59

volume = get_root_volume();

sbin/hammer/cmd_strip.c

60

if (volume == NULL) {

sbin/hammer/cmd_strip.c

65

rootmap = &volume->ondisk->vol0_blockmap[zone];

sbin/hammer/cmd_volume.c

55

volume_info_t volume;

sbin/hammer/cmd_volume.c

76

volume = init_volume(device, O_RDONLY, -1);

sbin/hammer/cmd_volume.c

77

assert(volume->vol_no == -1);

sbin/hammer/cmd_volume.c

78

if (is_regfile(volume)) {

sbin/hammer/cmd_volume.c

82

close(volume->fd);

sbin/hammer/cmd_volume.c

89

ioc.vol_size = volume->size;

sbin/hammer/hammer.c

595

volume_info_t volume = NULL;

sbin/hammer/hammer.c

615

volume = load_volume(volname, oflags, verify_volume);

sbin/hammer/hammer.c

616

assert(volume);

sbin/hammer/hammer.c

623

assert(volume);

sbin/hammer/hammer.c

625

if (vol_count != volume->ondisk->vol_count) {

sbin/hammer/hammer.c

627

volume->ondisk->vol_count, vol_count);

sbin/hammer/hammer_util.h

107

volume_info_t volume;

sbin/hammer/hammer_util.h

130

int is_regfile(const volume_info_t volume);

sbin/hammer/hammer_util.h

131

void assert_volume_offset(const volume_info_t volume);

sbin/hammer/hammer_util.h

143

int64_t initialize_freemap(volume_info_t volume);

sbin/hammer/hammer_util.h

144

int64_t count_freemap(const volume_info_t volume);

sbin/hammer/hammer_util.h

146

void print_blockmap(const volume_info_t volume);

sbin/hammer/hammer_util.h

148

void flush_volume(volume_info_t volume);

sbin/hammer/hammer_util.h

153

hammer_off_t bootstrap_bigblock(volume_info_t volume);

sbin/hammer/hammer_util.h

154

hammer_off_t alloc_undo_bigblock(volume_info_t volume);

sbin/hammer/ondisk.c

100

err(1, "alloc_volume: Failed to open %s", volume->name);

sbin/hammer/ondisk.c

1000

return(__write(volume, volume->ondisk, 0, HAMMER_BUFSIZE));

sbin/hammer/ondisk.c

1007

return(__write(buffer->volume, buffer->ondisk, buffer->raw_offset,

sbin/hammer/ondisk.c

103

check_volume(volume);

sbin/hammer/ondisk.c

105

volume->ondisk = calloc(1, HAMMER_BUFSIZE);

sbin/hammer/ondisk.c

108

TAILQ_INIT(&volume->buffer_lists[i]);

sbin/hammer/ondisk.c

110

return(volume);

sbin/hammer/ondisk.c

115

__add_volume(const volume_info_t volume)

sbin/hammer/ondisk.c

120

if (fstat(volume->fd, &st1) != 0) {

sbin/hammer/ondisk.c

121

errx(1, "add_volume: %s: Failed to stat", volume->name);

sbin/hammer/ondisk.c

126

if (scan->vol_no == volume->vol_no) {

sbin/hammer/ondisk.c

129

volume->name, volume->vol_no, scan->name);

sbin/hammer/ondisk.c

134

volume->name, scan->name);

sbin/hammer/ondisk.c

139

volume->name);

sbin/hammer/ondisk.c

144

TAILQ_INSERT_TAIL(&VolList, volume, entry);

sbin/hammer/ondisk.c

149

__verify_volume(const volume_info_t volume)

sbin/hammer/ondisk.c

151

hammer_volume_ondisk_t ondisk = volume->ondisk;

sbin/hammer/ondisk.c

167

"this is a HAMMER volume", volume->name, fstype);

sbin/hammer/ondisk.c

173

volume->name);

sbin/hammer/ondisk.c

179

volume->name, ondisk->vol_version);

sbin/hammer/ondisk.c

190

volume_info_t volume;

sbin/hammer/ondisk.c

192

volume = __alloc_volume(filename, oflags);

sbin/hammer/ondisk.c

193

volume->vol_no = volume->ondisk->vol_no = vol_no;

sbin/hammer/ondisk.c

195

__add_volume(volume);

sbin/hammer/ondisk.c

197

return(volume);

sbin/hammer/ondisk.c

206

volume_info_t volume;

sbin/hammer/ondisk.c

209

volume = __alloc_volume(filename, oflags);

sbin/hammer/ondisk.c

211

n = readhammervol(volume);

sbin/hammer/ondisk.c

214

volume->name);

sbin/hammer/ondisk.c

217

volume->vol_no = volume->ondisk->vol_no;

sbin/hammer/ondisk.c

218

if (volume->vol_no == HAMMER_ROOT_VOLNO)

sbin/hammer/ondisk.c

219

HammerVersion = volume->ondisk->vol_version;

sbin/hammer/ondisk.c

222

Hammer_FSId = volume->ondisk->vol_fsid;

sbin/hammer/ondisk.c

224

__verify_volume(volume);

sbin/hammer/ondisk.c

226

__add_volume(volume);

sbin/hammer/ondisk.c

228

return(volume);

sbin/hammer/ondisk.c

236

check_volume(volume_info_t volume)

sbin/hammer/ondisk.c

244

if (ioctl(volume->fd, DIOCGPART, &pinfo) < 0) {

sbin/hammer/ondisk.c

245

if (fstat(volume->fd, &st) < 0) {

sbin/hammer/ondisk.c

246

err(1, "Unable to stat %s", volume->name);

sbin/hammer/ondisk.c

250

volume->size = st.st_size;

sbin/hammer/ondisk.c

251

volume->type = "REGFILE";

sbin/hammer/ondisk.c

253

errx(1, "Unsupported file type for %s", volume->name);

sbin/hammer/ondisk.c

274

volume->size = pinfo.media_size;

sbin/hammer/ondisk.c

275

volume->device_offset = pinfo.media_offset;

sbin/hammer/ondisk.c

276

volume->type = "DEVICE";

sbin/hammer/ondisk.c

281

is_regfile(const volume_info_t volume)

sbin/hammer/ondisk.c

283

return(strcmp(volume->type, "REGFILE") ? 0 : 1);

sbin/hammer/ondisk.c

287

assert_volume_offset(const volume_info_t volume)

sbin/hammer/ondisk.c

289

assert(hammer_is_zone_raw_buffer(volume->vol_free_off));

sbin/hammer/ondisk.c

290

assert(hammer_is_zone_raw_buffer(volume->vol_free_end));

sbin/hammer/ondisk.c

291

if (volume->vol_free_off >= volume->vol_free_end) {

sbin/hammer/ondisk.c

300

volume_info_t volume;

sbin/hammer/ondisk.c

302

TAILQ_FOREACH(volume, &VolList, entry) {

sbin/hammer/ondisk.c

303

if (volume->vol_no == vol_no)

sbin/hammer/ondisk.c

307

return(volume);

sbin/hammer/ondisk.c

339

volume_info_t volume;

sbin/hammer/ondisk.c

343

volume = get_volume(HAMMER_VOL_DECODE(zone2_offset));

sbin/hammer/ondisk.c

344

assert(volume != NULL);

sbin/hammer/ondisk.c

348

buffer->raw_offset = hammer_xlate_to_phys(volume->ondisk, zone2_offset);

sbin/hammer/ondisk.c

349

buffer->volume = volume;

sbin/hammer/ondisk.c

355

volume->name,

sbin/hammer/ondisk.c

363

TAILQ_INSERT_TAIL(&volume->buffer_lists[hi], buffer, entry);

sbin/hammer/ondisk.c

40

static void check_volume(volume_info_t volume);

sbin/hammer/ondisk.c

414

volume_info_t volume;

sbin/hammer/ondisk.c

42

static __inline int readhammervol(volume_info_t volume);

sbin/hammer/ondisk.c

421

volume = base->volume;

sbin/hammer/ondisk.c

424

if (raw_offset >= volume->ondisk->vol_buf_end)

sbin/hammer/ondisk.c

426

if (raw_offset < volume->ondisk->vol_buf_beg || ri == 0) {

sbin/hammer/ondisk.c

431

zone2_offset = HAMMER_ENCODE_RAW_BUFFER(volume->vol_no,

sbin/hammer/ondisk.c

432

raw_offset - volume->ondisk->vol_buf_beg);

sbin/hammer/ondisk.c

44

static __inline int writehammervol(volume_info_t volume);

sbin/hammer/ondisk.c

447

volume_info_t volume;

sbin/hammer/ondisk.c

456

volume = buffer->volume;

sbin/hammer/ondisk.c

459

TAILQ_REMOVE(&volume->buffer_lists[hi], buffer, entry);

sbin/hammer/ondisk.c

481

ondisk = (*bufferp)->volume->ondisk;

sbin/hammer/ondisk.c

606

initialize_freemap(volume_info_t volume)

sbin/hammer/ondisk.c

624

assert_volume_offset(volume);

sbin/hammer/ondisk.c

625

aligned_vol_free_end = HAMMER_BLOCKMAP_LAYER2_DOALIGN(volume->vol_free_end);

sbin/hammer/ondisk.c

627

printf("initialize freemap volume %d\n", volume->vol_no);

sbin/hammer/ondisk.c

636

for (phys_offset = HAMMER_ENCODE_RAW_BUFFER(volume->vol_no, 0);

sbin/hammer/ondisk.c

643

layer1->phys_offset = bootstrap_bigblock(volume);

sbin/hammer/ondisk.c

653

for (phys_offset = HAMMER_ENCODE_RAW_BUFFER(volume->vol_no, 0);

sbin/hammer/ondisk.c

670

if (phys_offset + block_offset < volume->vol_free_off) {

sbin/hammer/ondisk.c

678

} else if (phys_offset + block_offset < volume->vol_free_end) {

sbin/hammer/ondisk.c

708

count_freemap(const volume_info_t volume)

sbin/hammer/ondisk.c

715

vol_free_off = HAMMER_ENCODE_RAW_BUFFER(volume->vol_no, 0);

sbin/hammer/ondisk.c

717

assert_volume_offset(volume);

sbin/hammer/ondisk.c

718

aligned_vol_free_end = HAMMER_BLOCKMAP_LAYER2_DOALIGN(volume->vol_free_end);

sbin/hammer/ondisk.c

72

volume_info_t volume;

sbin/hammer/ondisk.c

720

if (volume->vol_no == HAMMER_ROOT_VOLNO)

sbin/hammer/ondisk.c

723

for (phys_offset = HAMMER_ENCODE_RAW_BUFFER(volume->vol_no, 0);

sbin/hammer/ondisk.c

729

for (phys_offset = HAMMER_ENCODE_RAW_BUFFER(volume->vol_no, 0);

sbin/hammer/ondisk.c

734

else if (phys_offset < volume->vol_free_end)

sbin/hammer/ondisk.c

76

volume = get_volume(HAMMER_VOL_DECODE(zone2_offset));

sbin/hammer/ondisk.c

77

assert(volume);

sbin/hammer/ondisk.c

80

TAILQ_FOREACH(buffer, &volume->buffer_lists[hi], entry) {

sbin/hammer/ondisk.c

857

print_blockmap(const volume_info_t volume)

sbin/hammer/ondisk.c

860

hammer_volume_ondisk_t ondisk = volume->ondisk;

sbin/hammer/ondisk.c

91

volume_info_t volume;

sbin/hammer/ondisk.c

916

volume_info_t volume;

sbin/hammer/ondisk.c

918

TAILQ_FOREACH(volume, &VolList, entry)

sbin/hammer/ondisk.c

919

flush_volume(volume);

sbin/hammer/ondisk.c

923

flush_volume(volume_info_t volume)

sbin/hammer/ondisk.c

929

TAILQ_FOREACH(buffer, &volume->buffer_lists[i], entry)

sbin/hammer/ondisk.c

932

if (writehammervol(volume) == -1) {

sbin/hammer/ondisk.c

933

err(1, "Write volume %d (%s)", volume->vol_no, volume->name);

sbin/hammer/ondisk.c

94

volume = calloc(1, sizeof(*volume));

sbin/hammer/ondisk.c

941

volume_info_t volume;

sbin/hammer/ondisk.c

943

volume = buffer->volume;

sbin/hammer/ondisk.c

945

err(1, "Write volume %d (%s)", volume->vol_no, volume->name);

sbin/hammer/ondisk.c

95

volume->vol_no = -1;

sbin/hammer/ondisk.c

956

__read(volume_info_t volume, void *data, int64_t offset, int size)

sbin/hammer/ondisk.c

96

volume->rdonly = (oflags == O_RDONLY);

sbin/hammer/ondisk.c

960

n = pread(volume->fd, data, size, offset);

sbin/hammer/ondisk.c

968

readhammervol(volume_info_t volume)

sbin/hammer/ondisk.c

97

volume->name = strdup(volname);

sbin/hammer/ondisk.c

970

return(__read(volume, volume->ondisk, 0, HAMMER_BUFSIZE));

sbin/hammer/ondisk.c

977

return(__read(buffer->volume, buffer->ondisk, buffer->raw_offset,

sbin/hammer/ondisk.c

98

volume->fd = open(volume->name, oflags);

sbin/hammer/ondisk.c

983

__write(volume_info_t volume, const void *data, int64_t offset, int size)

sbin/hammer/ondisk.c

987

if (volume->rdonly)

sbin/hammer/ondisk.c

99

if (volume->fd < 0) {

sbin/hammer/ondisk.c

990

n = pwrite(volume->fd, data, size, offset);

sbin/hammer/ondisk.c

998

writehammervol(volume_info_t volume)

sbin/mount_hammer2/mount_hammer2.c

178

info.volume = devpath;

sbin/mount_hammer2/mount_hammer2.c

185

info.volume, mountpt);

sbin/mount_hammer2/mount_hammer2.c

188

info.volume);

sbin/mount_hammer2/mount_hammer2.c

192

info.volume);

sbin/mount_hammer2/mount_hammer2.c

216

cluster_connect(const char *volume __unused)

sbin/mount_hammer2/mount_hammer2.c

50

static int cluster_connect(const char *volume);

sbin/newfs_hammer/newfs_hammer.c

191

volume = init_volume(av[i], O_RDWR, i);

sbin/newfs_hammer/newfs_hammer.c

193

volume->vol_no, volume->type, volume->name,

sbin/newfs_hammer/newfs_hammer.c

194

sizetostr(volume->size));

sbin/newfs_hammer/newfs_hammer.c

197

if (trim_volume(volume) == -1 && ForceOpt == 0) {

sbin/newfs_hammer/newfs_hammer.c

202

total += volume->size;

sbin/newfs_hammer/newfs_hammer.c

244

print_volume(const volume_info_t volume)

sbin/newfs_hammer/newfs_hammer.c

253

ondisk = volume->ondisk;

sbin/newfs_hammer/newfs_hammer.c

284

sizetostr(HAMMER_OFF_SHORT_ENCODE(volume->vol_free_off)));

sbin/newfs_hammer/newfs_hammer.c

42

static int trim_volume(volume_info_t volume);

sbin/newfs_hammer/newfs_hammer.c

43

static void format_volume(volume_info_t volume, int nvols,const char *label);

sbin/newfs_hammer/newfs_hammer.c

46

static void print_volume(const volume_info_t volume);

sbin/newfs_hammer/newfs_hammer.c

490

trim_volume(volume_info_t volume)

sbin/newfs_hammer/newfs_hammer.c

498

if (is_regfile(volume)) {

sbin/newfs_hammer/newfs_hammer.c

499

hwarnx("Cannot TRIM regular file %s", volume->name);

sbin/newfs_hammer/newfs_hammer.c

502

if (strncmp(volume->name, "/dev/da", 7)) {

sbin/newfs_hammer/newfs_hammer.c

503

hwarnx("%s does not support the TRIM command", volume->name);

sbin/newfs_hammer/newfs_hammer.c

508

dev_name = strdup(volume->name);

sbin/newfs_hammer/newfs_hammer.c

518

volume->name, sysctl_name);

sbin/newfs_hammer/newfs_hammer.c

527

ioarg[0] = volume->device_offset;

sbin/newfs_hammer/newfs_hammer.c

528

ioarg[1] = volume->size;

sbin/newfs_hammer/newfs_hammer.c

531

volume->type, volume->name,

sbin/newfs_hammer/newfs_hammer.c

535

if (ioctl(volume->fd, DAIOCTRIM, ioarg) == -1) {

sbin/newfs_hammer/newfs_hammer.c

536

err(1, "Trimming %s failed", volume->name);

sbin/newfs_hammer/newfs_hammer.c

548

format_volume(volume_info_t volume, int nvols, const char *label)

sbin/newfs_hammer/newfs_hammer.c

561

ondisk = volume->ondisk;

sbin/newfs_hammer/newfs_hammer.c

566

ondisk->vol_no = volume->vol_no;

sbin/newfs_hammer/newfs_hammer.c

580

ondisk->vol_buf_end = volume->size & ~(int64_t)HAMMER_BUFMASK;

sbin/newfs_hammer/newfs_hammer.c

585

volume->vol_no, volume->name);

sbin/newfs_hammer/newfs_hammer.c

589

errx(1, "volume %d %s is too large", volume->vol_no, volume->name);

sbin/newfs_hammer/newfs_hammer.c

596

volume->vol_free_off = HAMMER_ENCODE_RAW_BUFFER(volume->vol_no, 0);

sbin/newfs_hammer/newfs_hammer.c

597

volume->vol_free_end = HAMMER_ENCODE_RAW_BUFFER(volume->vol_no,

sbin/newfs_hammer/newfs_hammer.c

603

if (volume->vol_no == HAMMER_ROOT_VOLNO) {

sbin/newfs_hammer/newfs_hammer.c

607

freeblks = count_freemap(volume);

sbin/newfs_hammer/newfs_hammer.c

627

format_freemap(volume);

sbin/newfs_hammer/newfs_hammer.c

629

ondisk->vol0_stat_freebigblocks = initialize_freemap(volume);

sbin/newfs_hammer/newfs_hammer.c

636

format_blockmap(volume, i, 0);

sbin/newfs_hammer/newfs_hammer.c

644

format_undomap(volume, &UndoBufferSize);

sbin/newfs_hammer/newfs_hammer.c

656

freeblks = initialize_freemap(volume);

sbin/newfs_hammer/newfs_hammer.c

71

volume_info_t volume;

sbin/vinum/commands.c

1011

struct volume;

sbin/vinum/commands.c

2308

struct volume vol;

sbin/vinum/commands.c

803

struct volume vol;

sbin/vinum/list.c

1071

struct volume vol;

sbin/vinum/v.c

479

get_volume_info(struct volume *volume, int index)

sbin/vinum/v.c

481

*(int *) volume = index; /* put in volume to hand to driver */

sbin/vinum/v.c

482

if (ioctl(superdev, VINUM_VOLCONFIG, volume) < 0) {

sbin/vinum/v.c

92

struct volume vol;

sbin/vinum/vext.h

132

void get_volume_info(struct volume *volume, int index);

sbin/vinum/vext.h

161

extern struct volume vol;

sbin/vinum/vinumparser.c

78

keypair(volume),

sys/bus/cam/scsi/scsi_cd.c

2477

page->audio.port[LEFT_PORT].volume;

sys/bus/cam/scsi/scsi_cd.c

2479

page->audio.port[RIGHT_PORT].volume;

sys/bus/cam/scsi/scsi_cd.c

2480

arg->vol[2] = page->audio.port[2].volume;

sys/bus/cam/scsi/scsi_cd.c

2481

arg->vol[3] = page->audio.port[3].volume;

sys/bus/cam/scsi/scsi_cd.c

2509

page->audio.port[LEFT_PORT].volume =

sys/bus/cam/scsi/scsi_cd.c

2512

page->audio.port[RIGHT_PORT].volume =

sys/bus/cam/scsi/scsi_cd.c

2514

page->audio.port[2].volume = arg->vol[2];

sys/bus/cam/scsi/scsi_cd.c

2515

page->audio.port[3].volume = arg->vol[3];

sys/bus/cam/scsi/scsi_cd.h

684

u_int8_t volume;

sys/dev/disk/mpt/mpt.h

479

struct mpt_raid_volume *volume;

sys/dev/disk/mpt/mpt_raid.c

1310

mpt_disk->volume = mpt_vol;

sys/dev/disk/mpt/mpt_raid.c

212

if (disk->volume != NULL) {

sys/dev/disk/mpt/mpt_raid.c

215

disk->volume->config_page->VolumeID,

sys/dev/disk/mpt/mpt_raid.c

770

rv = mpt_issue_raid_req(mpt, mpt_disk->volume, mpt_disk, req,

sys/dev/disk/nata/ata-raid.c

1057

if (ars->raid[rdp->volume]) {

sys/dev/disk/nata/ata-raid.c

1270

ars->raid[rdp->volume] = rdp;

sys/dev/disk/nata/ata-raid.c

1271

ars->disk_number[rdp->volume] = disk;

sys/dev/disk/nata/ata-raid.c

1300

if (ars->raid[rdp->volume] != rdp) /* XXX SOS */

sys/dev/disk/nata/ata-raid.c

1302

if (ars->disk_number[rdp->volume] != disk) /* XXX SOS */

sys/dev/disk/nata/ata-raid.c

1304

ars->raid[rdp->volume] = NULL;

sys/dev/disk/nata/ata-raid.c

1305

ars->disk_number[rdp->volume] = -1;

sys/dev/disk/nata/ata-raid.c

1343

if (ars->raid[rdp->volume])

sys/dev/disk/nata/ata-raid.c

1347

ars->raid[rdp->volume] = rdp;

sys/dev/disk/nata/ata-raid.c

1348

ars->disk_number[rdp->volume] = disk;

sys/dev/disk/nata/ata-raid.c

1734

ars->raid[raid->volume] = raid;

sys/dev/disk/nata/ata-raid.c

1735

ars->disk_number[raid->volume] = disk_number;

sys/dev/disk/nata/ata-raid.c

1885

ars->raid[raid->volume] = raid;

sys/dev/disk/nata/ata-raid.c

1886

ars->disk_number[raid->volume] = disk_number;

sys/dev/disk/nata/ata-raid.c

2108

ars->raid[raid->volume] = raid;

sys/dev/disk/nata/ata-raid.c

2109

ars->disk_number[raid->volume] = disk_number;

sys/dev/disk/nata/ata-raid.c

2129

int array, count, disk, volume = 1, retval = 0;

sys/dev/disk/nata/ata-raid.c

2238

raid->volume = volume - 1;

sys/dev/disk/nata/ata-raid.c

2280

ars->raid[raid->volume] = raid;

sys/dev/disk/nata/ata-raid.c

2281

ars->disk_number[raid->volume] = disk;

sys/dev/disk/nata/ata-raid.c

2290

if (volume < meta->total_volumes) {

sys/dev/disk/nata/ata-raid.c

2293

volume++;

sys/dev/disk/nata/ata-raid.c

2302

if (volume == 2)

sys/dev/disk/nata/ata-raid.c

2541

ars->raid[raid->volume] = raid;

sys/dev/disk/nata/ata-raid.c

2542

ars->disk_number[raid->volume] = disk_number;

sys/dev/disk/nata/ata-raid.c

2674

ars->raid[raid->volume] = raid;

sys/dev/disk/nata/ata-raid.c

2675

ars->disk_number[raid->volume] = disk;

sys/dev/disk/nata/ata-raid.c

2871

ars->raid[raid->volume] = raid;

sys/dev/disk/nata/ata-raid.c

2872

ars->disk_number[raid->volume] = meta->disk_number;

sys/dev/disk/nata/ata-raid.c

3005

ars->raid[raid->volume] = raid;

sys/dev/disk/nata/ata-raid.c

3006

ars->disk_number[raid->volume] = disk_number;

sys/dev/disk/nata/ata-raid.c

3126

ars->raid[raid->volume] = raid;

sys/dev/disk/nata/ata-raid.c

3127

ars->disk_number[raid->volume] = meta->disk_number;

sys/dev/disk/nata/ata-raid.c

3304

ars->raid[raid->volume] = raid;

sys/dev/disk/nata/ata-raid.c

3305

ars->disk_number[raid->volume] = disk_number;

sys/dev/disk/nata/ata-raid.c

3597

ars->raid[raid->volume] = raid;

sys/dev/disk/nata/ata-raid.c

3598

ars->disk_number[raid->volume] = disk_number;

sys/dev/disk/nata/ata-raid.c

3712

ars->raid[raid->volume] = raid;

sys/dev/disk/nata/ata-raid.c

3713

ars->disk_number[raid->volume] = disk_number;

sys/dev/disk/nata/ata-raid.c

3922

ars->raid[raid->volume] = raid;

sys/dev/disk/nata/ata-raid.c

3923

ars->disk_number[raid->volume] = disk;

sys/dev/disk/nata/ata-raid.c

4155

int volume;

sys/dev/disk/nata/ata-raid.c

4157

for (volume = 0; volume < MAX_VOLUMES; volume++) {

sys/dev/disk/nata/ata-raid.c

4158

ars->raid[volume] = NULL;

sys/dev/disk/nata/ata-raid.c

4159

ars->disk_number[volume] = -1;

sys/dev/disk/nata/ata-raid.c

4169

int volume;

sys/dev/disk/nata/ata-raid.c

4171

for (volume = 0; volume < MAX_VOLUMES; volume++) {

sys/dev/disk/nata/ata-raid.c

4172

if (ars->raid[volume]) {

sys/dev/disk/nata/ata-raid.c

4173

ars->raid[volume]->disks[ars->disk_number[volume]].flags &=

sys/dev/disk/nata/ata-raid.c

4175

ars->raid[volume]->disks[ars->disk_number[volume]].dev = NULL;

sys/dev/disk/nata/ata-raid.c

4177

if (mtx_initialized(&ars->raid[volume]->lock))

sys/dev/disk/nata/ata-raid.c

4179

ata_raid_config_changed(ars->raid[volume], 1);

sys/dev/disk/nata/ata-raid.c

4180

ars->raid[volume] = NULL;

sys/dev/disk/nata/ata-raid.c

4181

ars->disk_number[volume] = -1;

sys/dev/disk/nata/ata-raid.h

53

int volume;

sys/dev/disk/nata/atapi-cd.c

601

arg->vol[0] = cdp->au.port[0].volume;

sys/dev/disk/nata/atapi-cd.c

602

arg->vol[1] = cdp->au.port[1].volume;

sys/dev/disk/nata/atapi-cd.c

603

arg->vol[2] = cdp->au.port[2].volume;

sys/dev/disk/nata/atapi-cd.c

604

arg->vol[3] = cdp->au.port[3].volume;

sys/dev/disk/nata/atapi-cd.c

626

cdp->au.port[0].volume = arg->vol[0] & cdp->aumask.port[0].volume;

sys/dev/disk/nata/atapi-cd.c

627

cdp->au.port[1].volume = arg->vol[1] & cdp->aumask.port[1].volume;

sys/dev/disk/nata/atapi-cd.c

628

cdp->au.port[2].volume = arg->vol[2] & cdp->aumask.port[2].volume;

sys/dev/disk/nata/atapi-cd.c

629

cdp->au.port[3].volume = arg->vol[3] & cdp->aumask.port[3].volume;

sys/dev/disk/nata/atapi-cd.h

77

u_int8_t volume;

sys/dev/raid/vinum/vinum.c

149

vol = &vinum_conf.volume[i];

sys/dev/raid/vinum/vinum.c

248

struct volume *vol = &vinum_conf.volume[i];

sys/dev/raid/vinum/vinum.c

274

VOL = (struct volume *) Malloc(sizeof(struct volume) * INITIAL_VOLUMES);

sys/dev/raid/vinum/vinum.c

276

bzero(VOL, sizeof(struct volume) * INITIAL_VOLUMES);

sys/dev/raid/vinum/vinum.c

377

struct volume *vol;

sys/dev/raid/vinum/vinum.c

484

struct volume *vol;

sys/dev/raid/vinum/vinum.c

562

struct volume *vol;

sys/dev/raid/vinum/vinum.c

93

struct volume *vol;

sys/dev/raid/vinum/vinumconfig.c

1332

struct volume *vol; /* for tidying up dangling references */

sys/dev/raid/vinum/vinumconfig.c

1488

struct volume *vol; /* collect volume info here */

sys/dev/raid/vinum/vinumconfig.c

155

struct volume *vol;

sys/dev/raid/vinum/vinumconfig.c

1838

struct volume *vol = &VOL[plex->volno];

sys/dev/raid/vinum/vinumconfig.c

185

struct volume *vol;

sys/dev/raid/vinum/vinumconfig.c

1868

struct volume *vol = &VOL[volno];

sys/dev/raid/vinum/vinumconfig.c

1915

struct volume *vol;

sys/dev/raid/vinum/vinumconfig.c

2027

struct volume *vol = &VOL[volno];

sys/dev/raid/vinum/vinumconfig.c

74

static void made_vol(struct volume *vol);

sys/dev/raid/vinum/vinumconfig.c

760

made_vol(struct volume *vol)

sys/dev/raid/vinum/vinumconfig.c

879

struct volume *vol;

sys/dev/raid/vinum/vinumconfig.c

889

EXPAND(VOL, struct volume, vinum_conf.volumes_allocated, INITIAL_VOLUMES);

sys/dev/raid/vinum/vinumconfig.c

893

bzero(vol, sizeof(struct volume));

sys/dev/raid/vinum/vinumconfig.c

911

struct volume *vol;

sys/dev/raid/vinum/vinumconfig.c

937

struct volume *vol;

sys/dev/raid/vinum/vinumconfig.c

942

bzero(vol, sizeof(struct volume)); /* and clear it out */

sys/dev/raid/vinum/vinumext.h

221

struct volume *validvol(int volno, struct _ioctl_reply *);

sys/dev/raid/vinum/vinumext.h

232

int lockvol(struct volume *vol);

sys/dev/raid/vinum/vinumext.h

233

void unlockvol(struct volume *vol);

sys/dev/raid/vinum/vinumext.h

75

int volume_index(struct volume *volume);

sys/dev/raid/vinum/vinumio.c

434

struct volume *vol;

sys/dev/raid/vinum/vinumio.c

436

vol = &vinum_conf.volume[i];

sys/dev/raid/vinum/vinumio.c

484

vinum_conf.volume[plex->volno].name);

sys/dev/raid/vinum/vinumio.h

131

#define VINUM_VOLCONFIG _IOWR(L, 69, struct volume)

sys/dev/raid/vinum/vinumioctl.c

165

bcopy(&VOL[index], data, sizeof(struct volume));

sys/dev/raid/vinum/vinumioctl.c

414

struct volume *

sys/dev/raid/vinum/vinumioctl.c

485

struct volume *vol = &VOL[msg->index];

sys/dev/raid/vinum/vinumioctl.c

512

struct volume *vol;

sys/dev/raid/vinum/vinumioctl.c

591

struct volume *vol;

sys/dev/raid/vinum/vinumioctl.c

729

struct volume *vol;

sys/dev/raid/vinum/vinumioctl.c

74

struct volume *vol;

sys/dev/raid/vinum/vinumparser.c

90

keypair(volume),

sys/dev/raid/vinum/vinumrequest.c

1000

vinum_bounds_check(struct bio *bio, struct volume *vol)

sys/dev/raid/vinum/vinumrequest.c

131

struct volume *vol = NULL;

sys/dev/raid/vinum/vinumrequest.c

195

struct volume *vol;

sys/dev/raid/vinum/vinumrequest.c

65

struct bio *vinum_bounds_check(struct bio *bio, struct volume *vol);

sys/dev/raid/vinum/vinumrequest.c

693

struct volume *vol; /* volume in question */

sys/dev/raid/vinum/vinumrequest.c

770

struct volume *vol; /* volume in question */

sys/dev/raid/vinum/vinumrevive.c

61

struct volume *vol;

sys/dev/raid/vinum/vinumstate.c

108

struct volume *vol;

sys/dev/raid/vinum/vinumstate.c

397

struct volume *vol = &VOL[volno]; /* point to our volume */

sys/dev/raid/vinum/vinumstate.c

519

struct volume *vol = &VOL[plex->volno]; /* possible volume to which it points */

sys/dev/raid/vinum/vinumstate.c

581

struct volume *vol; /* our volume */

sys/dev/raid/vinum/vinumstate.c

777

struct volume *vol;

sys/dev/raid/vinum/vinumvar.h

226

unsigned volume:8; /* up to 256 volumes */

sys/dev/raid/vinum/vinumvar.h

321

struct volume *volume;

sys/dev/raid/vinum/vinumvar.h

351

#define VOL vinum_conf.volume

sys/dev/sound/pci/emu10kx.c

2634

emumix_set_volume(struct emu_sc_info *sc, int mixer_idx, int volume)

sys/dev/sound/pci/emu10kx.c

2637

RANGE(volume, 0, 100);

sys/dev/sound/pci/emu10kx.c

2639

sc->mixer_volcache[mixer_idx] = volume;

sys/dev/sound/pci/emu10kx.c

2640

emumix_set_fxvol(sc, sc->mixer_gpr[mixer_idx], volume);

sys/dev/sound/pci/emu10kx.h

186

void emumix_set_volume(struct emu_sc_info *sc, int mixer_idx, int volume);

sys/dev/sound/pcm/channel.c

1266

c->volume[SND_VOL_C_MASTER][i] = SND_VOL_0DB_MASTER;

sys/dev/sound/pcm/channel.c

1269

c->volume[SND_VOL_C_MASTER][SND_CHN_T_VOL_0DB] = SND_VOL_0DB_MASTER;

sys/dev/sound/pcm/channel.c

1270

c->volume[SND_VOL_C_PCM][SND_CHN_T_VOL_0DB] = chn_vol_0db_pcm;

sys/dev/sound/pcm/channel.c

1404

c->volume[vc][vt] = val;

sys/dev/sound/pcm/channel.c

1413

c->volume[SND_VOL_C_VAL(vc)][vt] =

sys/dev/sound/pcm/channel.c

1414

SND_VOL_CALC_VAL(c->volume, vc, vt);

sys/dev/sound/pcm/channel.c

1419

c->volume[SND_VOL_C_VAL(vc)][i] =

sys/dev/sound/pcm/channel.c

1420

SND_VOL_CALC_VAL(c->volume, vc, i);

sys/dev/sound/pcm/channel.c

1423

c->volume[SND_VOL_C_VAL(vc)][vt] =

sys/dev/sound/pcm/channel.c

1424

SND_VOL_CALC_VAL(c->volume, vc, vt);

sys/dev/sound/pcm/channel.c

1440

return (c->volume[vc][vt]);

sys/dev/sound/pcm/channel.c

1571

CHN_SETVOLUME(c, vc, i, c->volume[vc][SND_CHN_T_VOL_0DB]);

sys/dev/sound/pcm/channel.h

167

int volume[SND_VOL_C_MAX][SND_CHN_T_VOL_MAX];

sys/dev/sound/pcm/channel.h

305

#define CHN_GETVOLUME(x, y, z) ((x)->volume[y][z])

sys/dev/sound/pcm/feeder_chain.c

790

FEEDER_BUILD(volume);

sys/dev/sound/pcm/feeder_chain.c

796

FEEDER_BUILD(volume);

sys/dev/sound/pcm/feeder_chain.c

810

FEEDER_BUILD(volume);

sys/dev/sound/pcm/feeder_chain.c

818

FEEDER_BUILD(volume);

sys/dev/sound/pcm/feeder_volume.c

251

vol = c->volume[SND_VOL_C_VAL(info->volume_class)];

sys/dev/video/cxm/cxm_msp34xxx.c

401

unsigned char volume[2];

sys/dev/video/cxm/cxm_msp34xxx.c

404

0x0000, volume, sizeof(volume)) != sizeof(volume))

sys/dev/video/cxm/cxm_msp34xxx.c

407

return volume[0] == 0x00 || volume[0] == 0xff ? 1 : 0;

sys/sys/soundcard.h

449

int volume;

sys/vfs/hammer/hammer.h

1170

int hammer_ref_volume(hammer_volume_t volume);

sys/vfs/hammer/hammer.h

1174

void hammer_rel_volume(hammer_volume_t volume, int locked);

sys/vfs/hammer/hammer.h

1302

void hammer_io_init(hammer_io_t io, hammer_volume_t volume,

sys/vfs/hammer/hammer.h

1308

int hammer_io_inval(hammer_volume_t volume, hammer_off_t zone2_offset);

sys/vfs/hammer/hammer.h

1332

void hammer_modify_volume(hammer_transaction_t trans, hammer_volume_t volume,

sys/vfs/hammer/hammer.h

1336

void hammer_modify_volume_done(hammer_volume_t volume);

sys/vfs/hammer/hammer.h

1425

hammer_modify_volume_noundo(hammer_transaction_t trans, hammer_volume_t volume)

sys/vfs/hammer/hammer.h

1427

hammer_modify_volume(trans, volume, NULL, 0);

sys/vfs/hammer/hammer.h

600

struct hammer_volume *volume;

sys/vfs/hammer/hammer.h

996

int hammer_unload_volume(hammer_volume_t volume, void *data);

sys/vfs/hammer/hammer.h

997

int hammer_adjust_volume_mode(hammer_volume_t volume, void *data __unused);

sys/vfs/hammer/hammer_btree.c

1613

hammer_volume_t volume;

sys/vfs/hammer/hammer_btree.c

1615

volume = hammer_get_root_volume(hmp, &error);

sys/vfs/hammer/hammer_btree.c

1618

hammer_modify_volume_field(cursor->trans, volume,

sys/vfs/hammer/hammer_btree.c

1620

volume->ondisk->vol0_btree_root = parent->node_offset;

sys/vfs/hammer/hammer_btree.c

1621

hammer_modify_volume_done(volume);

sys/vfs/hammer/hammer_btree.c

1628

hammer_rel_volume(volume, 0);

sys/vfs/hammer/hammer_btree.c

1855

hammer_volume_t volume;

sys/vfs/hammer/hammer_btree.c

1857

volume = hammer_get_root_volume(hmp, &error);

sys/vfs/hammer/hammer_btree.c

1860

hammer_modify_volume_field(cursor->trans, volume,

sys/vfs/hammer/hammer_btree.c

1862

volume->ondisk->vol0_btree_root = parent->node_offset;

sys/vfs/hammer/hammer_btree.c

1863

hammer_modify_volume_done(volume);

sys/vfs/hammer/hammer_btree.c

1870

hammer_rel_volume(volume, 0);

sys/vfs/hammer/hammer_cursor.c

157

volume = hammer_get_root_volume(hmp, &error);

sys/vfs/hammer/hammer_cursor.c

160

node = hammer_get_node(trans, volume->ondisk->vol0_btree_root,

sys/vfs/hammer/hammer_cursor.c

162

hammer_rel_volume(volume, 0);

sys/vfs/hammer/hammer_cursor.c

188

if (volume->ondisk->vol0_btree_root != node->node_offset) {

sys/vfs/hammer/hammer_cursor.c

50

hammer_volume_t volume;

sys/vfs/hammer/hammer_disk.h

818

#define hammer_xlate_to_phys(volume, zone2_offset) \

sys/vfs/hammer/hammer_disk.h

819

((volume)->vol_buf_beg + HAMMER_OFF_SHORT_ENCODE(zone2_offset))

sys/vfs/hammer/hammer_disk.h

827

#define hammer_xlate_to_undo(volume, zone3_offset) \

sys/vfs/hammer/hammer_disk.h

828

((volume)->vol0_undo_array[HAMMER_UNDO_INDEX(zone3_offset)] + \

sys/vfs/hammer/hammer_disk.h

834

#define HAMMER_VOL_BUF_SIZE(volume) \

sys/vfs/hammer/hammer_disk.h

835

((volume)->vol_buf_end - (volume)->vol_buf_beg)

sys/vfs/hammer/hammer_io.c

1082

io->volume->vol_no, io->offset);

sys/vfs/hammer/hammer_io.c

1262

io->volume->vol_no, io->offset);

sys/vfs/hammer/hammer_io.c

1455

hammer_volume_t volume;

sys/vfs/hammer/hammer_io.c

1487

volume = hammer_get_volume(hmp, vol_no, &error);

sys/vfs/hammer/hammer_io.c

1488

if (error == 0 && zone2_offset >= volume->maxbuf_off)

sys/vfs/hammer/hammer_io.c

1496

nbio->bio_offset = hammer_xlate_to_phys(volume->ondisk,

sys/vfs/hammer/hammer_io.c

1499

vn_strategy(volume->devvp, nbio);

sys/vfs/hammer/hammer_io.c

1501

hammer_rel_volume(volume, 0);

sys/vfs/hammer/hammer_io.c

1530

hammer_volume_t volume;

sys/vfs/hammer/hammer_io.c

1561

volume = hammer_get_volume(hmp, vol_no, &error);

sys/vfs/hammer/hammer_io.c

1562

if (error == 0 && zone2_offset >= volume->maxbuf_off)

sys/vfs/hammer/hammer_io.c

1573

buf_offset = hammer_xlate_to_phys(volume->ondisk, zone2_offset);

sys/vfs/hammer/hammer_io.c

1587

cluster_readcb(volume->devvp, limit, buf_offset,

sys/vfs/hammer/hammer_io.c

1595

breadcb(volume->devvp, buf_offset, bp->b_bufsize,

sys/vfs/hammer/hammer_io.c

1600

hammer_rel_volume(volume, 0);

sys/vfs/hammer/hammer_io.c

1699

hammer_volume_t volume;

sys/vfs/hammer/hammer_io.c

1726

volume = hammer_get_volume(hmp, vol_no, &error);

sys/vfs/hammer/hammer_io.c

1728

if (error == 0 && zone2_offset >= volume->maxbuf_off)

sys/vfs/hammer/hammer_io.c

1753

nbio->bio_offset = hammer_xlate_to_phys(volume->ondisk,

sys/vfs/hammer/hammer_io.c

1757

vn_strategy(volume->devvp, nbio);

sys/vfs/hammer/hammer_io.c

1758

hammer_io_flush_mark(volume);

sys/vfs/hammer/hammer_io.c

1760

hammer_rel_volume(volume, 0);

sys/vfs/hammer/hammer_io.c

1976

hammer_io_flush_mark(hammer_volume_t volume)

sys/vfs/hammer/hammer_io.c

1978

atomic_set_int(&volume->vol_flags, HAMMER_VOLF_NEEDFLUSH);

sys/vfs/hammer/hammer_io.c

1987

hammer_volume_t volume;

sys/vfs/hammer/hammer_io.c

1991

RB_FOREACH(volume, hammer_vol_rb_tree, &hmp->rb_vols_root) {

sys/vfs/hammer/hammer_io.c

1992

if (volume->vol_flags & HAMMER_VOLF_NEEDFLUSH) {

sys/vfs/hammer/hammer_io.c

1993

atomic_clear_int(&volume->vol_flags,

sys/vfs/hammer/hammer_io.c

2004

vn_strategy(volume->devvp, &bp->b_bio1);

sys/vfs/hammer/hammer_io.c

489

hammer_io_inval(hammer_volume_t volume, hammer_off_t zone2_offset)

sys/vfs/hammer/hammer_io.c

497

hmp = volume->io.hmp;

sys/vfs/hammer/hammer_io.c

505

phys_offset = hammer_xlate_to_phys(volume->ondisk, zone2_offset);

sys/vfs/hammer/hammer_io.c

506

if ((bp = findblk(volume->devvp, phys_offset, 0)) != NULL)

sys/vfs/hammer/hammer_io.c

509

bp = getblk(volume->devvp, phys_offset, HAMMER_BUFSIZE, 0, 0);

sys/vfs/hammer/hammer_io.c

61

static __inline void hammer_io_flush_mark(hammer_volume_t volume);

sys/vfs/hammer/hammer_io.c

74

io1_offset = HAMMER_ENCODE(0, io1->volume->vol_no, io1->offset);

sys/vfs/hammer/hammer_io.c

75

io2_offset = HAMMER_ENCODE(0, io2->volume->vol_no, io2->offset);

sys/vfs/hammer/hammer_io.c

787

hammer_io_flush_mark(io->volume);

sys/vfs/hammer/hammer_io.c

901

hammer_modify_volume(hammer_transaction_t trans, hammer_volume_t volume,

sys/vfs/hammer/hammer_io.c

906

hammer_io_modify(&volume->io, 1);

sys/vfs/hammer/hammer_io.c

908

intptr_t rel_offset = (intptr_t)base - (intptr_t)volume->ondisk;

sys/vfs/hammer/hammer_io.c

91

hammer_io_init(hammer_io_t io, hammer_volume_t volume, hammer_io_type_t type)

sys/vfs/hammer/hammer_io.c

911

HAMMER_ENCODE_RAW_VOLUME(volume->vol_no, rel_offset),

sys/vfs/hammer/hammer_io.c

93

io->volume = volume;

sys/vfs/hammer/hammer_io.c

939

hammer_modify_volume_done(hammer_volume_t volume)

sys/vfs/hammer/hammer_io.c

94

io->hmp = volume->io.hmp;

sys/vfs/hammer/hammer_io.c

941

hammer_io_modify_done(&volume->io);

sys/vfs/hammer/hammer_ioctl.c

612

hammer_volume_t volume;

sys/vfs/hammer/hammer_ioctl.c

657

volume = hammer_get_root_volume(hmp, &error);

sys/vfs/hammer/hammer_ioctl.c

659

hammer_modify_volume_field(cursor.trans, volume, vol_version);

sys/vfs/hammer/hammer_ioctl.c

660

volume->ondisk->vol_version = ver->cur_version;

sys/vfs/hammer/hammer_ioctl.c

661

hammer_modify_volume_done(volume);

sys/vfs/hammer/hammer_ioctl.c

662

hammer_rel_volume(volume, 0);

sys/vfs/hammer/hammer_ondisk.c

1041

hammer_volume_t volume;

sys/vfs/hammer/hammer_ondisk.c

1081

volume = buffer->io.volume;

sys/vfs/hammer/hammer_ondisk.c

1082

buffer->io.volume = NULL; /* sanity */

sys/vfs/hammer/hammer_ondisk.c

1083

hammer_rel_volume(volume, 0);

sys/vfs/hammer/hammer_ondisk.c

113

hammer_volume_t volume;

sys/vfs/hammer/hammer_ondisk.c

130

volume = kmalloc(sizeof(*volume), hmp->m_misc, M_WAITOK|M_ZERO);

sys/vfs/hammer/hammer_ondisk.c

131

volume->vol_name = kstrdup(volname, hmp->m_misc);

sys/vfs/hammer/hammer_ondisk.c

132

volume->io.hmp = hmp; /* bootstrap */

sys/vfs/hammer/hammer_ondisk.c

133

hammer_io_init(&volume->io, volume, HAMMER_IOTYPE_VOLUME);

sys/vfs/hammer/hammer_ondisk.c

134

volume->io.offset = 0LL;

sys/vfs/hammer/hammer_ondisk.c

135

volume->io.bytes = HAMMER_BUFSIZE;

sys/vfs/hammer/hammer_ondisk.c

141

error = nlookup_init(&nd, volume->vol_name, UIO_SYSSPACE, NLC_FOLLOW);

sys/vfs/hammer/hammer_ondisk.c

145

error = cache_vref(&nd.nl_nch, nd.nl_cred, &volume->devvp);

sys/vfs/hammer/hammer_ondisk.c

149

volume->devvp = devvp;

sys/vfs/hammer/hammer_ondisk.c

153

if (vn_isdisk(volume->devvp, &error)) {

sys/vfs/hammer/hammer_ondisk.c

154

error = vfs_mountedon(volume->devvp);

sys/vfs/hammer/hammer_ondisk.c

157

if (error == 0 && vcount(volume->devvp) > 0)

sys/vfs/hammer/hammer_ondisk.c

160

vn_lock(volume->devvp, LK_EXCLUSIVE | LK_RETRY);

sys/vfs/hammer/hammer_ondisk.c

161

error = vinvalbuf(volume->devvp, V_SAVE, 0, 0);

sys/vfs/hammer/hammer_ondisk.c

163

error = VOP_OPEN(volume->devvp,

sys/vfs/hammer/hammer_ondisk.c

167

vn_unlock(volume->devvp);

sys/vfs/hammer/hammer_ondisk.c

170

hammer_free_volume(volume);

sys/vfs/hammer/hammer_ondisk.c

173

volume->devvp->v_rdev->si_mountpoint = mp;

sys/vfs/hammer/hammer_ondisk.c

180

error = bread(volume->devvp, 0LL, HAMMER_BUFSIZE, &bp);

sys/vfs/hammer/hammer_ondisk.c

200

hkprintf("volume %s has an invalid header\n", volume->vol_name);

sys/vfs/hammer/hammer_ondisk.c

210

volume->vol_no = ondisk->vol_no;

sys/vfs/hammer/hammer_ondisk.c

211

volume->vol_flags = ondisk->vol_flags;

sys/vfs/hammer/hammer_ondisk.c

212

volume->maxbuf_off = HAMMER_ENCODE_RAW_BUFFER(volume->vol_no,

sys/vfs/hammer/hammer_ondisk.c

219

volume->vol_name);

sys/vfs/hammer/hammer_ondisk.c

227

if (RB_INSERT(hammer_vol_rb_tree, &hmp->rb_vols_root, volume)) {

sys/vfs/hammer/hammer_ondisk.c

229

volume->vol_name, volume->vol_no);

sys/vfs/hammer/hammer_ondisk.c

234

hammer_volume_number_add(hmp, volume);

sys/vfs/hammer/hammer_ondisk.c

244

volume->vol_name, ondisk->vol_rootvol);

sys/vfs/hammer/hammer_ondisk.c

248

hmp->rootvol = volume;

sys/vfs/hammer/hammer_ondisk.c

265

volume->devvp->v_rdev->si_mountpoint = NULL;

sys/vfs/hammer/hammer_ondisk.c

266

vn_lock(volume->devvp, LK_EXCLUSIVE | LK_RETRY);

sys/vfs/hammer/hammer_ondisk.c

267

VOP_CLOSE(volume->devvp, ronly ? FREAD : FREAD|FWRITE, NULL);

sys/vfs/hammer/hammer_ondisk.c

268

vn_unlock(volume->devvp);

sys/vfs/hammer/hammer_ondisk.c

269

hammer_free_volume(volume);

sys/vfs/hammer/hammer_ondisk.c

279

hammer_adjust_volume_mode(hammer_volume_t volume, void *data __unused)

sys/vfs/hammer/hammer_ondisk.c

281

if (volume->devvp) {

sys/vfs/hammer/hammer_ondisk.c

282

vn_lock(volume->devvp, LK_EXCLUSIVE | LK_RETRY);

sys/vfs/hammer/hammer_ondisk.c

283

if (volume->io.hmp->ronly) {

sys/vfs/hammer/hammer_ondisk.c

285

VOP_OPEN(volume->devvp, FREAD, FSCRED, NULL);

sys/vfs/hammer/hammer_ondisk.c

286

VOP_CLOSE(volume->devvp, FREAD|FWRITE, NULL);

sys/vfs/hammer/hammer_ondisk.c

289

VOP_OPEN(volume->devvp, FREAD|FWRITE, FSCRED, NULL);

sys/vfs/hammer/hammer_ondisk.c

290

VOP_CLOSE(volume->devvp, FREAD, NULL);

sys/vfs/hammer/hammer_ondisk.c

292

vn_unlock(volume->devvp);

sys/vfs/hammer/hammer_ondisk.c

302

hammer_unload_volume(hammer_volume_t volume, void *data)

sys/vfs/hammer/hammer_ondisk.c

304

hammer_mount_t hmp = volume->io.hmp;

sys/vfs/hammer/hammer_ondisk.c

313

if (ronly == 0 && data && volume->devvp) {

sys/vfs/hammer/hammer_ondisk.c

315

error = bread(volume->devvp, 0LL, HAMMER_BUFSIZE, &bp);

sys/vfs/hammer/hammer_ondisk.c

331

if (hmp->rootvol == volume)

sys/vfs/hammer/hammer_ondisk.c

339

hammer_io_clear_modify(&volume->io, 1);

sys/vfs/hammer/hammer_ondisk.c

340

volume->io.waitdep = 1;

sys/vfs/hammer/hammer_ondisk.c

345

if (volume->io.ioerror)

sys/vfs/hammer/hammer_ondisk.c

346

hammer_io_clear_error_noassert(&volume->io);

sys/vfs/hammer/hammer_ondisk.c

352

hammer_ref_interlock_true(&volume->io.lock);

sys/vfs/hammer/hammer_ondisk.c

353

hammer_rel_volume(volume, 1);

sys/vfs/hammer/hammer_ondisk.c

354

KKASSERT(volume->io.bp == NULL);

sys/vfs/hammer/hammer_ondisk.c

359

KKASSERT(hammer_norefs(&volume->io.lock));

sys/vfs/hammer/hammer_ondisk.c

361

volume->ondisk = NULL;

sys/vfs/hammer/hammer_ondisk.c

362

if (volume->devvp) {

sys/vfs/hammer/hammer_ondisk.c

363

if (volume->devvp->v_rdev &&

sys/vfs/hammer/hammer_ondisk.c

364

volume->devvp->v_rdev->si_mountpoint == hmp->mp) {

sys/vfs/hammer/hammer_ondisk.c

365

volume->devvp->v_rdev->si_mountpoint = NULL;

sys/vfs/hammer/hammer_ondisk.c

374

vn_lock(volume->devvp, LK_EXCLUSIVE | LK_RETRY);

sys/vfs/hammer/hammer_ondisk.c

375

vinvalbuf(volume->devvp, 0, 0, 0);

sys/vfs/hammer/hammer_ondisk.c

376

VOP_CLOSE(volume->devvp, FREAD, NULL);

sys/vfs/hammer/hammer_ondisk.c

377

vn_unlock(volume->devvp);

sys/vfs/hammer/hammer_ondisk.c

383

vn_lock(volume->devvp, LK_EXCLUSIVE | LK_RETRY);

sys/vfs/hammer/hammer_ondisk.c

384

vinvalbuf(volume->devvp, V_SAVE, 0, 0);

sys/vfs/hammer/hammer_ondisk.c

385

VOP_CLOSE(volume->devvp, FREAD|FWRITE, NULL);

sys/vfs/hammer/hammer_ondisk.c

386

vn_unlock(volume->devvp);

sys/vfs/hammer/hammer_ondisk.c

393

RB_REMOVE(hammer_vol_rb_tree, &hmp->rb_vols_root, volume);

sys/vfs/hammer/hammer_ondisk.c

394

hammer_volume_number_del(hmp, volume);

sys/vfs/hammer/hammer_ondisk.c

395

hammer_free_volume(volume);

sys/vfs/hammer/hammer_ondisk.c

401

hammer_free_volume(hammer_volume_t volume)

sys/vfs/hammer/hammer_ondisk.c

403

hammer_mount_t hmp = volume->io.hmp;

sys/vfs/hammer/hammer_ondisk.c

405

if (volume->vol_name) {

sys/vfs/hammer/hammer_ondisk.c

406

kfree(volume->vol_name, hmp->m_misc);

sys/vfs/hammer/hammer_ondisk.c

407

volume->vol_name = NULL;

sys/vfs/hammer/hammer_ondisk.c

409

if (volume->devvp) {

sys/vfs/hammer/hammer_ondisk.c

410

vrele(volume->devvp);

sys/vfs/hammer/hammer_ondisk.c

411

volume->devvp = NULL;

sys/vfs/hammer/hammer_ondisk.c

414

kfree(volume, hmp->m_misc);

sys/vfs/hammer/hammer_ondisk.c

423

hammer_volume_t volume;

sys/vfs/hammer/hammer_ondisk.c

428

volume = RB_LOOKUP(hammer_vol_rb_tree, &hmp->rb_vols_root, vol_no);

sys/vfs/hammer/hammer_ondisk.c

429

if (volume == NULL) {

sys/vfs/hammer/hammer_ondisk.c

439

if (hammer_ref_interlock(&volume->io.lock)) {

sys/vfs/hammer/hammer_ondisk.c

440

*errorp = hammer_load_volume(volume);

sys/vfs/hammer/hammer_ondisk.c

442

volume = NULL;

sys/vfs/hammer/hammer_ondisk.c

444

KKASSERT(volume->ondisk);

sys/vfs/hammer/hammer_ondisk.c

447

return(volume);

sys/vfs/hammer/hammer_ondisk.c

451

hammer_ref_volume(hammer_volume_t volume)

sys/vfs/hammer/hammer_ondisk.c

459

if (hammer_ref_interlock(&volume->io.lock)) {

sys/vfs/hammer/hammer_ondisk.c

460

error = hammer_load_volume(volume);

sys/vfs/hammer/hammer_ondisk.c

462

KKASSERT(volume->ondisk);

sys/vfs/hammer/hammer_ondisk.c

47

static void hammer_free_volume(hammer_volume_t volume);

sys/vfs/hammer/hammer_ondisk.c

474

hammer_volume_t volume;

sys/vfs/hammer/hammer_ondisk.c

476

volume = hmp->rootvol;

sys/vfs/hammer/hammer_ondisk.c

477

KKASSERT(volume != NULL);

sys/vfs/hammer/hammer_ondisk.c

48

static int hammer_load_volume(hammer_volume_t volume);

sys/vfs/hammer/hammer_ondisk.c

483

if (hammer_ref_interlock(&volume->io.lock)) {

sys/vfs/hammer/hammer_ondisk.c

484

lwkt_gettoken(&volume->io.hmp->fs_token);

sys/vfs/hammer/hammer_ondisk.c

485

*errorp = hammer_load_volume(volume);

sys/vfs/hammer/hammer_ondisk.c

486

lwkt_reltoken(&volume->io.hmp->fs_token);

sys/vfs/hammer/hammer_ondisk.c

488

volume = NULL;

sys/vfs/hammer/hammer_ondisk.c

490

KKASSERT(volume->ondisk);

sys/vfs/hammer/hammer_ondisk.c

493

return (volume);

sys/vfs/hammer/hammer_ondisk.c

502

hammer_load_volume(hammer_volume_t volume)

sys/vfs/hammer/hammer_ondisk.c

506

if (volume->ondisk == NULL) {

sys/vfs/hammer/hammer_ondisk.c

507

error = hammer_io_read(volume->devvp, &volume->io,

sys/vfs/hammer/hammer_ondisk.c

510

volume->ondisk = (void *)volume->io.bp->b_data;

sys/vfs/hammer/hammer_ondisk.c

511

hammer_ref_interlock_done(&volume->io.lock);

sys/vfs/hammer/hammer_ondisk.c

513

hammer_rel_volume(volume, 1);

sys/vfs/hammer/hammer_ondisk.c

529

hammer_rel_volume(hammer_volume_t volume, int locked)

sys/vfs/hammer/hammer_ondisk.c

533

if (hammer_rel_interlock(&volume->io.lock, locked)) {

sys/vfs/hammer/hammer_ondisk.c

534

lwkt_gettoken(&volume->io.hmp->fs_token);

sys/vfs/hammer/hammer_ondisk.c

535

volume->ondisk = NULL;

sys/vfs/hammer/hammer_ondisk.c

536

bp = hammer_io_release(&volume->io, locked);

sys/vfs/hammer/hammer_ondisk.c

537

lwkt_reltoken(&volume->io.hmp->fs_token);

sys/vfs/hammer/hammer_ondisk.c

538

hammer_rel_interlock_done(&volume->io.lock, locked);

sys/vfs/hammer/hammer_ondisk.c

602

hammer_volume_t volume;

sys/vfs/hammer/hammer_ondisk.c

705

volume = hammer_get_volume(hmp, vol_no, errorp);

sys/vfs/hammer/hammer_ondisk.c

706

if (volume == NULL)

sys/vfs/hammer/hammer_ondisk.c

709

KKASSERT(zone2_offset < volume->maxbuf_off);

sys/vfs/hammer/hammer_ondisk.c

720

hammer_io_init(&buffer->io, volume, hammer_zone_to_iotype(zone));

sys/vfs/hammer/hammer_ondisk.c

721

buffer->io.offset = hammer_xlate_to_phys(volume->ondisk, zone2_offset);

sys/vfs/hammer/hammer_ondisk.c

730

hammer_rel_volume(volume, 0);

sys/vfs/hammer/hammer_ondisk.c

731

buffer->io.volume = NULL; /* safety */

sys/vfs/hammer/hammer_ondisk.c

817

hammer_volume_t volume;

sys/vfs/hammer/hammer_ondisk.c

823

volume = hammer_get_volume(hmp, vol_no, &ret_error);

sys/vfs/hammer/hammer_ondisk.c

846

KKASSERT(buffer->io.volume == volume);

sys/vfs/hammer/hammer_ondisk.c

850

error = hammer_io_inval(volume, zone2_offset);

sys/vfs/hammer/hammer_ondisk.c

869

hammer_rel_volume(volume, 0);

sys/vfs/hammer/hammer_ondisk.c

883

hammer_volume_t volume;

sys/vfs/hammer/hammer_ondisk.c

889

volume = buffer->io.volume;

sys/vfs/hammer/hammer_ondisk.c

909

error = hammer_io_new(volume->devvp, &buffer->io);

sys/vfs/hammer/hammer_ondisk.c

911

error = hammer_io_read(volume->devvp, &buffer->io,

sys/vfs/hammer/hammer_ondisk.c

918

error = hammer_io_read(volume->devvp, &buffer->io,

sys/vfs/hammer/hammer_ondisk.c

924

error = hammer_io_new(volume->devvp, &buffer->io);

sys/vfs/hammer/hammer_ondisk.c

948

hammer_volume_t volume = (hammer_volume_t)data;

sys/vfs/hammer/hammer_ondisk.c

954

if (volume != NULL && volume != buffer->io.volume)

sys/vfs/hammer/hammer_reblock.c

660

hammer_volume_t volume;

sys/vfs/hammer/hammer_reblock.c

661

volume = hammer_get_root_volume(cursor->trans->hmp, &error);

sys/vfs/hammer/hammer_reblock.c

664

hammer_modify_volume_field(cursor->trans, volume,

sys/vfs/hammer/hammer_reblock.c

666

volume->ondisk->vol0_btree_root = nnode->node_offset;

sys/vfs/hammer/hammer_reblock.c

667

hammer_modify_volume_done(volume);

sys/vfs/hammer/hammer_reblock.c

668

hammer_rel_volume(volume, 0);

sys/vfs/hammer/hammer_recover.c

1034

hammer_volume_t volume;

sys/vfs/hammer/hammer_recover.c

1081

volume = hammer_get_volume(hmp, vol_no, &error);

sys/vfs/hammer/hammer_recover.c

1082

if (volume == NULL) {

sys/vfs/hammer/hammer_recover.c

1087

hammer_modify_volume_noundo(NULL, volume);

sys/vfs/hammer/hammer_recover.c

1090

(char *)volume->ondisk + offset,

sys/vfs/hammer/hammer_recover.c

1092

hammer_modify_volume_done(volume);

sys/vfs/hammer/hammer_recover.c

1101

if (volume->io.recovered == 0)

sys/vfs/hammer/hammer_recover.c

1102

volume->io.recovered = 1;

sys/vfs/hammer/hammer_recover.c

1104

hammer_rel_volume(volume, 0);

sys/vfs/hammer/hammer_recover.c

1481

hammer_recover_flush_volume_callback(hammer_volume_t volume, void *data)

sys/vfs/hammer/hammer_recover.c

1485

if (volume->io.recovered && volume != root_volume) {

sys/vfs/hammer/hammer_recover.c

1486

volume->io.recovered = 0;

sys/vfs/hammer/hammer_recover.c

1492

hammer_io_flush(&volume->io, 0);

sys/vfs/hammer/hammer_recover.c

1494

hammer_io_clear_error(&volume->io);

sys/vfs/hammer/hammer_recover.c

1495

hammer_io_clear_modify(&volume->io, 1);

sys/vfs/hammer/hammer_recover.c

1497

hammer_rel_volume(volume, 0);

sys/vfs/hammer/hammer_vfsops.c

1002

hammer_rel_volume(volume, 0);

sys/vfs/hammer/hammer_vfsops.c

1020

hammer_volume_t volume;

sys/vfs/hammer/hammer_vfsops.c

1027

volume = hammer_get_root_volume(hmp, &error);

sys/vfs/hammer/hammer_vfsops.c

1032

ondisk = volume->ondisk;

sys/vfs/hammer/hammer_vfsops.c

1040

hammer_rel_volume(volume, 0);

sys/vfs/hammer/hammer_vfsops.c

982

hammer_volume_t volume;

sys/vfs/hammer/hammer_vfsops.c

989

volume = hammer_get_root_volume(hmp, &error);

sys/vfs/hammer/hammer_vfsops.c

994

ondisk = volume->ondisk;

sys/vfs/hammer/hammer_volume.c

114

volume = hammer_get_volume(hmp, free_vol_no, &error);

sys/vfs/hammer/hammer_volume.c

115

KKASSERT(volume != NULL && error == 0);

sys/vfs/hammer/hammer_volume.c

117

error = hammer_format_freemap(trans, volume);

sys/vfs/hammer/hammer_volume.c

120

error = hammer_count_bigblocks(hmp, volume,

sys/vfs/hammer/hammer_volume.c

125

hammer_rel_volume(volume, 0);

sys/vfs/hammer/hammer_volume.c

154

hammer_volume_t volume;

sys/vfs/hammer/hammer_volume.c

178

volume = NULL;

sys/vfs/hammer/hammer_volume.c

180

volume = hammer_get_volume(hmp, vol_no, &error);

sys/vfs/hammer/hammer_volume.c

181

KKASSERT(volume != NULL && error == 0);

sys/vfs/hammer/hammer_volume.c

182

if (strcmp(volume->vol_name, ioc->device_name) == 0) {

sys/vfs/hammer/hammer_volume.c

185

hammer_rel_volume(volume, 0);

sys/vfs/hammer/hammer_volume.c

186

volume = NULL;

sys/vfs/hammer/hammer_volume.c

189

if (volume == NULL) {

sys/vfs/hammer/hammer_volume.c

195

if (volume == trans->rootvol) {

sys/vfs/hammer/hammer_volume.c

197

hammer_rel_volume(volume, 0);

sys/vfs/hammer/hammer_volume.c

205

hmp->volume_to_remove = volume->vol_no;

sys/vfs/hammer/hammer_volume.c

207

error = hammer_count_bigblocks(hmp, volume,

sys/vfs/hammer/hammer_volume.c

212

hmkprintf(hmp, "%s is already empty\n", volume->vol_name);

sys/vfs/hammer/hammer_volume.c

217

hammer_rel_volume(volume, 0);

sys/vfs/hammer/hammer_volume.c

221

hmkprintf(hmp, "%s is not empty\n", volume->vol_name);

sys/vfs/hammer/hammer_volume.c

222

hammer_rel_volume(volume, 0);

sys/vfs/hammer/hammer_volume.c

230

error = hammer_count_bigblocks(hmp, volume,

sys/vfs/hammer/hammer_volume.c

234

error = hammer_free_freemap(trans, volume);

sys/vfs/hammer/hammer_volume.c

238

kprintf("Volume %d not empty\n", volume->vol_no);

sys/vfs/hammer/hammer_volume.c

242

hammer_rel_volume(volume, 0);

sys/vfs/hammer/hammer_volume.c

245

hammer_rel_volume(volume, 0);

sys/vfs/hammer/hammer_volume.c

263

hammer_unload_buffer, volume);

sys/vfs/hammer/hammer_volume.c

266

error = hammer_unload_volume(volume, &ondisk);

sys/vfs/hammer/hammer_volume.c

295

hammer_volume_t volume;

sys/vfs/hammer/hammer_volume.c

308

volume = hammer_get_volume(hmp, i, &error);

sys/vfs/hammer/hammer_volume.c

309

KKASSERT(volume != NULL && error == 0);

sys/vfs/hammer/hammer_volume.c

311

len = strlen(volume->vol_name) + 1;

sys/vfs/hammer/hammer_volume.c

314

vol_no = volume->vol_no;

sys/vfs/hammer/hammer_volume.c

318

error = copyout(volume->vol_name,

sys/vfs/hammer/hammer_volume.c

320

hammer_rel_volume(volume, 0);

sys/vfs/hammer/hammer_volume.c

383

hammer_format_freemap(hammer_transaction_t trans, hammer_volume_t volume)

sys/vfs/hammer/hammer_volume.c

403

KKASSERT(volume->vol_no != HAMMER_ROOT_VOLNO);

sys/vfs/hammer/hammer_volume.c

405

ondisk = volume->ondisk;

sys/vfs/hammer/hammer_volume.c

413

alloc_offset = HAMMER_ENCODE_RAW_BUFFER(volume->vol_no, 0);

sys/vfs/hammer/hammer_volume.c

415

hmkprintf(hmp, "Initialize freemap volume %d\n", volume->vol_no);

sys/vfs/hammer/hammer_volume.c

417

for (phys_offset = HAMMER_ENCODE_RAW_BUFFER(volume->vol_no, 0);

sys/vfs/hammer/hammer_volume.c

436

for (phys_offset = HAMMER_ENCODE_RAW_BUFFER(volume->vol_no, 0);

sys/vfs/hammer/hammer_volume.c

502

hammer_free_freemap(hammer_transaction_t trans, hammer_volume_t volume)

sys/vfs/hammer/hammer_volume.c

520

KKASSERT(volume->vol_no != HAMMER_ROOT_VOLNO);

sys/vfs/hammer/hammer_volume.c

522

ondisk = volume->ondisk;

sys/vfs/hammer/hammer_volume.c

53

hammer_format_freemap(hammer_transaction_t trans, hammer_volume_t volume);

sys/vfs/hammer/hammer_volume.c

531

hmkprintf(hmp, "Free freemap volume %d\n", volume->vol_no);

sys/vfs/hammer/hammer_volume.c

533

for (phys_offset = HAMMER_ENCODE_RAW_BUFFER(volume->vol_no, 0);

sys/vfs/hammer/hammer_volume.c

56

hammer_free_freemap(hammer_transaction_t trans, hammer_volume_t volume);

sys/vfs/hammer/hammer_volume.c

569

for (phys_offset = HAMMER_ENCODE_RAW_BUFFER(volume->vol_no, 0);

sys/vfs/hammer/hammer_volume.c

59

hammer_count_bigblocks(hammer_mount_t hmp, hammer_volume_t volume,

sys/vfs/hammer/hammer_volume.c

679

hammer_volume_t volume;

sys/vfs/hammer/hammer_volume.c

687

volume = hammer_get_volume(hmp, vol_no, &error);

sys/vfs/hammer/hammer_volume.c

688

KKASSERT(volume != NULL && error == 0);

sys/vfs/hammer/hammer_volume.c

689

hammer_modify_volume_field(trans, volume, vol_count);

sys/vfs/hammer/hammer_volume.c

69

hammer_volume_t volume;

sys/vfs/hammer/hammer_volume.c

690

volume->ondisk->vol_count = hmp->nvolumes;

sys/vfs/hammer/hammer_volume.c

691

hammer_modify_volume_done(volume);

sys/vfs/hammer/hammer_volume.c

701

if (volume != trans->rootvol && volume->io.modified) {

sys/vfs/hammer/hammer_volume.c

702

hammer_crc_set_volume(hmp->version, volume->ondisk);

sys/vfs/hammer/hammer_volume.c

703

hammer_io_flush(&volume->io, 0);

sys/vfs/hammer/hammer_volume.c

706

hammer_rel_volume(volume, 0);

sys/vfs/hammer/hammer_volume.c

750

hammer_count_bigblocks(hammer_mount_t hmp, hammer_volume_t volume,

sys/vfs/hammer/hammer_volume.c

770

KKASSERT(volume->vol_no != HAMMER_ROOT_VOLNO);

sys/vfs/hammer/hammer_volume.c

775

ondisk = volume->ondisk;

sys/vfs/hammer/hammer_volume.c

784

for (phys_offset = HAMMER_ENCODE_RAW_BUFFER(volume->ondisk->vol_no, 0);

sys/vfs/hammer2/hammer2_mount.h

46

const char *volume;

sys/vfs/hammer2/hammer2_vfsops.c

1497

copyinstr(info.volume, mp->mnt_stat.f_mntfromname,

sys/vfs/hammer2/hammer2_vfsops.c

989

error = copyinstr(info.volume, devstr, MNAMELEN - 1, &done);

usr.sbin/fstyp/befs.c

50

struct disk_super_block *volume;

usr.sbin/fstyp/befs.c

52

volume = read_buf(fp, BEFS_BLOCK_OFFSET, sizeof(*volume));

usr.sbin/fstyp/befs.c

54

if (volume == NULL) {

usr.sbin/fstyp/befs.c

58

if (volume->magic1 == BEFS_SUPER_BLOCK_MAGIC1) {

usr.sbin/fstyp/befs.c

59

strlcpy(label, volume->name, size);

usr.sbin/fstyp/befs.c

60

free(volume);

usr.sbin/fstyp/befs.c

65

free(volume);

usr.sbin/fstyp/cd9660.c

46

char *sector, *volume;

usr.sbin/fstyp/cd9660.c

55

volume = sector + 0x28;

usr.sbin/fstyp/cd9660.c

57

strlcpy(label, volume, MIN(size, VOLUME_LEN));

usr.sbin/makefs/hammer2/hammer2_vfsops.c

1461

copyinstr(info.volume, mp->mnt_stat.f_mntfromname,

usr.sbin/mfiutil/mfi_volume.c

42

MFI_TABLE(top, volume);

usr.sbin/mfiutil/mfi_volume.c

496

MFI_COMMAND(volume, progress, volume_progress);

usr.sbin/mptutil/mpt_volume.c

191

MPT_COMMAND(volume, status, volume_status);

usr.sbin/mptutil/mpt_volume.c

196

CONFIG_PAGE_RAID_VOL_0 *volume;

usr.sbin/mptutil/mpt_volume.c

229

volume = mpt_vol_info(fd, VolumeBus, VolumeID, NULL);

usr.sbin/mptutil/mpt_volume.c

230

if (volume == NULL)

usr.sbin/mptutil/mpt_volume.c

233

Settings = volume->VolumeSettings.Settings;

usr.sbin/mptutil/mpt_volume.c

247

volume->VolumeSettings.Settings = NewSettings;

usr.sbin/mptutil/mpt_volume.c

249

VolumeBus, VolumeID, 0, *(U32 *)&volume->VolumeSettings, NULL, 0,

usr.sbin/mptutil/mpt_volume.c

257

MPT_COMMAND(volume, cache, volume_cache);

usr.sbin/mptutil/mpt_volume.c

44

MPT_TABLE(top, volume);