arch/m68k/mac/macboing.c

220

static void mac_quadra_start_bell( unsigned int freq, unsigned int length, unsigned int volume )

arch/m68k/mac/macboing.c

239

mac_asc_regs[ 0x806 ] = volume;

arch/m68k/mac/macboing.c

301

static void mac_av_start_bell( unsigned int freq, unsigned int length, unsigned int volume )

arch/powerpc/kernel/rtas-proc.c

730

u64 volume;

arch/powerpc/kernel/rtas-proc.c

731

int error = parse_number(buf, count, &volume);

arch/powerpc/kernel/rtas-proc.c

735

if (volume > 100)

arch/powerpc/kernel/rtas-proc.c

736

volume = 100;

arch/powerpc/kernel/rtas-proc.c

738

rtas_tone_volume = volume; /* save it for later */

arch/powerpc/kernel/rtas-proc.c

740

TONE_VOLUME, 0, volume);

arch/um/drivers/ubd_kern.c

1340

struct cdrom_volctrl volume;

arch/um/drivers/ubd_kern.c

1352

if(copy_from_user(&volume, (char __user *) arg, sizeof(volume)))

arch/um/drivers/ubd_kern.c

1354

volume.channel0 = 255;

arch/um/drivers/ubd_kern.c

1355

volume.channel1 = 255;

arch/um/drivers/ubd_kern.c

1356

volume.channel2 = 255;

arch/um/drivers/ubd_kern.c

1357

volume.channel3 = 255;

arch/um/drivers/ubd_kern.c

1358

if(copy_to_user((char __user *) arg, &volume, sizeof(volume)))

block/partitions/sgi.c

26

} volume[15];

block/partitions/sun.c

32

char volume[8]; /* Volume name */

drivers/accessibility/speakup/speakup_dtlk.c

314

status.volume = *t++;

drivers/accessibility/speakup/speakup_dtlk.h

49

u_char volume; /* nV; 0-9 */

drivers/block/drbd/drbd_int.h

922

unsigned int volume;

drivers/block/drbd/drbd_main.c

2657

int vnr = adm_ctx->volume;

drivers/block/drbd/drbd_main.c

564

h->volume = cpu_to_be16(vnr);

drivers/block/drbd/drbd_nl.c

190

adm_ctx->volume = VOLUME_UNSPECIFIED;

drivers/block/drbd/drbd_nl.c

209

adm_ctx->volume = nla_get_u32(nla);

drivers/block/drbd/drbd_nl.c

278

adm_ctx->volume != VOLUME_UNSPECIFIED &&

drivers/block/drbd/drbd_nl.c

279

adm_ctx->volume != adm_ctx->device->vnr) {

drivers/block/drbd/drbd_nl.c

281

adm_ctx->minor, adm_ctx->volume,

drivers/block/drbd/drbd_nl.c

3873

unsigned volume = cb->args[1];

drivers/block/drbd/drbd_nl.c

3913

device = idr_get_next(&resource->devices, &volume);

drivers/block/drbd/drbd_nl.c

3920

if (volume != 0) {

drivers/block/drbd/drbd_nl.c

3926

volume = 0;

drivers/block/drbd/drbd_nl.c

3959

D_ASSERT(device, device->vnr == volume);

drivers/block/drbd/drbd_nl.c

3978

cb->args[1] = (pos == resource) ? volume + 1 : 0;

drivers/block/drbd/drbd_nl.c

4304

if (adm_ctx.volume > DRBD_VOLUME_MAX) {

drivers/block/drbd/drbd_protocol.h

118

u16 volume;

drivers/block/drbd/drbd_receiver.c

981

pi->vnr = be16_to_cpu(h->volume);

drivers/cdrom/cdrom.c

2695

struct cdrom_volctrl volume;

drivers/cdrom/cdrom.c

2701

if (copy_from_user(&volume, argp, sizeof(volume)))

drivers/cdrom/cdrom.c

2703

return cdi->ops->audio_ioctl(cdi, CDROMVOLCTRL, &volume);

drivers/cdrom/cdrom.c

2709

struct cdrom_volctrl volume;

drivers/cdrom/cdrom.c

2717

ret = cdi->ops->audio_ioctl(cdi, CDROMVOLREAD, &volume);

drivers/cdrom/cdrom.c

2721

if (copy_to_user(argp, &volume, sizeof(volume)))

drivers/char/dtlk.c

551

status.volume = *t++;

drivers/firmware/efi/libstub/file.c

128

static efi_status_t efi_open_device_path(efi_file_protocol_t **volume,

drivers/firmware/efi/libstub/file.c

171

status = efi_call_proto(io, open_volume, volume);

drivers/firmware/efi/libstub/file.c

203

efi_file_protocol_t *volume = NULL;

drivers/firmware/efi/libstub/file.c

246

status = efi_open_device_path(&volume, &fi);

drivers/firmware/efi/libstub/file.c

249

status = efi_open_volume(image, &volume);

drivers/firmware/efi/libstub/file.c

254

status = efi_open_file(volume, &fi, &file, &size);

drivers/firmware/efi/libstub/file.c

309

efi_call_proto(volume, close);

drivers/firmware/efi/libstub/file.c

326

efi_call_proto(volume, close);

drivers/firmware/efi/libstub/file.c

37

static efi_status_t efi_open_file(efi_file_protocol_t *volume,

drivers/firmware/efi/libstub/file.c

54

status = efi_call_proto(volume, open, &fh, fi->filename,

drivers/isdn/mISDN/dsp.h

241

extern void dsp_change_volume(struct sk_buff *skb, int volume);

drivers/isdn/mISDN/dsp_audio.c

391

dsp_change_volume(struct sk_buff *skb, int volume)

drivers/isdn/mISDN/dsp_audio.c

398

if (volume == 0)

drivers/isdn/mISDN/dsp_audio.c

402

if (volume < 0) {

drivers/isdn/mISDN/dsp_audio.c

403

shift = volume + 8;

drivers/isdn/mISDN/dsp_audio.c

407

shift = volume + 7;

drivers/md/dm-vdo/indexer/index-layout.c

1101

result = uds_write_index_page_map(index->volume->index_page_map, writers[0]);

drivers/md/dm-vdo/indexer/index-layout.c

1281

sil->volume = table->regions[3];

drivers/md/dm-vdo/indexer/index-layout.c

1282

result = verify_region(&sil->volume, next_block, RL_KIND_VOLUME,

drivers/md/dm-vdo/indexer/index-layout.c

1287

next_block += sil->volume.block_count + layout->super.volume_offset;

drivers/md/dm-vdo/indexer/index-layout.c

171

struct layout_region volume;

drivers/md/dm-vdo/indexer/index-layout.c

1729

off_t offset = (layout->index.volume.start_block +

drivers/md/dm-vdo/indexer/index-layout.c

379

sil->volume = (struct layout_region) {

drivers/md/dm-vdo/indexer/index-layout.c

655

*lr++ = layout->index.volume;

drivers/md/dm-vdo/indexer/index-layout.c

929

result = uds_read_index_page_map(index->volume->index_page_map, readers[0]);

drivers/md/dm-vdo/indexer/index.c

1002

result = uds_get_volume_record_page(index->volume, physical_chapter,

drivers/md/dm-vdo/indexer/index.c

1049

old_map_update = index->volume->index_page_map->last_update;

drivers/md/dm-vdo/indexer/index.c

1051

will_be_sparse = uds_is_chapter_sparse(index->volume->geometry,

drivers/md/dm-vdo/indexer/index.c

1062

new_map_update = index->volume->index_page_map->last_update;

drivers/md/dm-vdo/indexer/index.c

1078

u32 chapters_per_volume = index->volume->geometry->chapters_per_volume;

drivers/md/dm-vdo/indexer/index.c

1080

index->volume->lookup_mode = LOOKUP_FOR_REBUILD;

drivers/md/dm-vdo/indexer/index.c

1081

result = uds_find_volume_chapter_boundaries(index->volume, &lowest, &highest,

drivers/md/dm-vdo/indexer/index.c

1091

index->volume->lookup_mode = LOOKUP_NORMAL;

drivers/md/dm-vdo/indexer/index.c

1107

index->volume->lookup_mode = LOOKUP_NORMAL;

drivers/md/dm-vdo/indexer/index.c

1130

result = uds_make_open_chapter(index->volume->geometry, index->zone_count,

drivers/md/dm-vdo/indexer/index.c

1137

result = uds_make_open_chapter(index->volume->geometry, index->zone_count,

drivers/md/dm-vdo/indexer/index.c

1183

result = uds_make_volume(config, index->layout, &index->volume);

drivers/md/dm-vdo/indexer/index.c

1189

index->volume->lookup_mode = LOOKUP_NORMAL;

drivers/md/dm-vdo/indexer/index.c

1292

uds_free_volume(index->volume);

drivers/md/dm-vdo/indexer/index.c

1338

return uds_replace_volume_storage(index->volume, index->layout, bdev);

drivers/md/dm-vdo/indexer/index.c

1352

index->volume->cache_size +

drivers/md/dm-vdo/indexer/index.c

157

!uds_is_sparse_index_geometry(zone->index->volume->geometry))

drivers/md/dm-vdo/indexer/index.c

281

expire_chapters = uds_chapters_to_expire(zone->index->volume->geometry,

drivers/md/dm-vdo/indexer/index.c

289

uds_forget_chapter(zone->index->volume, expiring++);

drivers/md/dm-vdo/indexer/index.c

345

struct volume *volume;

drivers/md/dm-vdo/indexer/index.c

355

volume = zone->index->volume;

drivers/md/dm-vdo/indexer/index.c

356

chapter = uds_map_to_physical_chapter(volume->geometry, virtual_chapter);

drivers/md/dm-vdo/indexer/index.c

357

return uds_search_cached_record_page(volume, request, chapter,

drivers/md/dm-vdo/indexer/index.c

364

struct volume *volume;

drivers/md/dm-vdo/indexer/index.c

388

volume = zone->index->volume;

drivers/md/dm-vdo/indexer/index.c

390

uds_sparse_cache_contains(volume->sparse_cache, request->virtual_chapter,

drivers/md/dm-vdo/indexer/index.c

395

return uds_search_volume_page_cache(volume, request, found);

drivers/md/dm-vdo/indexer/index.c

473

} else if (uds_is_sparse_index_geometry(zone->index->volume->geometry) &&

drivers/md/dm-vdo/indexer/index.c

715

index->volume,

drivers/md/dm-vdo/indexer/index.c

723

uds_chapters_to_expire(index->volume->geometry,

drivers/md/dm-vdo/indexer/index.c

765

(sizeof(struct uds_volume_record) * index->volume->geometry->records_per_chapter);

drivers/md/dm-vdo/indexer/index.c

785

index->volume->geometry,

drivers/md/dm-vdo/indexer/index.c

786

index->volume->nonce);

drivers/md/dm-vdo/indexer/index.c

80

return uds_is_chapter_sparse(zone->index->volume->geometry,

drivers/md/dm-vdo/indexer/index.c

829

struct index_geometry *geometry = index->volume->geometry;

drivers/md/dm-vdo/indexer/index.c

839

result = uds_get_volume_index_page(index->volume, chapter,

drivers/md/dm-vdo/indexer/index.c

856

uds_update_index_page_map(index->volume->index_page_map, vcn, chapter,

drivers/md/dm-vdo/indexer/index.c

910

result = uds_search_volume_page_cache_for_rebuild(index->volume,

drivers/md/dm-vdo/indexer/index.c

985

geometry = index->volume->geometry;

drivers/md/dm-vdo/indexer/index.c

987

uds_prefetch_volume_chapter(index->volume, physical_chapter);

drivers/md/dm-vdo/indexer/index.h

43

struct volume *volume;

drivers/md/dm-vdo/indexer/open-chapter.c

276

unsigned int zone_count, struct volume *volume,

drivers/md/dm-vdo/indexer/open-chapter.c

289

return uds_write_chapter(volume, chapter_index, collated_records);

drivers/md/dm-vdo/indexer/open-chapter.h

66

unsigned int zone_count, struct volume *volume,

drivers/md/dm-vdo/indexer/sparse-cache.c

460

const struct volume *volume)

drivers/md/dm-vdo/indexer/sparse-cache.c

466

result = uds_read_chapter_index_from_volume(volume, virtual_chapter,

drivers/md/dm-vdo/indexer/sparse-cache.c

496

struct sparse_cache *cache = index->volume->sparse_cache;

drivers/md/dm-vdo/indexer/sparse-cache.c

523

index->volume);

drivers/md/dm-vdo/indexer/sparse-cache.c

579

struct volume *volume = zone->index->volume;

drivers/md/dm-vdo/indexer/sparse-cache.c

580

struct sparse_cache *cache = volume->sparse_cache;

drivers/md/dm-vdo/indexer/sparse-cache.c

597

volume->index_page_map, name,

drivers/md/dm-vdo/indexer/volume.c

1008

uds_find_index_page_number(volume->index_page_map, name,

drivers/md/dm-vdo/indexer/volume.c

1010

result = get_volume_page(volume, physical_chapter, index_page_number, &page);

drivers/md/dm-vdo/indexer/volume.c

1023

result = get_volume_page(volume, physical_chapter, page_number, &page);

drivers/md/dm-vdo/indexer/volume.c

1049

void uds_forget_chapter(struct volume *volume, u64 virtual_chapter)

drivers/md/dm-vdo/indexer/volume.c

1052

uds_map_to_physical_chapter(volume->geometry, virtual_chapter);

drivers/md/dm-vdo/indexer/volume.c

1053

u32 first_page = map_to_physical_page(volume->geometry, physical_chapter, 0);

drivers/md/dm-vdo/indexer/volume.c

1057

mutex_lock(&volume->read_threads_mutex);

drivers/md/dm-vdo/indexer/volume.c

1058

for (i = 0; i < volume->geometry->pages_per_chapter; i++)

drivers/md/dm-vdo/indexer/volume.c

1059

invalidate_page(&volume->page_cache, first_page + i);

drivers/md/dm-vdo/indexer/volume.c

1060

mutex_unlock(&volume->read_threads_mutex);

drivers/md/dm-vdo/indexer/volume.c

1067

static int donate_index_page_locked(struct volume *volume, u32 physical_chapter,

drivers/md/dm-vdo/indexer/volume.c

1073

map_to_physical_page(volume->geometry, physical_chapter,

drivers/md/dm-vdo/indexer/volume.c

1076

page = select_victim_in_cache(&volume->page_cache);

drivers/md/dm-vdo/indexer/volume.c

1078

result = init_chapter_index_page(volume, dm_bufio_get_block_data(page_buffer),

drivers/md/dm-vdo/indexer/volume.c

1083

cancel_page_in_cache(&volume->page_cache, physical_page, page);

drivers/md/dm-vdo/indexer/volume.c

1087

result = put_page_in_cache(&volume->page_cache, physical_page, page);

drivers/md/dm-vdo/indexer/volume.c

1090

cancel_page_in_cache(&volume->page_cache, physical_page, page);

drivers/md/dm-vdo/indexer/volume.c

1097

static int write_index_pages(struct volume *volume, u32 physical_chapter_number,

drivers/md/dm-vdo/indexer/volume.c

1100

struct index_geometry *geometry = volume->geometry;

drivers/md/dm-vdo/indexer/volume.c

1115

page_data = dm_bufio_new(volume->client, physical_page, &page_buffer);

drivers/md/dm-vdo/indexer/volume.c

1140

uds_update_index_page_map(volume->index_page_map,

drivers/md/dm-vdo/indexer/volume.c

1145

mutex_lock(&volume->read_threads_mutex);

drivers/md/dm-vdo/indexer/volume.c

1146

result = donate_index_page_locked(volume, physical_chapter_number,

drivers/md/dm-vdo/indexer/volume.c

1148

mutex_unlock(&volume->read_threads_mutex);

drivers/md/dm-vdo/indexer/volume.c

1182

static int encode_record_page(const struct volume *volume,

drivers/md/dm-vdo/indexer/volume.c

1187

u32 records_per_page = volume->geometry->records_per_page;

drivers/md/dm-vdo/indexer/volume.c

1188

const struct uds_volume_record **record_pointers = volume->record_pointers;

drivers/md/dm-vdo/indexer/volume.c

1198

result = uds_radix_sort(volume->radix_sorter, (const u8 **) record_pointers,

drivers/md/dm-vdo/indexer/volume.c

1207

static int write_record_pages(struct volume *volume, u32 physical_chapter_number,

drivers/md/dm-vdo/indexer/volume.c

1211

struct index_geometry *geometry = volume->geometry;

drivers/md/dm-vdo/indexer/volume.c

1224

page_data = dm_bufio_new(volume->client, physical_page, &page_buffer);

drivers/md/dm-vdo/indexer/volume.c

1230

result = encode_record_page(volume, next_record, page_data);

drivers/md/dm-vdo/indexer/volume.c

1246

int uds_write_chapter(struct volume *volume, struct open_chapter_index *chapter_index,

drivers/md/dm-vdo/indexer/volume.c

1251

uds_map_to_physical_chapter(volume->geometry,

drivers/md/dm-vdo/indexer/volume.c

1254

result = write_index_pages(volume, physical_chapter_number, chapter_index);

drivers/md/dm-vdo/indexer/volume.c

1258

result = write_record_pages(volume, physical_chapter_number, records);

drivers/md/dm-vdo/indexer/volume.c

1262

result = -dm_bufio_write_dirty_buffers(volume->client);

drivers/md/dm-vdo/indexer/volume.c

1269

static void probe_chapter(struct volume *volume, u32 chapter_number,

drivers/md/dm-vdo/indexer/volume.c

1272

const struct index_geometry *geometry = volume->geometry;

drivers/md/dm-vdo/indexer/volume.c

1278

dm_bufio_prefetch(volume->client,

drivers/md/dm-vdo/indexer/volume.c

1286

result = uds_get_volume_index_page(volume, chapter_number, i, &page);

drivers/md/dm-vdo/indexer/volume.c

1328

static void find_real_end_of_volume(struct volume *volume, u32 limit, u32 *limit_ptr)

drivers/md/dm-vdo/indexer/volume.c

1337

probe_chapter(volume, chapter, &vcn);

drivers/md/dm-vdo/indexer/volume.c

1353

static int find_chapter_limits(struct volume *volume, u32 chapter_limit, u64 *lowest_vcn,

drivers/md/dm-vdo/indexer/volume.c

1356

struct index_geometry *geometry = volume->geometry;

drivers/md/dm-vdo/indexer/volume.c

1374

probe_chapter(volume, 0, &zero_vcn);

drivers/md/dm-vdo/indexer/volume.c

1389

probe_chapter(volume, geometry->remapped_physical, &remapped_vcn);

drivers/md/dm-vdo/indexer/volume.c

1404

probe_chapter(volume, chapter, &probe_vcn);

drivers/md/dm-vdo/indexer/volume.c

1419

probe_chapter(volume, left_chapter, &lowest);

drivers/md/dm-vdo/indexer/volume.c

1434

probe_chapter(volume, right_chapter, &highest);

drivers/md/dm-vdo/indexer/volume.c

1451

int uds_find_volume_chapter_boundaries(struct volume *volume, u64 *lowest_vcn,

drivers/md/dm-vdo/indexer/volume.c

1454

u32 chapter_limit = volume->geometry->chapters_per_volume;

drivers/md/dm-vdo/indexer/volume.c

1456

find_real_end_of_volume(volume, chapter_limit, &chapter_limit);

drivers/md/dm-vdo/indexer/volume.c

1465

return find_chapter_limits(volume, chapter_limit, lowest_vcn, highest_vcn);

drivers/md/dm-vdo/indexer/volume.c

1468

int __must_check uds_replace_volume_storage(struct volume *volume,

drivers/md/dm-vdo/indexer/volume.c

1480

for (i = 0; i < volume->page_cache.indexable_pages; i++)

drivers/md/dm-vdo/indexer/volume.c

1481

volume->page_cache.index[i] = volume->page_cache.cache_slots;

drivers/md/dm-vdo/indexer/volume.c

1482

for (i = 0; i < volume->page_cache.cache_slots; i++)

drivers/md/dm-vdo/indexer/volume.c

1483

clear_cache_page(&volume->page_cache, &volume->page_cache.cache[i]);

drivers/md/dm-vdo/indexer/volume.c

1484

if (volume->sparse_cache != NULL)

drivers/md/dm-vdo/indexer/volume.c

1485

uds_invalidate_sparse_cache(volume->sparse_cache);

drivers/md/dm-vdo/indexer/volume.c

1486

if (volume->client != NULL)

drivers/md/dm-vdo/indexer/volume.c

1487

dm_bufio_client_destroy(vdo_forget(volume->client));

drivers/md/dm-vdo/indexer/volume.c

1489

return uds_open_volume_bufio(layout, volume->geometry->bytes_per_page,

drivers/md/dm-vdo/indexer/volume.c

1490

volume->reserved_buffers, &volume->client);

drivers/md/dm-vdo/indexer/volume.c

1543

struct volume **new_volume)

drivers/md/dm-vdo/indexer/volume.c

1546

struct volume *volume = NULL;

drivers/md/dm-vdo/indexer/volume.c

1551

result = vdo_allocate(1, struct volume, "volume", &volume);

drivers/md/dm-vdo/indexer/volume.c

1555

volume->nonce = uds_get_volume_nonce(layout);

drivers/md/dm-vdo/indexer/volume.c

1557

result = uds_copy_index_geometry(config->geometry, &volume->geometry);

drivers/md/dm-vdo/indexer/volume.c

1559

uds_free_volume(volume);

drivers/md/dm-vdo/indexer/volume.c

1563

geometry = volume->geometry;

drivers/md/dm-vdo/indexer/volume.c

1573

volume->reserved_buffers = reserved_buffers;

drivers/md/dm-vdo/indexer/volume.c

1575

volume->reserved_buffers, &volume->client);

drivers/md/dm-vdo/indexer/volume.c

1577

uds_free_volume(volume);

drivers/md/dm-vdo/indexer/volume.c

1582

&volume->radix_sorter);

drivers/md/dm-vdo/indexer/volume.c

1584

uds_free_volume(volume);

drivers/md/dm-vdo/indexer/volume.c

1590

&volume->record_pointers);

drivers/md/dm-vdo/indexer/volume.c

1592

uds_free_volume(volume);

drivers/md/dm-vdo/indexer/volume.c

1601

&volume->sparse_cache);

drivers/md/dm-vdo/indexer/volume.c

1603

uds_free_volume(volume);

drivers/md/dm-vdo/indexer/volume.c

1607

volume->cache_size =

drivers/md/dm-vdo/indexer/volume.c

1611

result = initialize_page_cache(&volume->page_cache, geometry,

drivers/md/dm-vdo/indexer/volume.c

1614

uds_free_volume(volume);

drivers/md/dm-vdo/indexer/volume.c

1618

volume->cache_size += volume->page_cache.cache_slots * sizeof(struct delta_index_page);

drivers/md/dm-vdo/indexer/volume.c

1619

result = uds_make_index_page_map(geometry, &volume->index_page_map);

drivers/md/dm-vdo/indexer/volume.c

1621

uds_free_volume(volume);

drivers/md/dm-vdo/indexer/volume.c

1625

mutex_init(&volume->read_threads_mutex);

drivers/md/dm-vdo/indexer/volume.c

1626

uds_init_cond(&volume->read_threads_read_done_cond);

drivers/md/dm-vdo/indexer/volume.c

1627

uds_init_cond(&volume->read_threads_cond);

drivers/md/dm-vdo/indexer/volume.c

1630

&volume->reader_threads);

drivers/md/dm-vdo/indexer/volume.c

1632

uds_free_volume(volume);

drivers/md/dm-vdo/indexer/volume.c

1637

result = vdo_create_thread(read_thread_function, (void *) volume,

drivers/md/dm-vdo/indexer/volume.c

1638

"reader", &volume->reader_threads[i]);

drivers/md/dm-vdo/indexer/volume.c

1640

uds_free_volume(volume);

drivers/md/dm-vdo/indexer/volume.c

1644

volume->read_thread_count = i + 1;

drivers/md/dm-vdo/indexer/volume.c

1647

*new_volume = volume;

drivers/md/dm-vdo/indexer/volume.c

1665

void uds_free_volume(struct volume *volume)

drivers/md/dm-vdo/indexer/volume.c

1667

if (volume == NULL)

drivers/md/dm-vdo/indexer/volume.c

1670

if (volume->reader_threads != NULL) {

drivers/md/dm-vdo/indexer/volume.c

1674

mutex_lock(&volume->read_threads_mutex);

drivers/md/dm-vdo/indexer/volume.c

1675

volume->read_threads_exiting = true;

drivers/md/dm-vdo/indexer/volume.c

1676

uds_broadcast_cond(&volume->read_threads_cond);

drivers/md/dm-vdo/indexer/volume.c

1677

mutex_unlock(&volume->read_threads_mutex);

drivers/md/dm-vdo/indexer/volume.c

1678

for (i = 0; i < volume->read_thread_count; i++)

drivers/md/dm-vdo/indexer/volume.c

1679

vdo_join_threads(volume->reader_threads[i]);

drivers/md/dm-vdo/indexer/volume.c

1680

vdo_free(volume->reader_threads);

drivers/md/dm-vdo/indexer/volume.c

1681

volume->reader_threads = NULL;

drivers/md/dm-vdo/indexer/volume.c

1685

uninitialize_page_cache(&volume->page_cache);

drivers/md/dm-vdo/indexer/volume.c

1686

uds_free_sparse_cache(volume->sparse_cache);

drivers/md/dm-vdo/indexer/volume.c

1687

if (volume->client != NULL)

drivers/md/dm-vdo/indexer/volume.c

1688

dm_bufio_client_destroy(vdo_forget(volume->client));

drivers/md/dm-vdo/indexer/volume.c

1690

uds_free_index_page_map(volume->index_page_map);

drivers/md/dm-vdo/indexer/volume.c

1691

uds_free_radix_sorter(volume->radix_sorter);

drivers/md/dm-vdo/indexer/volume.c

1692

vdo_free(volume->geometry);

drivers/md/dm-vdo/indexer/volume.c

1693

vdo_free(volume->record_pointers);

drivers/md/dm-vdo/indexer/volume.c

1694

vdo_free(volume);

drivers/md/dm-vdo/indexer/volume.c

355

static void enqueue_page_read(struct volume *volume, struct uds_request *request,

drivers/md/dm-vdo/indexer/volume.c

359

while (!enqueue_read(&volume->page_cache, request, physical_page)) {

drivers/md/dm-vdo/indexer/volume.c

361

uds_wait_cond(&volume->read_threads_read_done_cond,

drivers/md/dm-vdo/indexer/volume.c

362

&volume->read_threads_mutex);

drivers/md/dm-vdo/indexer/volume.c

365

uds_signal_cond(&volume->read_threads_cond);

drivers/md/dm-vdo/indexer/volume.c

402

static inline struct queued_read *wait_to_reserve_read_queue_entry(struct volume *volume)

drivers/md/dm-vdo/indexer/volume.c

406

while (!volume->read_threads_exiting) {

drivers/md/dm-vdo/indexer/volume.c

407

queue_entry = reserve_read_queue_entry(&volume->page_cache);

drivers/md/dm-vdo/indexer/volume.c

411

uds_wait_cond(&volume->read_threads_cond, &volume->read_threads_mutex);

drivers/md/dm-vdo/indexer/volume.c

417

static int init_chapter_index_page(const struct volume *volume, u8 *index_page,

drivers/md/dm-vdo/indexer/volume.c

425

struct index_geometry *geometry = volume->geometry;

drivers/md/dm-vdo/indexer/volume.c

429

index_page, volume->nonce);

drivers/md/dm-vdo/indexer/volume.c

430

if (volume->lookup_mode == LOOKUP_FOR_REBUILD)

drivers/md/dm-vdo/indexer/volume.c

439

uds_get_list_number_bounds(volume->index_page_map, chapter, index_page_number,

drivers/md/dm-vdo/indexer/volume.c

449

(unsigned long long) volume->index_page_map->last_update);

drivers/md/dm-vdo/indexer/volume.c

459

static int initialize_index_page(const struct volume *volume, u32 physical_page,

drivers/md/dm-vdo/indexer/volume.c

462

u32 chapter = map_to_chapter_number(volume->geometry, physical_page);

drivers/md/dm-vdo/indexer/volume.c

463

u32 index_page_number = map_to_page_number(volume->geometry, physical_page);

drivers/md/dm-vdo/indexer/volume.c

465

return init_chapter_index_page(volume, dm_bufio_get_block_data(page->buffer),

drivers/md/dm-vdo/indexer/volume.c

506

static int search_page(struct cached_page *page, const struct volume *volume,

drivers/md/dm-vdo/indexer/volume.c

513

if (is_record_page(volume->geometry, physical_page)) {

drivers/md/dm-vdo/indexer/volume.c

515

&request->record_name, volume->geometry,

drivers/md/dm-vdo/indexer/volume.c

522

volume->geometry,

drivers/md/dm-vdo/indexer/volume.c

541

static int process_entry(struct volume *volume, struct queued_read *entry)

drivers/md/dm-vdo/indexer/volume.c

554

page = select_victim_in_cache(&volume->page_cache);

drivers/md/dm-vdo/indexer/volume.c

556

mutex_unlock(&volume->read_threads_mutex);

drivers/md/dm-vdo/indexer/volume.c

557

page_data = dm_bufio_read(volume->client, page_number, &page->buffer);

drivers/md/dm-vdo/indexer/volume.c

558

mutex_lock(&volume->read_threads_mutex);

drivers/md/dm-vdo/indexer/volume.c

564

cancel_page_in_cache(&volume->page_cache, page_number, page);

drivers/md/dm-vdo/indexer/volume.c

570

cancel_page_in_cache(&volume->page_cache, page_number, page);

drivers/md/dm-vdo/indexer/volume.c

574

if (!is_record_page(volume->geometry, page_number)) {

drivers/md/dm-vdo/indexer/volume.c

575

result = initialize_index_page(volume, page_number, page);

drivers/md/dm-vdo/indexer/volume.c

578

cancel_page_in_cache(&volume->page_cache, page_number, page);

drivers/md/dm-vdo/indexer/volume.c

583

result = put_page_in_cache(&volume->page_cache, page_number, page);

drivers/md/dm-vdo/indexer/volume.c

586

cancel_page_in_cache(&volume->page_cache, page_number, page);

drivers/md/dm-vdo/indexer/volume.c

592

result = search_page(page, volume, request, page_number);

drivers/md/dm-vdo/indexer/volume.c

599

static void release_queued_requests(struct volume *volume, struct queued_read *entry,

drivers/md/dm-vdo/indexer/volume.c

602

struct page_cache *cache = &volume->page_cache;

drivers/md/dm-vdo/indexer/volume.c

620

uds_broadcast_cond(&volume->read_threads_read_done_cond);

drivers/md/dm-vdo/indexer/volume.c

625

struct volume *volume = arg;

drivers/md/dm-vdo/indexer/volume.c

628

mutex_lock(&volume->read_threads_mutex);

drivers/md/dm-vdo/indexer/volume.c

633

queue_entry = wait_to_reserve_read_queue_entry(volume);

drivers/md/dm-vdo/indexer/volume.c

634

if (volume->read_threads_exiting)

drivers/md/dm-vdo/indexer/volume.c

637

result = process_entry(volume, queue_entry);

drivers/md/dm-vdo/indexer/volume.c

638

release_queued_requests(volume, queue_entry, result);

drivers/md/dm-vdo/indexer/volume.c

640

mutex_unlock(&volume->read_threads_mutex);

drivers/md/dm-vdo/indexer/volume.c

693

static int read_page_locked(struct volume *volume, u32 physical_page,

drivers/md/dm-vdo/indexer/volume.c

700

page = select_victim_in_cache(&volume->page_cache);

drivers/md/dm-vdo/indexer/volume.c

701

page_data = dm_bufio_read(volume->client, physical_page, &page->buffer);

drivers/md/dm-vdo/indexer/volume.c

707

cancel_page_in_cache(&volume->page_cache, physical_page, page);

drivers/md/dm-vdo/indexer/volume.c

711

if (!is_record_page(volume->geometry, physical_page)) {

drivers/md/dm-vdo/indexer/volume.c

712

result = initialize_index_page(volume, physical_page, page);

drivers/md/dm-vdo/indexer/volume.c

714

if (volume->lookup_mode != LOOKUP_FOR_REBUILD)

drivers/md/dm-vdo/indexer/volume.c

716

cancel_page_in_cache(&volume->page_cache, physical_page, page);

drivers/md/dm-vdo/indexer/volume.c

721

result = put_page_in_cache(&volume->page_cache, physical_page, page);

drivers/md/dm-vdo/indexer/volume.c

724

cancel_page_in_cache(&volume->page_cache, physical_page, page);

drivers/md/dm-vdo/indexer/volume.c

733

static int get_volume_page_locked(struct volume *volume, u32 physical_page,

drivers/md/dm-vdo/indexer/volume.c

739

get_page_from_cache(&volume->page_cache, physical_page, &page);

drivers/md/dm-vdo/indexer/volume.c

741

result = read_page_locked(volume, physical_page, &page);

drivers/md/dm-vdo/indexer/volume.c

745

make_page_most_recent(&volume->page_cache, page);

drivers/md/dm-vdo/indexer/volume.c

753

static int get_volume_page_protected(struct volume *volume, struct uds_request *request,

drivers/md/dm-vdo/indexer/volume.c

759

get_page_from_cache(&volume->page_cache, physical_page, &page);

drivers/md/dm-vdo/indexer/volume.c

763

make_page_most_recent(&volume->page_cache, page);

drivers/md/dm-vdo/indexer/volume.c

771

end_pending_search(&volume->page_cache, zone_number);

drivers/md/dm-vdo/indexer/volume.c

772

mutex_lock(&volume->read_threads_mutex);

drivers/md/dm-vdo/indexer/volume.c

782

get_page_from_cache(&volume->page_cache, physical_page, &page);

drivers/md/dm-vdo/indexer/volume.c

784

enqueue_page_read(volume, request, physical_page);

drivers/md/dm-vdo/indexer/volume.c

790

mutex_unlock(&volume->read_threads_mutex);

drivers/md/dm-vdo/indexer/volume.c

791

begin_pending_search(&volume->page_cache, physical_page, zone_number);

drivers/md/dm-vdo/indexer/volume.c

800

begin_pending_search(&volume->page_cache, physical_page, zone_number);

drivers/md/dm-vdo/indexer/volume.c

801

mutex_unlock(&volume->read_threads_mutex);

drivers/md/dm-vdo/indexer/volume.c

806

static int get_volume_page(struct volume *volume, u32 chapter, u32 page_number,

drivers/md/dm-vdo/indexer/volume.c

810

u32 physical_page = map_to_physical_page(volume->geometry, chapter, page_number);

drivers/md/dm-vdo/indexer/volume.c

812

mutex_lock(&volume->read_threads_mutex);

drivers/md/dm-vdo/indexer/volume.c

813

result = get_volume_page_locked(volume, physical_page, page_ptr);

drivers/md/dm-vdo/indexer/volume.c

814

mutex_unlock(&volume->read_threads_mutex);

drivers/md/dm-vdo/indexer/volume.c

818

int uds_get_volume_record_page(struct volume *volume, u32 chapter, u32 page_number,

drivers/md/dm-vdo/indexer/volume.c

824

result = get_volume_page(volume, chapter, page_number, &page);

drivers/md/dm-vdo/indexer/volume.c

830

int uds_get_volume_index_page(struct volume *volume, u32 chapter, u32 page_number,

drivers/md/dm-vdo/indexer/volume.c

836

result = get_volume_page(volume, chapter, page_number, &page);

drivers/md/dm-vdo/indexer/volume.c

846

static int search_cached_index_page(struct volume *volume, struct uds_request *request,

drivers/md/dm-vdo/indexer/volume.c

853

u32 physical_page = map_to_physical_page(volume->geometry, chapter,

drivers/md/dm-vdo/indexer/volume.c

862

begin_pending_search(&volume->page_cache, physical_page, zone_number);

drivers/md/dm-vdo/indexer/volume.c

864

result = get_volume_page_protected(volume, request, physical_page, &page);

drivers/md/dm-vdo/indexer/volume.c

866

end_pending_search(&volume->page_cache, zone_number);

drivers/md/dm-vdo/indexer/volume.c

870

result = uds_search_chapter_index_page(&page->index_page, volume->geometry,

drivers/md/dm-vdo/indexer/volume.c

873

end_pending_search(&volume->page_cache, zone_number);

drivers/md/dm-vdo/indexer/volume.c

881

int uds_search_cached_record_page(struct volume *volume, struct uds_request *request,

drivers/md/dm-vdo/indexer/volume.c

885

struct index_geometry *geometry = volume->geometry;

drivers/md/dm-vdo/indexer/volume.c

902

physical_page = map_to_physical_page(volume->geometry, chapter, page_number);

drivers/md/dm-vdo/indexer/volume.c

910

begin_pending_search(&volume->page_cache, physical_page, zone_number);

drivers/md/dm-vdo/indexer/volume.c

912

result = get_volume_page_protected(volume, request, physical_page, &record_page);

drivers/md/dm-vdo/indexer/volume.c

914

end_pending_search(&volume->page_cache, zone_number);

drivers/md/dm-vdo/indexer/volume.c

922

end_pending_search(&volume->page_cache, zone_number);

drivers/md/dm-vdo/indexer/volume.c

926

void uds_prefetch_volume_chapter(const struct volume *volume, u32 chapter)

drivers/md/dm-vdo/indexer/volume.c

928

const struct index_geometry *geometry = volume->geometry;

drivers/md/dm-vdo/indexer/volume.c

931

dm_bufio_prefetch(volume->client, physical_page, geometry->pages_per_chapter);

drivers/md/dm-vdo/indexer/volume.c

934

int uds_read_chapter_index_from_volume(const struct volume *volume, u64 virtual_chapter,

drivers/md/dm-vdo/indexer/volume.c

940

const struct index_geometry *geometry = volume->geometry;

drivers/md/dm-vdo/indexer/volume.c

944

dm_bufio_prefetch(volume->client, physical_page, geometry->index_pages_per_chapter);

drivers/md/dm-vdo/indexer/volume.c

948

index_page = dm_bufio_read(volume->client, physical_page + i,

drivers/md/dm-vdo/indexer/volume.c

958

result = init_chapter_index_page(volume, index_page, physical_chapter, i,

drivers/md/dm-vdo/indexer/volume.c

967

int uds_search_volume_page_cache(struct volume *volume, struct uds_request *request,

drivers/md/dm-vdo/indexer/volume.c

972

uds_map_to_physical_chapter(volume->geometry, request->virtual_chapter);

drivers/md/dm-vdo/indexer/volume.c

976

index_page_number = uds_find_index_page_number(volume->index_page_map,

drivers/md/dm-vdo/indexer/volume.c

983

result = search_cached_index_page(volume, request, physical_chapter,

drivers/md/dm-vdo/indexer/volume.c

990

return uds_search_cached_record_page(volume, request, physical_chapter,

drivers/md/dm-vdo/indexer/volume.c

994

int uds_search_volume_page_cache_for_rebuild(struct volume *volume,

drivers/md/dm-vdo/indexer/volume.c

999

struct index_geometry *geometry = volume->geometry;

drivers/md/dm-vdo/indexer/volume.h

127

struct volume **new_volume);

drivers/md/dm-vdo/indexer/volume.h

129

void uds_free_volume(struct volume *volume);

drivers/md/dm-vdo/indexer/volume.h

131

int __must_check uds_replace_volume_storage(struct volume *volume,

drivers/md/dm-vdo/indexer/volume.h

135

int __must_check uds_find_volume_chapter_boundaries(struct volume *volume,

drivers/md/dm-vdo/indexer/volume.h

139

int __must_check uds_search_volume_page_cache(struct volume *volume,

drivers/md/dm-vdo/indexer/volume.h

143

int __must_check uds_search_volume_page_cache_for_rebuild(struct volume *volume,

drivers/md/dm-vdo/indexer/volume.h

148

int __must_check uds_search_cached_record_page(struct volume *volume,

drivers/md/dm-vdo/indexer/volume.h

152

void uds_forget_chapter(struct volume *volume, u64 chapter);

drivers/md/dm-vdo/indexer/volume.h

154

int __must_check uds_write_chapter(struct volume *volume,

drivers/md/dm-vdo/indexer/volume.h

158

void uds_prefetch_volume_chapter(const struct volume *volume, u32 chapter);

drivers/md/dm-vdo/indexer/volume.h

160

int __must_check uds_read_chapter_index_from_volume(const struct volume *volume,

drivers/md/dm-vdo/indexer/volume.h

165

int __must_check uds_get_volume_record_page(struct volume *volume, u32 chapter,

drivers/md/dm-vdo/indexer/volume.h

168

int __must_check uds_get_volume_index_page(struct volume *volume, u32 chapter,

drivers/media/dvb-frontends/drx39xyj/drx_driver.h

1463

s16 volume; /*< volume, range -114 to 12 dB */

drivers/media/dvb-frontends/drx39xyj/drx_driver.h

1659

s16 volume; /* dB */

drivers/media/dvb-frontends/drx39xyj/drx_driver.h

1679

struct drx_cfg_aud_volume volume;

drivers/media/i2c/cx25840/cx25840-audio.c

468

static void set_volume(struct i2c_client *client, int volume)

drivers/media/i2c/cx25840/cx25840-audio.c

473

vol = volume >> 9;

drivers/media/i2c/cx25840/cx25840-audio.c

535

set_volume(client, state->volume->val);

drivers/media/i2c/cx25840/cx25840-core.c

3916

state->volume = v4l2_ctrl_new_std(&state->hdl,

drivers/media/i2c/cx25840/cx25840-core.c

3943

v4l2_ctrl_cluster(2, &state->volume);

drivers/media/i2c/cx25840/cx25840-core.h

77

struct v4l2_ctrl *volume;

drivers/media/i2c/msp3400-driver.c

343

state->volume->val);

drivers/media/i2c/msp3400-driver.c

391

v4l2_ctrl_lock(state->volume);

drivers/media/i2c/msp3400-driver.c

392

state->volume->val = state->volume->cur.val;

drivers/media/i2c/msp3400-driver.c

394

msp_s_ctrl(state->volume);

drivers/media/i2c/msp3400-driver.c

395

v4l2_ctrl_unlock(state->volume);

drivers/media/i2c/msp3400-driver.c

804

state->volume = v4l2_ctrl_new_std(hdl, &msp_ctrl_ops,

drivers/media/i2c/msp3400-driver.c

818

v4l2_ctrl_cluster(2, &state->volume);

drivers/media/i2c/msp3400-driver.h

102

struct v4l2_ctrl *volume;

drivers/media/i2c/sony-btf-mpx.c

125

u16 volume;

drivers/media/i2c/sony-btf-mpx.c

221

mpx_write(client, 0x12, 0x0000, mpx_audio_modes[mode].volume);

drivers/media/i2c/sony-btf-mpx.c

240

mpx_audio_modes[mode].volume);

drivers/media/i2c/tda7432.c

275

u8 bass, treble, volume;

drivers/media/i2c/tda7432.c

306

volume = 0x6f - ctrl->val;

drivers/media/i2c/tda7432.c

308

volume |= TDA7432_LD_ON;

drivers/media/i2c/tda7432.c

310

tda7432_write(sd, TDA7432_VL, volume);

drivers/media/i2c/tvaudio.c

117

struct v4l2_ctrl *volume;

drivers/media/i2c/tvaudio.c

1759

u32 volume, balance;

drivers/media/i2c/tvaudio.c

1762

volume = chip->volume->val;

drivers/media/i2c/tvaudio.c

1764

left = (min(65536U - balance, 32768U) * volume) / 32768U;

drivers/media/i2c/tvaudio.c

1765

right = (min(balance, 32768U) * volume) / 32768U;

drivers/media/i2c/tvaudio.c

2009

chip->volume = v4l2_ctrl_new_std(&chip->hdl,

drivers/media/i2c/tvaudio.c

2016

v4l2_ctrl_cluster(2, &chip->volume);

drivers/media/i2c/wm8739.c

102

work_l = (min(65536 - state->balance->val, 32768) * state->volume->val) / 32768;

drivers/media/i2c/wm8739.c

103

work_r = (min(state->balance->val, 32768) * state->volume->val) / 32768;

drivers/media/i2c/wm8739.c

199

state->volume = v4l2_ctrl_new_std(&state->hdl, &wm8739_ctrl_ops,

drivers/media/i2c/wm8739.c

212

v4l2_ctrl_cluster(3, &state->volume);

drivers/media/i2c/wm8739.c

45

struct v4l2_ctrl *volume;

drivers/media/i2c/wm8775.c

86

u16 volume = (u16)state->vol->val;

drivers/media/i2c/wm8775.c

90

vol_l = (min(65536 - balance, 32768) * volume) >> 23;

drivers/media/i2c/wm8775.c

91

vol_r = (min(balance, (u16)32768) * volume) >> 23;

drivers/media/pci/bt8xx/bttv-audio-hook.c

15

void winview_volume(struct bttv *btv, __u16 volume)

drivers/media/pci/bt8xx/bttv-audio-hook.c

21

vol = 32 - ((volume>>11));

drivers/media/pci/bt8xx/bttv-audio-hook.h

12

void winview_volume (struct bttv *btv, __u16 volume);

drivers/media/pci/bt8xx/bttv.h

219

void (*volume_gpio)(struct bttv *btv, __u16 volume);

drivers/media/pci/bt8xx/bttvp.h

335

void (*volume_gpio)(struct bttv *btv, __u16 volume);

drivers/media/pci/cx18/cx18-av-audio.c

331

static void set_volume(struct cx18 *cx, int volume)

drivers/media/pci/cx18/cx18-av-audio.c

334

int vol = volume >> 9;

drivers/media/pci/cx18/cx18-av-core.c

1330

state->volume = v4l2_ctrl_new_std(&state->hdl,

drivers/media/pci/cx18/cx18-av-core.c

251

state->volume->cur.val = state->volume->default_value = default_volume;

drivers/media/pci/cx18/cx18-av-core.h

86

struct v4l2_ctrl *volume;

drivers/media/pci/cx88/cx88-tvaudio.c

126

u32 volume;

drivers/media/pci/cx88/cx88-tvaudio.c

154

volume = cx_sread(SHADOW_AUD_VOL_CTL);

drivers/media/pci/cx88/cx88-tvaudio.c

155

cx_swrite(SHADOW_AUD_VOL_CTL, AUD_VOL_CTL, volume);

drivers/media/radio/radio-isa.c

124

isa->volume ? isa->volume->val : 0);

drivers/media/radio/radio-isa.c

220

isa->volume = v4l2_ctrl_new_std(&isa->hdl, &radio_isa_ctrl_ops,

drivers/media/radio/radio-isa.c

281

ops->s_mute_volume(isa, true, isa->volume ? isa->volume->cur.val : 0);

drivers/media/radio/radio-isa.h

32

struct v4l2_ctrl *volume;

drivers/media/radio/radio-isa.h

53

int (*s_mute_volume)(struct radio_isa_card *isa, bool mute, int volume);

drivers/media/radio/radio-ma901.c

136

radio->volume = vol_to_set;

drivers/media/radio/radio-ma901.c

82

u16 volume;

drivers/media/radio/radio-sf16fmr2.c

153

int volume, balance, left, right;

drivers/media/radio/radio-sf16fmr2.c

157

volume = ctrl->val;

drivers/media/radio/radio-sf16fmr2.c

162

volume = fmr2->volume->cur.val;

drivers/media/radio/radio-sf16fmr2.c

168

left = right = volume;

drivers/media/radio/radio-sf16fmr2.c

190

fmr2->volume = v4l2_ctrl_new_std(&tea->ctrl_handler, &fmr2_ctrl_ops, V4L2_CID_AUDIO_VOLUME, 0, 68, 2, 56);

drivers/media/radio/radio-sf16fmr2.c

35

struct v4l2_ctrl *volume;

drivers/media/test-drivers/vivid/vivid-core.h

321

struct v4l2_ctrl *volume;

drivers/media/test-drivers/vivid/vivid-ctrls.c

1686

dev->volume = v4l2_ctrl_new_std(hdl_user_aud, NULL,

drivers/media/test-drivers/vivid/vivid-kthread-cap.c

519

dev->volume->cur.val, dev->mute->cur.val);

drivers/media/usb/em28xx/em28xx-core.c

459

vol = (0x1f - dev->volume) | ((0x1f - dev->volume) << 8);

drivers/media/usb/em28xx/em28xx-video.c

1324

dev->volume = ctrl->val;

drivers/media/usb/em28xx/em28xx-video.c

1343

dev->volume = ctrl->val;

drivers/media/usb/em28xx/em28xx-video.c

2700

dev->volume = 0x1f;

drivers/media/usb/em28xx/em28xx.h

693

int volume;

drivers/media/usb/pvrusb2/pvrusb2-hdw-internal.h

354

VCREATE_DATA(volume);

drivers/media/usb/pvrusb2/pvrusb2-hdw.c

1023

DEFREF(volume),

drivers/media/usb/pvrusb2/pvrusb2-hdw.c

2878

PVR2_SUBDEV_SET_CONTROL(hdw, V4L2_CID_AUDIO_VOLUME, volume);

drivers/media/usb/pvrusb2/pvrusb2-hdw.c

974

VCREATE_FUNCS(volume)

drivers/message/fusion/mptbase.c

5151

int volume;

drivers/message/fusion/mptbase.c

5158

volume = pRaidEventData->VolumeID;

drivers/message/fusion/mptbase.c

5173

ioc->name, disk, volume);

drivers/message/fusion/mptbase.c

5176

ioc->name, volume);

drivers/platform/x86/lenovo/thinkpad_acpi.c

12050

TPACPI_PARAM(volume);

drivers/s390/block/dasd_eckd.c

1601

prssdp->volume = private->conf.ned->unit_addr;

drivers/s390/block/dasd_eckd.c

5974

prssdp->volume = private->conf.ned->unit_addr;

drivers/s390/block/dasd_eckd.h

542

unsigned char volume;

drivers/staging/media/av7110/av7110.c

2664

av7110->mixer.volume_left = volume;

drivers/staging/media/av7110/av7110.c

2665

av7110->mixer.volume_right = volume;

drivers/staging/media/av7110/av7110.c

65

static int volume = 255;

drivers/staging/media/av7110/av7110.c

84

module_param(volume, int, 0444);

drivers/staging/media/av7110/av7110.c

85

MODULE_PARM_DESC(volume, "initial volume: default 255 (range 0-255)");

drivers/staging/vc04_services/bcm2835-audio/bcm2835-ctl.c

60

ucontrol->value.integer.value[0] = chip->volume;

drivers/staging/vc04_services/bcm2835-audio/bcm2835-ctl.c

79

valp = &chip->volume;

drivers/staging/vc04_services/bcm2835-audio/bcm2835-pcm.c

339

chip->volume = 0;

drivers/staging/vc04_services/bcm2835-audio/bcm2835-vchiq.c

267

m.control.volume = CHIP_MIN_VOLUME;

drivers/staging/vc04_services/bcm2835-audio/bcm2835-vchiq.c

269

m.control.volume = alsa2chip(chip->volume);

drivers/staging/vc04_services/bcm2835-audio/bcm2835.h

58

int volume;

drivers/staging/vc04_services/bcm2835-audio/vc_vchi_audioserv_defs.h

41

u32 volume;

drivers/usb/gadget/function/f_uac1.c

515

s16 volume;

drivers/usb/gadget/function/f_uac1.c

517

u_audio_get_volume(audio, is_playback, &volume);

drivers/usb/gadget/function/f_uac1.c

519

c = cpu_to_le16(volume);

drivers/usb/gadget/function/f_uac1.c

711

s16 volume;

drivers/usb/gadget/function/f_uac1.c

713

volume = le16_to_cpu(*c);

drivers/usb/gadget/function/f_uac1.c

714

u_audio_set_volume(audio, is_playback, volume);

drivers/usb/gadget/function/f_uac2.c

1577

s16 volume;

drivers/usb/gadget/function/f_uac2.c

1581

u_audio_get_volume(agdev, is_playback, &volume);

drivers/usb/gadget/function/f_uac2.c

1582

c.wCUR = cpu_to_le16(volume);

drivers/usb/gadget/function/f_uac2.c

1755

s16 volume;

drivers/usb/gadget/function/f_uac2.c

1757

volume = le16_to_cpu(c->wCUR);

drivers/usb/gadget/function/f_uac2.c

1758

u_audio_set_volume(agdev, is_playback, volume);

drivers/usb/gadget/function/u_audio.c

1045

(prm->volume - prm->volume_min) / prm->volume_res;

drivers/usb/gadget/function/u_audio.c

1058

s16 volume;

drivers/usb/gadget/function/u_audio.c

1065

volume = (val * prm->volume_res) + prm->volume_min;

drivers/usb/gadget/function/u_audio.c

1066

volume = clamp(volume, prm->volume_min, prm->volume_max);

drivers/usb/gadget/function/u_audio.c

1067

if (volume != prm->volume) {

drivers/usb/gadget/function/u_audio.c

1068

prm->volume = volume;

drivers/usb/gadget/function/u_audio.c

1386

prm->volume = fu->volume_max;

drivers/usb/gadget/function/u_audio.c

63

s16 volume;

drivers/usb/gadget/function/u_audio.c

806

*val = prm->volume;

drivers/usb/gadget/function/u_audio.c

827

if (prm->volume != val) {

drivers/usb/gadget/function/u_audio.c

828

prm->volume = val;

fs/affs/super.c

175

char volume[32]; /* Vol. prefix for absolute symlinks */

fs/affs/super.c

257

strscpy(ctx->volume, param->string, 32);

fs/affs/super.c

348

memcpy(sbi->s_volume, ctx->volume, 32);

fs/affs/super.c

545

memcpy(sbi->s_volume, ctx->volume, 32);

fs/affs/super.c

631

memcpy(ctx->volume, sbi->s_volume, 32);

fs/affs/super.c

638

ctx->volume[0] = ':';

fs/afs/callback.c

114

struct afs_volume *volume = NULL;

fs/afs/callback.c

128

volume = rb_entry(p, struct afs_volume, cell_node);

fs/afs/callback.c

130

if (volume->vid < vid)

fs/afs/callback.c

132

else if (volume->vid > vid)

fs/afs/callback.c

136

volume = NULL;

fs/afs/callback.c

139

if (volume && afs_try_get_volume(volume, afs_volume_trace_get_callback))

fs/afs/callback.c

147

return volume;

fs/afs/callback.c

159

struct afs_volume *volume)

fs/afs/callback.c

162

struct afs_server_list *slist = rcu_dereference(volume->servers);

fs/afs/callback.c

165

write_lock(&volume->cb_v_break_lock);

fs/afs/callback.c

170

volume->cb_expires_at = AFS_NO_CB_PROMISE;

fs/afs/callback.c

172

cb_v_break = atomic_inc_return_release(&volume->cb_v_break);

fs/afs/callback.c

173

trace_afs_cb_v_break(volume->vid, cb_v_break, afs_cb_break_for_volume_callback);

fs/afs/callback.c

175

write_unlock(&volume->cb_v_break_lock);

fs/afs/callback.c

178

if (!list_empty(&volume->open_mmaps))

fs/afs/callback.c

179

afs_volume_init_callback(volume);

fs/afs/callback.c

189

struct afs_volume *volume,

fs/afs/callback.c

200

sb = rcu_dereference(volume->sb);

fs/afs/callback.c

218

struct afs_volume *volume;

fs/afs/callback.c

223

volume = afs_lookup_volume_rcu(server->cell, vid);

fs/afs/callback.c

225

afs_break_volume_callback(server, volume);

fs/afs/callback.c

241

if (volume)

fs/afs/callback.c

242

afs_break_one_callback(server, volume, &cbb->fid);

fs/afs/callback.c

250

afs_put_volume(volume, afs_volume_trace_put_callback);

fs/afs/callback.c

36

static void afs_volume_init_callback(struct afs_volume *volume)

fs/afs/callback.c

40

down_read(&volume->open_mmaps_lock);

fs/afs/callback.c

42

list_for_each_entry(vnode, &volume->open_mmaps, cb_mmap_link) {

fs/afs/callback.c

43

if (vnode->cb_v_check != atomic_read(&volume->cb_v_break)) {

fs/afs/callback.c

49

up_read(&volume->open_mmaps_lock);

fs/afs/callback.c

64

se->volume->cb_expires_at = AFS_NO_CB_PROMISE;

fs/afs/callback.c

65

trace_afs_cb_v_break(se->volume->vid, atomic_read(&se->volume->cb_v_break),

fs/afs/callback.c

67

if (!list_empty(&se->volume->open_mmaps))

fs/afs/callback.c

68

afs_volume_init_callback(se->volume);

fs/afs/callback.c

84

vnode->cb_v_check = atomic_read(&vnode->volume->cb_v_break);

fs/afs/cmservice.c

599

cb->fid.vid = xdr_to_u64(bp->volume);

fs/afs/dir.c

1081

key = afs_request_key(AFS_FS_S(dentry->d_sb)->volume->cell);

fs/afs/dir.c

1326

op = afs_alloc_operation(NULL, dvnode->volume);

fs/afs/dir.c

1418

op = afs_alloc_operation(NULL, dvnode->volume);

fs/afs/dir.c

1568

op = afs_alloc_operation(NULL, dvnode->volume);

fs/afs/dir.c

1651

op = afs_alloc_operation(NULL, dvnode->volume);

fs/afs/dir.c

1730

op = afs_alloc_operation(NULL, dvnode->volume);

fs/afs/dir.c

1797

op = afs_alloc_operation(NULL, dvnode->volume);

fs/afs/dir.c

2083

op = afs_alloc_operation(NULL, orig_dvnode->volume);

fs/afs/dir.c

609

.fid.vid = as->volume->vid

fs/afs/dir.c

745

struct afs_volume *volume = dvnode->volume;

fs/afs/dir.c

750

if (!test_bit(AFS_VOLUME_MAYBE_NO_IBULK, &volume->flags))

fs/afs/dir.c

754

slist = rcu_dereference(volume->servers);

fs/afs/dir.c

823

op = afs_alloc_operation(NULL, dvnode->volume);

fs/afs/dir_silly.c

208

op = afs_alloc_operation(NULL, dvnode->volume);

fs/afs/dir_silly.c

68

op = afs_alloc_operation(key, dvnode->volume);

fs/afs/dynroot.c

37

vnode->volume = as->volume;

fs/afs/dynroot.c

376

if (as->volume)

fs/afs/dynroot.c

377

fid.vid = as->volume->vid;

fs/afs/file.c

127

key = afs_request_key(vnode->volume->cell);

fs/afs/file.c

339

vnode->volume->name,

fs/afs/file.c

345

op = afs_alloc_operation(key, vnode->volume);

fs/afs/file.c

392

struct key *key = afs_request_key(vnode->volume->cell);

fs/afs/file.c

465

down_write(&vnode->volume->open_mmaps_lock);

fs/afs/file.c

468

list_add_tail(&vnode->cb_mmap_link, &vnode->volume->open_mmaps);

fs/afs/file.c

470

up_write(&vnode->volume->open_mmaps_lock);

fs/afs/file.c

479

down_write(&vnode->volume->open_mmaps_lock);

fs/afs/file.c

488

up_write(&vnode->volume->open_mmaps_lock);

fs/afs/flock.c

197

vnode->volume->name,

fs/afs/flock.c

203

op = afs_alloc_operation(key, vnode->volume);

fs/afs/flock.c

228

vnode->volume->name,

fs/afs/flock.c

234

op = afs_alloc_operation(key, vnode->volume);

fs/afs/flock.c

259

vnode->volume->name,

fs/afs/flock.c

265

op = afs_alloc_operation(key, vnode->volume);

fs/afs/fs_operation.c

18

struct afs_operation *afs_alloc_operation(struct key *key, struct afs_volume *volume)

fs/afs/fs_operation.c

251

op->cb_v_break = atomic_read(&op->volume->cb_v_break);

fs/afs/fs_operation.c

29

key = afs_request_key(volume->cell);

fs/afs/fs_operation.c

366

afs_put_volume(op->volume, afs_volume_trace_put_put_op);

fs/afs/fs_operation.c

39

op->volume = afs_get_volume(volume, afs_volume_trace_get_new_op);

fs/afs/fs_operation.c

40

op->net = volume->cell->net;

fs/afs/fs_operation.c

41

op->cb_v_break = atomic_read(&volume->cb_v_break);

fs/afs/fs_operation.c

42

op->pre_volsync.creation = volume->creation_time;

fs/afs/fs_operation.c

43

op->pre_volsync.update = volume->update_time;

fs/afs/fsclient.c

1923

set_bit(AFS_VOLUME_MAYBE_NO_IBULK, &call->op->volume->flags);

fs/afs/inode.c

311

if (vnode->cb_ro_snapshot == atomic_read(&vnode->volume->cb_ro_snapshot) &&

fs/afs/inode.c

369

if (op->volume->type == AFSVL_RWVOL)

fs/afs/inode.c

456

vnode->volume->name,

fs/afs/inode.c

460

op = afs_alloc_operation(key, vnode->volume);

fs/afs/inode.c

509

vnode->volume = as->volume;

fs/afs/inode.c

548

vnode->volume->cache,

fs/afs/inode.c

611

vnode->volume = as->volume;

fs/afs/inode.c

612

vnode->fid.vid = as->volume->vid;

fs/afs/inode.c

632

_enter(",{%llx},,", as->volume->vid);

fs/afs/inode.c

640

_debug("GOT ROOT INODE %p { vl=%llx }", inode, as->volume->vid);

fs/afs/inode.c

645

vnode->cb_v_check = atomic_read(&as->volume->cb_v_break);

fs/afs/inode.c

648

op = afs_alloc_operation(key, as->volume);

fs/afs/inode.c

688

if (vnode->volume &&

fs/afs/inode.c

691

key = afs_request_key(vnode->volume->cell);

fs/afs/inode.c

904

vnode->volume);

fs/afs/internal.h

1044

atomic_read(&vnode->volume->cb_ro_snapshot) +

fs/afs/internal.h

1045

atomic_read(&vnode->volume->cb_scrub));

fs/afs/internal.h

1588

struct afs_server_list *afs_alloc_server_list(struct afs_volume *volume,

fs/afs/internal.h

1592

void afs_attach_volume_to_servers(struct afs_volume *volume, struct afs_server_list *slist);

fs/afs/internal.h

1593

void afs_reattach_volume_to_servers(struct afs_volume *volume, struct afs_server_list *slist,

fs/afs/internal.h

1595

void afs_detach_volume_from_servers(struct afs_volume *volume, struct afs_server_list *slist);

fs/afs/internal.h

1675

bool afs_try_get_volume(struct afs_volume *volume, enum afs_volume_trace reason);

fs/afs/internal.h

1677

void afs_put_volume(struct afs_volume *volume, enum afs_volume_trace reason);

fs/afs/internal.h

252

struct afs_volume *volume; /* volume record */

fs/afs/internal.h

598

struct afs_volume *volume;

fs/afs/internal.h

62

struct afs_volume *volume; /* volume record */

fs/afs/internal.h

689

struct afs_volume *volume; /* volume on which vnode resides */

fs/afs/internal.h

869

struct afs_volume *volume; /* Volume being accessed */

fs/afs/mntpt.c

148

if (src_as->volume && src_as->volume->type == AFSVL_BACKVOL &&

fs/afs/mntpt.c

85

if (src_as->volume && src_as->volume->type == AFSVL_RWVOL) {

fs/afs/protocol_yfs.h

84

struct yfs_xdr_u64 volume;

fs/afs/rotate.c

126

op->volume->vid, op->volume->name, &op->server->uuid, m);

fs/afs/rotate.c

165

op->debug_id, op->nr_iterations, op->volume->vid,

fs/afs/rotate.c

243

write_lock(&op->volume->servers_lock);

fs/afs/rotate.c

245

write_unlock(&op->volume->servers_lock);

fs/afs/rotate.c

247

set_bit(AFS_VOLUME_NEEDS_UPDATE, &op->volume->flags);

fs/afs/rotate.c

248

error = afs_check_volume_status(op->volume, op);

fs/afs/rotate.c

254

if (test_bit(AFS_VOLUME_DELETED, &op->volume->flags)) {

fs/afs/rotate.c

262

if (rcu_access_pointer(op->volume->servers) == op->server_list) {

fs/afs/rotate.c

386

set_bit(AFS_VOLUME_WAIT, &op->volume->flags);

fs/afs/rotate.c

387

set_bit(AFS_VOLUME_NEEDS_UPDATE, &op->volume->flags);

fs/afs/rotate.c

388

error = afs_check_volume_status(op->volume, op);

fs/afs/rotate.c

403

if (rcu_access_pointer(op->volume->servers) == op->server_list) {

fs/afs/rotate.c

413

if (op->volume->type != AFSVL_RWVOL)

fs/afs/rotate.c

43

read_lock(&op->volume->servers_lock);

fs/afs/rotate.c

45

rcu_dereference_protected(op->volume->servers,

fs/afs/rotate.c

46

lockdep_is_held(&op->volume->servers_lock)));

fs/afs/rotate.c

47

read_unlock(&op->volume->servers_lock);

fs/afs/rotate.c

495

error = afs_check_volume_status(op->volume, op);

fs/afs/rotate.c

505

_debug("__ VOL %llx __", op->volume->vid);

fs/afs/rotate.c

595

vnode->cb_v_check = atomic_read(&vnode->volume->cb_v_break);

fs/afs/security.c

346

if (key == vnode->volume->cell->anonymous_key) {

fs/afs/security.c

386

if (key == vnode->volume->cell->anonymous_key) {

fs/afs/security.c

443

key = afs_request_key_rcu(vnode->volume->cell);

fs/afs/security.c

452

key = afs_request_key(vnode->volume->cell);

fs/afs/server_list.c

100

afs_unuse_server_notime(volume->cell->net, server,

fs/afs/server_list.c

111

slist->servers[j].volume = volume;

fs/afs/server_list.c

125

afs_put_serverlist(volume->cell->net, slist);

fs/afs/server_list.c

157

void afs_attach_volume_to_servers(struct afs_volume *volume, struct afs_server_list *slist)

fs/afs/server_list.c

164

down_write(&volume->cell->vs_lock);

fs/afs/server_list.c

172

if (volume->vid <= pe->volume->vid)

fs/afs/server_list.c

179

up_write(&volume->cell->vs_lock);

fs/afs/server_list.c

187

void afs_reattach_volume_to_servers(struct afs_volume *volume, struct afs_server_list *new,

fs/afs/server_list.c

192

down_write(&volume->cell->vs_lock);

fs/afs/server_list.c

218

if (volume->vid <= s->volume->vid)

fs/afs/server_list.c

229

up_write(&volume->cell->vs_lock);

fs/afs/server_list.c

235

void afs_detach_volume_from_servers(struct afs_volume *volume, struct afs_server_list *slist)

fs/afs/server_list.c

242

down_write(&volume->cell->vs_lock);

fs/afs/server_list.c

248

up_write(&volume->cell->vs_lock);

fs/afs/server_list.c

27

struct afs_server_list *afs_alloc_server_list(struct afs_volume *volume,

fs/afs/server_list.c

33

unsigned int type_mask = 1 << volume->type;

fs/afs/server_list.c

82

server = afs_lookup_server(volume->cell, key, &vldb->fs_server[i],

fs/afs/super.c

159

struct afs_volume *volume = as->volume;

fs/afs/super.c

169

switch (volume->type) {

fs/afs/super.c

174

if (volume->type_force)

fs/afs/super.c

183

seq_printf(m, "%c%s:%s%s", pref, cell->name, volume->name, suf);

fs/afs/super.c

358

struct afs_volume *volume;

fs/afs/super.c

382

if (ctx->volume) {

fs/afs/super.c

383

afs_put_volume(ctx->volume, afs_volume_trace_put_validate_fc);

fs/afs/super.c

384

ctx->volume = NULL;

fs/afs/super.c

403

volume = afs_create_volume(ctx);

fs/afs/super.c

404

if (IS_ERR(volume))

fs/afs/super.c

405

return PTR_ERR(volume);

fs/afs/super.c

407

ctx->volume = volume;

fs/afs/super.c

408

if (volume->type != AFSVL_RWVOL) {

fs/afs/super.c

426

as->volume &&

fs/afs/super.c

427

as->volume->vid == ctx->volume->vid &&

fs/afs/super.c

472

sprintf(sb->s_id, "%llu", as->volume->vid);

fs/afs/super.c

473

afs_activate_volume(as->volume);

fs/afs/super.c

489

rcu_assign_pointer(as->volume->sb, sb);

fs/afs/super.c

513

as->volume = afs_get_volume(ctx->volume,

fs/afs/super.c

523

afs_put_volume(as->volume, afs_volume_trace_put_destroy_sbi);

fs/afs/super.c

537

if (as->volume)

fs/afs/super.c

538

rcu_assign_pointer(as->volume->sb, NULL);

fs/afs/super.c

540

if (as->volume)

fs/afs/super.c

541

afs_deactivate_volume(as->volume);

fs/afs/super.c

590

trace_afs_get_tree(as->cell, as->volume);

fs/afs/super.c

606

afs_put_volume(ctx->volume, afs_volume_trace_put_free_fc);

fs/afs/super.c

685

vnode->volume = NULL;

fs/afs/super.c

761

op = afs_alloc_operation(NULL, as->volume);

fs/afs/validation.c

122

const struct afs_volume *volume = vnode->volume;

fs/afs/validation.c

130

if (atomic_read(&volume->cb_v_check) != atomic_read(&volume->cb_v_break))

fs/afs/validation.c

136

else if (volume->cb_expires_at <= deadline)

fs/afs/validation.c

138

else if (vnode->cb_ro_snapshot != atomic_read(&volume->cb_ro_snapshot))

fs/afs/validation.c

140

else if (vnode->cb_scrub != atomic_read(&volume->cb_scrub))

fs/afs/validation.c

153

static bool __afs_is_server_excluded(struct afs_operation *op, struct afs_volume *volume)

fs/afs/validation.c

162

slist = rcu_dereference(volume->servers);

fs/afs/validation.c

179

static int afs_is_server_excluded(struct afs_operation *op, struct afs_volume *volume)

fs/afs/validation.c

183

if (__afs_is_server_excluded(op, volume))

fs/afs/validation.c

186

set_bit(AFS_VOLUME_NEEDS_UPDATE, &volume->flags);

fs/afs/validation.c

187

ret = afs_check_volume_status(op->volume, op);

fs/afs/validation.c

191

return __afs_is_server_excluded(op, volume);

fs/afs/validation.c

197

static int afs_update_volume_creation_time(struct afs_operation *op, struct afs_volume *volume)

fs/afs/validation.c

200

time64_t cur = volume->creation_time;

fs/afs/validation.c

205

_enter("%llx,%llx,%llx->%llx", volume->vid, cur, old, new);

fs/afs/validation.c

208

volume->creation_time = new;

fs/afs/validation.c

228

if (volume->type == AFSVL_RWVOL)

fs/afs/validation.c

230

if (volume->type == AFSVL_BACKVOL) {

fs/afs/validation.c

239

ret = afs_is_server_excluded(op, volume);

fs/afs/validation.c

243

snap = atomic_read(&volume->cb_ro_snapshot);

fs/afs/validation.c

244

trace_afs_cb_v_break(volume->vid, snap, afs_cb_break_volume_excluded);

fs/afs/validation.c

249

snap = atomic_inc_return(&volume->cb_ro_snapshot);

fs/afs/validation.c

250

trace_afs_cb_v_break(volume->vid, snap, afs_cb_break_for_vos_release);

fs/afs/validation.c

251

volume->creation_time = new;

fs/afs/validation.c

255

atomic_inc(&volume->cb_scrub);

fs/afs/validation.c

256

trace_afs_cb_v_break(volume->vid, 0, afs_cb_break_for_creation_regress);

fs/afs/validation.c

257

volume->creation_time = new;

fs/afs/validation.c

264

static void afs_update_volume_update_time(struct afs_operation *op, struct afs_volume *volume)

fs/afs/validation.c

267

time64_t cur = volume->update_time;

fs/afs/validation.c

271

_enter("%llx,%llx,%llx->%llx", volume->vid, cur, old, new);

fs/afs/validation.c

274

volume->update_time = new;

fs/afs/validation.c

296

atomic_inc(&volume->cb_scrub);

fs/afs/validation.c

297

trace_afs_cb_v_break(volume->vid, 0, reason);

fs/afs/validation.c

299

volume->update_time = new;

fs/afs/validation.c

303

static int afs_update_volume_times(struct afs_operation *op, struct afs_volume *volume)

fs/afs/validation.c

307

if (likely(op->volsync.creation == volume->creation_time &&

fs/afs/validation.c

308

op->volsync.update == volume->update_time))

fs/afs/validation.c

311

mutex_lock(&volume->volsync_lock);

fs/afs/validation.c

312

if (op->volsync.creation != volume->creation_time) {

fs/afs/validation.c

313

ret = afs_update_volume_creation_time(op, volume);

fs/afs/validation.c

317

if (op->volsync.update != volume->update_time)

fs/afs/validation.c

318

afs_update_volume_update_time(op, volume);

fs/afs/validation.c

320

mutex_unlock(&volume->volsync_lock);

fs/afs/validation.c

333

struct afs_volume *volume = op->volume;

fs/afs/validation.c

334

unsigned int cb_v_break = atomic_read(&volume->cb_v_break);

fs/afs/validation.c

335

unsigned int cb_v_check = atomic_read(&volume->cb_v_check);

fs/afs/validation.c

338

_enter("%llx", op->volume->vid);

fs/afs/validation.c

341

ret = afs_update_volume_times(op, volume);

fs/afs/validation.c

356

volume->cb_expires_at = expires_at;

fs/afs/validation.c

359

atomic_cmpxchg(&volume->cb_v_check, cb_v_check, op->cb_v_break);

fs/afs/validation.c

393

struct afs_volume *volume = vnode->volume;

fs/afs/validation.c

420

if (volume->cb_expires_at <= deadline ||

fs/afs/validation.c

421

atomic_read(&volume->cb_v_check) != atomic_read(&volume->cb_v_break)) {

fs/afs/validation.c

422

ret = mutex_lock_interruptible(&volume->cb_check_lock);

fs/afs/validation.c

428

cb_ro_snapshot = atomic_read(&volume->cb_ro_snapshot);

fs/afs/validation.c

429

cb_scrub = atomic_read(&volume->cb_scrub);

fs/afs/validation.c

436

volume->cb_expires_at <= deadline ||

fs/afs/validation.c

437

atomic_read(&volume->cb_v_check) != atomic_read(&volume->cb_v_break) ||

fs/afs/validation.c

454

mutex_unlock(&volume->cb_check_lock);

fs/afs/validation.c

458

cb_ro_snapshot = atomic_read(&volume->cb_ro_snapshot);

fs/afs/validation.c

459

cb_scrub = atomic_read(&volume->cb_scrub);

fs/afs/validation.c

479

mutex_unlock(&volume->cb_check_lock);

fs/afs/vl_alias.c

141

struct afs_volume *volume, *pvol = NULL;

fs/afs/vl_alias.c

157

volume = afs_sample_volume(cell, key, pvol->name, pvol->name_len);

fs/afs/vl_alias.c

158

if (IS_ERR(volume)) {

fs/afs/vl_alias.c

160

if (PTR_ERR(volume) != -ENOMEDIUM)

fs/afs/vl_alias.c

161

return PTR_ERR(volume);

fs/afs/vl_alias.c

170

if (pvol->vid == volume->vid) {

fs/afs/vl_alias.c

172

if (afs_compare_volume_slists(volume, pvol))

fs/afs/vl_alias.c

177

afs_put_volume(volume, afs_volume_trace_put_query_alias);

fs/afs/vl_alias.c

20

struct afs_volume *volume;

fs/afs/vl_alias.c

30

volume = afs_create_volume(&fc);

fs/afs/vl_alias.c

31

_leave(" = %p", volume);

fs/afs/vl_alias.c

32

return volume;

fs/afs/volume.c

100

INIT_WORK(&volume->destructor, afs_destroy_volume);

fs/afs/volume.c

101

rwlock_init(&volume->servers_lock);

fs/afs/volume.c

102

mutex_init(&volume->volsync_lock);

fs/afs/volume.c

103

mutex_init(&volume->cb_check_lock);

fs/afs/volume.c

104

rwlock_init(&volume->cb_v_break_lock);

fs/afs/volume.c

105

INIT_LIST_HEAD(&volume->open_mmaps);

fs/afs/volume.c

106

init_rwsem(&volume->open_mmaps_lock);

fs/afs/volume.c

107

memcpy(volume->name, vldb->name, vldb->name_len + 1);

fs/afs/volume.c

110

volume->vids[i] = vldb->vid[i];

fs/afs/volume.c

112

slist = afs_alloc_server_list(volume, params->key, vldb);

fs/afs/volume.c

119

rcu_assign_pointer(volume->servers, slist);

fs/afs/volume.c

120

trace_afs_volume(volume->debug_id, volume->vid, 1, afs_volume_trace_alloc);

fs/afs/volume.c

121

return volume;

fs/afs/volume.c

124

afs_put_cell(volume->cell, afs_cell_trace_put_vol);

fs/afs/volume.c

125

kfree(volume);

fs/afs/volume.c

137

struct afs_volume *candidate, *volume;

fs/afs/volume.c

143

volume = afs_insert_volume_into_cell(params->cell, candidate);

fs/afs/volume.c

144

if (volume == candidate)

fs/afs/volume.c

145

afs_attach_volume_to_servers(volume, slist);

fs/afs/volume.c

148

return volume;

fs/afs/volume.c

201

struct afs_volume *volume;

fs/afs/volume.c

210

volume = ERR_PTR(vldb->error);

fs/afs/volume.c

215

volume = ERR_PTR(-ENOMEDIUM);

fs/afs/volume.c

22

struct afs_volume *volume)

fs/afs/volume.c

227

volume = afs_lookup_volume(params, vldb);

fs/afs/volume.c

231

return volume;

fs/afs/volume.c

239

struct afs_volume *volume = container_of(work, struct afs_volume, destructor);

fs/afs/volume.c

240

struct afs_server_list *slist = rcu_access_pointer(volume->servers);

fs/afs/volume.c

242

_enter("%p", volume);

fs/afs/volume.c

245

ASSERTCMP(volume->cache, ==, NULL);

fs/afs/volume.c

248

afs_detach_volume_from_servers(volume, slist);

fs/afs/volume.c

249

afs_remove_volume_from_cell(volume);

fs/afs/volume.c

250

afs_put_serverlist(volume->cell->net, slist);

fs/afs/volume.c

251

afs_put_cell(volume->cell, afs_cell_trace_put_vol);

fs/afs/volume.c

252

trace_afs_volume(volume->debug_id, volume->vid, refcount_read(&volume->ref),

fs/afs/volume.c

254

kfree_rcu(volume, rcu);

fs/afs/volume.c

262

bool afs_try_get_volume(struct afs_volume *volume, enum afs_volume_trace reason)

fs/afs/volume.c

266

if (__refcount_inc_not_zero(&volume->ref, &r)) {

fs/afs/volume.c

267

trace_afs_volume(volume->debug_id, volume->vid, r + 1, reason);

fs/afs/volume.c

276

struct afs_volume *afs_get_volume(struct afs_volume *volume,

fs/afs/volume.c

279

if (volume) {

fs/afs/volume.c

282

__refcount_inc(&volume->ref, &r);

fs/afs/volume.c

283

trace_afs_volume(volume->debug_id, volume->vid, r + 1, reason);

fs/afs/volume.c

285

return volume;

fs/afs/volume.c

292

void afs_put_volume(struct afs_volume *volume, enum afs_volume_trace reason)

fs/afs/volume.c

294

if (volume) {

fs/afs/volume.c

295

unsigned int debug_id = volume->debug_id;

fs/afs/volume.c

296

afs_volid_t vid = volume->vid;

fs/afs/volume.c

300

zero = __refcount_dec_and_test(&volume->ref, &r);

fs/afs/volume.c

303

schedule_work(&volume->destructor);

fs/afs/volume.c

310

int afs_activate_volume(struct afs_volume *volume)

fs/afs/volume.c

317

volume->cell->name, volume->vid);

fs/afs/volume.c

33

if (p->vid < volume->vid) {

fs/afs/volume.c

330

volume->cache = vcookie;

fs/afs/volume.c

339

void afs_deactivate_volume(struct afs_volume *volume)

fs/afs/volume.c

341

_enter("%s", volume->name);

fs/afs/volume.c

344

fscache_relinquish_volume(volume->cache, NULL,

fs/afs/volume.c

345

test_bit(AFS_VOLUME_DELETED, &volume->flags));

fs/afs/volume.c

346

volume->cache = NULL;

fs/afs/volume.c

35

} else if (p->vid > volume->vid) {

fs/afs/volume.c

355

static int afs_update_volume_status(struct afs_volume *volume, struct key *key)

fs/afs/volume.c

367

idsz = snprintf(idbuf, sizeof(idbuf), "%llu", volume->vid);

fs/afs/volume.c

369

vldb = afs_vl_lookup_vldb(volume->cell, key, idbuf, idsz);

fs/afs/volume.c

376

if (vldb->name_len != volume->name_len ||

fs/afs/volume.c

377

memcmp(vldb->name, volume->name, vldb->name_len) != 0) {

fs/afs/volume.c

379

memcpy(volume->name, vldb->name, AFS_MAXVOLNAME);

fs/afs/volume.c

380

volume->name_len = vldb->name_len;

fs/afs/volume.c

384

new = afs_alloc_server_list(volume, key, vldb);

fs/afs/volume.c

39

volume = p;

fs/afs/volume.c

390

write_lock(&volume->servers_lock);

fs/afs/volume.c

393

old = rcu_dereference_protected(volume->servers,

fs/afs/volume.c

394

lockdep_is_held(&volume->servers_lock));

fs/afs/volume.c

396

new->seq = volume->servers_seq + 1;

fs/afs/volume.c

397

rcu_assign_pointer(volume->servers, new);

fs/afs/volume.c

399

volume->servers_seq++;

fs/afs/volume.c

405

volume->update_at = ktime_get_real_seconds() + 10 * 60;

fs/afs/volume.c

407

volume->update_at = ktime_get_real_seconds() + afs_volume_record_life;

fs/afs/volume.c

408

write_unlock(&volume->servers_lock);

fs/afs/volume.c

411

afs_reattach_volume_to_servers(volume, new, old);

fs/afs/volume.c

412

afs_put_serverlist(volume->cell->net, discard);

fs/afs/volume.c

424

int afs_check_volume_status(struct afs_volume *volume, struct afs_operation *op)

fs/afs/volume.c

43

set_bit(AFS_VOLUME_RM_TREE, &volume->flags);

fs/afs/volume.c

431

if (test_bit(AFS_VOLUME_WAIT, &volume->flags))

fs/afs/volume.c

433

if (volume->update_at <= ktime_get_real_seconds() ||

fs/afs/volume.c

434

test_bit(AFS_VOLUME_NEEDS_UPDATE, &volume->flags))

fs/afs/volume.c

44

rb_replace_node_rcu(&p->cell_node, &volume->cell_node, &cell->volumes);

fs/afs/volume.c

440

if (!test_and_set_bit_lock(AFS_VOLUME_UPDATING, &volume->flags)) {

fs/afs/volume.c

441

clear_bit(AFS_VOLUME_NEEDS_UPDATE, &volume->flags);

fs/afs/volume.c

442

ret = afs_update_volume_status(volume, op->key);

fs/afs/volume.c

444

set_bit(AFS_VOLUME_NEEDS_UPDATE, &volume->flags);

fs/afs/volume.c

445

clear_bit_unlock(AFS_VOLUME_WAIT, &volume->flags);

fs/afs/volume.c

446

clear_bit_unlock(AFS_VOLUME_UPDATING, &volume->flags);

fs/afs/volume.c

447

wake_up_bit(&volume->flags, AFS_VOLUME_WAIT);

fs/afs/volume.c

453

if (!test_bit(AFS_VOLUME_WAIT, &volume->flags)) {

fs/afs/volume.c

458

ret = wait_on_bit(&volume->flags, AFS_VOLUME_WAIT,

fs/afs/volume.c

48

rb_link_node_rcu(&volume->cell_node, parent, pp);

fs/afs/volume.c

49

rb_insert_color(&volume->cell_node, &cell->volumes);

fs/afs/volume.c

50

hlist_add_head_rcu(&volume->proc_link, &cell->proc_volumes);

fs/afs/volume.c

54

return volume;

fs/afs/volume.c

58

static void afs_remove_volume_from_cell(struct afs_volume *volume)

fs/afs/volume.c

60

struct afs_cell *cell = volume->cell;

fs/afs/volume.c

62

if (!hlist_unhashed(&volume->proc_link)) {

fs/afs/volume.c

63

trace_afs_volume(volume->debug_id, volume->vid, refcount_read(&volume->ref),

fs/afs/volume.c

66

hlist_del_rcu(&volume->proc_link);

fs/afs/volume.c

67

if (!test_and_set_bit(AFS_VOLUME_RM_TREE, &volume->flags))

fs/afs/volume.c

68

rb_erase(&volume->cell_node, &cell->volumes);

fs/afs/volume.c

81

struct afs_volume *volume;

fs/afs/volume.c

84

volume = kzalloc_obj(struct afs_volume);

fs/afs/volume.c

85

if (!volume)

fs/afs/volume.c

88

volume->debug_id = atomic_inc_return(&afs_volume_debug_id);

fs/afs/volume.c

89

volume->vid = vldb->vid[params->type];

fs/afs/volume.c

90

volume->update_at = ktime_get_real_seconds() + afs_volume_record_life;

fs/afs/volume.c

91

volume->cell = afs_get_cell(params->cell, afs_cell_trace_get_vol);

fs/afs/volume.c

92

volume->type = params->type;

fs/afs/volume.c

93

volume->type_force = params->force;

fs/afs/volume.c

94

volume->name_len = vldb->name_len;

fs/afs/volume.c

95

volume->creation_time = TIME64_MIN;

fs/afs/volume.c

96

volume->update_time = TIME64_MIN;

fs/afs/volume.c

98

refcount_set(&volume->ref, 1);

fs/afs/volume.c

99

INIT_HLIST_NODE(&volume->proc_link);

fs/afs/write.c

115

vnode->volume->name,

fs/afs/write.c

131

op = afs_alloc_operation(wreq->netfs_priv, vnode->volume);

fs/afs/xattr.c

111

op = afs_alloc_operation(NULL, vnode->volume);

fs/afs/xattr.c

169

op = afs_alloc_operation(NULL, vnode->volume);

fs/afs/xattr.c

244

op = afs_alloc_operation(NULL, vnode->volume);

fs/afs/xattr.c

274

struct afs_cell *cell = vnode->volume->cell;

fs/afs/xattr.c

339

const char *volname = vnode->volume->name;

fs/afs/xattr.c

46

op = afs_alloc_operation(NULL, vnode->volume);

fs/afs/yfsclient.c

24

fid->vid = xdr_to_u64(x->volume);

fs/afs/yfsclient.c

49

x->volume = u64_to_xdr(fid->vid);

fs/cachefiles/cache.c

321

struct cachefiles_volume *volume;

fs/cachefiles/cache.c

328

volume = list_entry(cur, struct cachefiles_volume, cache_link);

fs/cachefiles/cache.c

330

if (atomic_read(&volume->vcookie->n_accesses) == 0)

fs/cachefiles/cache.c

333

vcookie = fscache_try_get_volume(volume->vcookie,

fs/cachefiles/cache.c

356

struct cachefiles_volume *volume = NULL;

fs/cachefiles/cache.c

360

volume = list_first_entry(&cache->volumes,

fs/cachefiles/cache.c

362

vcookie = fscache_try_get_volume(volume->vcookie,

fs/cachefiles/cache.c

369

list_del_init(&volume->cache_link);

fs/cachefiles/cache.c

372

if (!volume)

fs/cachefiles/cache.c

375

cachefiles_withdraw_volume(volume);

fs/cachefiles/interface.c

181

struct cachefiles_cache *cache = cookie->volume->cache->cache_priv;

fs/cachefiles/interface.c

236

struct cachefiles_cache *cache = object->volume->cache;

fs/cachefiles/interface.c

25

struct fscache_volume *vcookie = cookie->volume;

fs/cachefiles/interface.c

26

struct cachefiles_volume *volume = vcookie->cache_priv;

fs/cachefiles/interface.c

283

struct cachefiles_cache *cache = object->volume->cache;

fs/cachefiles/interface.c

35

if (cachefiles_ondemand_init_obj_info(object, volume)) {

fs/cachefiles/interface.c

364

struct cachefiles_cache *cache = object->volume->cache;

fs/cachefiles/interface.c

430

struct cachefiles_volume *volume = object->volume;

fs/cachefiles/interface.c

431

struct dentry *fan = volume->fanout[(u8)cookie->key_hash];

fs/cachefiles/interface.c

436

cachefiles_bury_object(volume->cache, object,

fs/cachefiles/interface.c

44

object->volume = volume;

fs/cachefiles/interface.c

98

cache = object->volume->cache->cache;

fs/cachefiles/internal.h

321

struct cachefiles_volume *volume);

fs/cachefiles/internal.h

371

struct cachefiles_volume *volume)

fs/cachefiles/internal.h

408

void cachefiles_acquire_volume(struct fscache_volume *volume);

fs/cachefiles/internal.h

409

void cachefiles_free_volume(struct fscache_volume *volume);

fs/cachefiles/internal.h

410

void cachefiles_withdraw_volume(struct cachefiles_volume *volume);

fs/cachefiles/internal.h

422

extern bool cachefiles_set_volume_xattr(struct cachefiles_volume *volume);

fs/cachefiles/internal.h

423

extern int cachefiles_check_volume_xattr(struct cachefiles_volume *volume);

fs/cachefiles/internal.h

441

___cache = (object)->volume->cache; \

fs/cachefiles/internal.h

67

struct cachefiles_volume *volume; /* Cache volume that holds this object */

fs/cachefiles/io.c

215

granularity = max_t(size_t, object->volume->cache->bsize, granularity);

fs/cachefiles/io.c

271

atomic_long_sub(ki->b_writing, &object->volume->cache->b_writing);

fs/cachefiles/io.c

295

cache = object->volume->cache;

fs/cachefiles/io.c

422

cache = object->volume->cache;

fs/cachefiles/io.c

524

struct cachefiles_cache *cache = object->volume->cache;

fs/cachefiles/io.c

607

struct cachefiles_cache *cache = object->volume->cache;

fs/cachefiles/io.c

650

struct cachefiles_cache *cache = object->volume->cache;

fs/cachefiles/namei.c

417

struct cachefiles_volume *volume = object->volume;

fs/cachefiles/namei.c

419

struct dentry *fan = volume->fanout[(u8)object->cookie->key_hash];

fs/cachefiles/namei.c

428

ret = cachefiles_unlink(volume->cache, object, fan, dentry, why);

fs/cachefiles/namei.c

439

struct cachefiles_volume *volume = object->volume;

fs/cachefiles/namei.c

440

struct cachefiles_cache *cache = volume->cache;

fs/cachefiles/namei.c

442

struct dentry *fan = volume->fanout[(u8)object->cookie->key_hash];

fs/cachefiles/namei.c

521

ret = cachefiles_has_space(object->volume->cache, 1, 0,

fs/cachefiles/namei.c

544

struct cachefiles_cache *cache = object->volume->cache;

fs/cachefiles/namei.c

618

struct cachefiles_volume *volume = object->volume;

fs/cachefiles/namei.c

619

struct dentry *dentry, *fan = volume->fanout[(u8)object->cookie->key_hash];

fs/cachefiles/namei.c

646

ret = cachefiles_bury_object(volume->cache, object,

fs/cachefiles/namei.c

674

struct cachefiles_volume *volume = object->volume;

fs/cachefiles/namei.c

675

struct dentry *dentry, *fan = volume->fanout[(u8)object->cookie->key_hash];

fs/cachefiles/namei.c

69

struct cachefiles_cache *cache = object->volume->cache;

fs/cachefiles/namei.c

698

ret = cachefiles_unlink(volume->cache, object, fan, dentry,

fs/cachefiles/ondemand.c

120

struct cachefiles_cache *cache = object->volume->cache;

fs/cachefiles/ondemand.c

304

cache = object->volume->cache;

fs/cachefiles/ondemand.c

31

cache = object->volume->cache;

fs/cachefiles/ondemand.c

490

struct cachefiles_cache *cache = object->volume->cache;

fs/cachefiles/ondemand.c

613

struct fscache_volume *volume = object->volume->vcookie;

fs/cachefiles/ondemand.c

62

struct cachefiles_cache *cache = object->volume->cache;

fs/cachefiles/ondemand.c

622

volume_key_size = volume->key[0] + 1;

fs/cachefiles/ondemand.c

623

volume_key = volume->key + 1;

fs/cachefiles/ondemand.c

675

struct fscache_volume *volume = object->volume->vcookie;

fs/cachefiles/ondemand.c

690

volume_key_size = volume->key[0] + 1;

fs/cachefiles/ondemand.c

715

cache = object->volume->cache;

fs/cachefiles/ondemand.c

732

struct cachefiles_volume *volume)

fs/cachefiles/ondemand.c

734

if (!cachefiles_in_ondemand_mode(volume->cache))

fs/cachefiles/volume.c

100

cachefiles_put_directory(volume->dentry);

fs/cachefiles/volume.c

104

kfree(volume);

fs/cachefiles/volume.c

111

static void __cachefiles_free_volume(struct cachefiles_volume *volume)

fs/cachefiles/volume.c

117

volume->vcookie->cache_priv = NULL;

fs/cachefiles/volume.c

120

cachefiles_put_directory(volume->fanout[i]);

fs/cachefiles/volume.c

121

cachefiles_put_directory(volume->dentry);

fs/cachefiles/volume.c

122

kfree(volume);

fs/cachefiles/volume.c

127

struct cachefiles_volume *volume = vcookie->cache_priv;

fs/cachefiles/volume.c

129

if (volume) {

fs/cachefiles/volume.c

130

spin_lock(&volume->cache->object_list_lock);

fs/cachefiles/volume.c

131

list_del_init(&volume->cache_link);

fs/cachefiles/volume.c

132

spin_unlock(&volume->cache->object_list_lock);

fs/cachefiles/volume.c

133

__cachefiles_free_volume(volume);

fs/cachefiles/volume.c

137

void cachefiles_withdraw_volume(struct cachefiles_volume *volume)

fs/cachefiles/volume.c

139

cachefiles_set_volume_xattr(volume);

fs/cachefiles/volume.c

140

__cachefiles_free_volume(volume);

fs/cachefiles/volume.c

20

struct cachefiles_volume *volume;

fs/cachefiles/volume.c

31

volume = kzalloc_obj(struct cachefiles_volume);

fs/cachefiles/volume.c

32

if (!volume)

fs/cachefiles/volume.c

34

volume->vcookie = vcookie;

fs/cachefiles/volume.c

35

volume->cache = cache;

fs/cachefiles/volume.c

36

INIT_LIST_HEAD(&volume->cache_link);

fs/cachefiles/volume.c

52

volume->dentry = vdentry;

fs/cachefiles/volume.c

55

if (!cachefiles_set_volume_xattr(volume))

fs/cachefiles/volume.c

58

ret = cachefiles_check_volume_xattr(volume);

fs/cachefiles/volume.c

67

cachefiles_put_directory(volume->dentry);

fs/cachefiles/volume.c

78

volume->fanout[i] = fan;

fs/cachefiles/volume.c

83

vcookie->cache_priv = volume;

fs/cachefiles/volume.c

90

list_add(&volume->cache_link, &volume->cache->volumes);

fs/cachefiles/volume.c

98

cachefiles_put_directory(volume->fanout[i]);

fs/cachefiles/xattr.c

198

struct cachefiles_cache *cache = object->volume->cache;

fs/cachefiles/xattr.c

212

bool cachefiles_set_volume_xattr(struct cachefiles_volume *volume)

fs/cachefiles/xattr.c

215

unsigned int len = volume->vcookie->coherency_len;

fs/cachefiles/xattr.c

216

const void *p = volume->vcookie->coherency;

fs/cachefiles/xattr.c

217

struct dentry *dentry = volume->dentry;

fs/cachefiles/xattr.c

220

_enter("%x,#%d", volume->vcookie->debug_id, len);

fs/cachefiles/xattr.c

227

memcpy(buf->data, p, volume->vcookie->coherency_len);

fs/cachefiles/xattr.c

231

ret = mnt_want_write(volume->cache->mnt);

fs/cachefiles/xattr.c

236

mnt_drop_write(volume->cache->mnt);

fs/cachefiles/xattr.c

242

trace_cachefiles_vol_coherency(volume, d_inode(dentry)->i_ino,

fs/cachefiles/xattr.c

246

volume->cache, "Failed to set xattr with error %d", ret);

fs/cachefiles/xattr.c

248

trace_cachefiles_vol_coherency(volume, d_inode(dentry)->i_ino,

fs/cachefiles/xattr.c

260

int cachefiles_check_volume_xattr(struct cachefiles_volume *volume)

fs/cachefiles/xattr.c

263

struct dentry *dentry = volume->dentry;

fs/cachefiles/xattr.c

264

unsigned int len = volume->vcookie->coherency_len;

fs/cachefiles/xattr.c

265

const void *p = volume->vcookie->coherency;

fs/cachefiles/xattr.c

287

volume->cache,

fs/cachefiles/xattr.c

300

trace_cachefiles_vol_coherency(volume, d_inode(dentry)->i_ino, why);

fs/erofs/fscache.c

380

fscache_relinquish_volume(domain->volume, NULL, false);

fs/erofs/fscache.c

393

struct fscache_volume *volume;

fs/erofs/fscache.c

402

volume = fscache_acquire_volume(name, NULL, NULL, 0);

fs/erofs/fscache.c

403

if (IS_ERR_OR_NULL(volume)) {

fs/erofs/fscache.c

405

ret = volume ? PTR_ERR(volume) : -EOPNOTSUPP;

fs/erofs/fscache.c

406

volume = NULL;

fs/erofs/fscache.c

409

sbi->volume = volume;

fs/erofs/fscache.c

443

domain->volume = sbi->volume;

fs/erofs/fscache.c

464

sbi->volume = domain->volume;

fs/erofs/fscache.c

478

struct fscache_volume *volume = EROFS_SB(sb)->volume;

fs/erofs/fscache.c

491

cookie = fscache_acquire_cookie(volume, FSCACHE_ADV_WANT_CACHE_SIZE,

fs/erofs/fscache.c

659

fscache_relinquish_volume(sbi->volume, NULL, false);

fs/erofs/fscache.c

662

sbi->volume = NULL;

fs/erofs/internal.h

164

struct fscache_volume *volume;

fs/erofs/internal.h

84

struct fscache_volume *volume;

fs/netfs/fscache_cookie.c

1010

struct fscache_volume *volume = cookie->volume;

fs/netfs/fscache_cookie.c

1019

fscache_put_volume(volume, fscache_volume_put_cookie);

fs/netfs/fscache_cookie.c

1043

if (!cookie->volume->cache->ops->invalidate_cookie(cookie))

fs/netfs/fscache_cookie.c

1130

cookie->volume->debug_id,

fs/netfs/fscache_cookie.c

185

!fscache_cache_is_live(cookie->volume->cache)) {

fs/netfs/fscache_cookie.c

295

cookie->key_hash = fscache_hash(cookie->volume->key_hash,

fs/netfs/fscache_cookie.c

306

a->volume != b->volume ||

fs/netfs/fscache_cookie.c

326

struct fscache_volume *volume,

fs/netfs/fscache_cookie.c

340

cookie->volume = volume;

fs/netfs/fscache_cookie.c

422

fscache_get_volume(candidate->volume, fscache_volume_get_cookie);

fs/netfs/fscache_cookie.c

423

atomic_inc(&candidate->volume->n_cookies);

fs/netfs/fscache_cookie.c

451

struct fscache_volume *volume,

fs/netfs/fscache_cookie.c

459

_enter("V=%x", volume->debug_id);

fs/netfs/fscache_cookie.c

470

cookie = fscache_alloc_cookie(volume, advice,

fs/netfs/fscache_cookie.c

48

cookie->volume->debug_id,

fs/netfs/fscache_cookie.c

49

cookie->volume->key);

fs/netfs/fscache_cookie.c

497

cookie->volume->cache->ops->prepare_to_write(cookie);

fs/netfs/fscache_cookie.c

510

if (!cookie->volume->cache_priv) {

fs/netfs/fscache_cookie.c

511

fscache_create_volume(cookie->volume, true);

fs/netfs/fscache_cookie.c

512

if (!cookie->volume->cache_priv) {

fs/netfs/fscache_cookie.c

518

if (!cookie->volume->cache->ops->lookup_cookie(cookie)) {

fs/netfs/fscache_cookie.c

541

fscache_end_volume_access(cookie->volume, cookie, trace);

fs/netfs/fscache_cookie.c

554

if (!fscache_begin_volume_access(cookie->volume, cookie,

fs/netfs/fscache_cookie.c

780

cookie->volume->cache->ops->withdraw_cookie(cookie);

fs/netfs/fscache_cookie.c

990

ASSERTCMP(atomic_read(&cookie->volume->n_cookies), >, 0);

fs/netfs/fscache_cookie.c

991

atomic_dec(&cookie->volume->n_cookies);

fs/netfs/fscache_io.c

117

if (!cookie->volume->cache->ops->begin_operation(cres, want_state))

fs/netfs/fscache_io.c

284

cookie->volume->cache->ops->resize_cookie(&cres, new_size);

fs/netfs/fscache_io.c

29

if (!fscache_cache_is_live(cookie->volume->cache)) {

fs/netfs/fscache_io.c

60

return cookie->volume->cache->ops->begin_operation(cres, want_state);

fs/netfs/fscache_volume.c

100

if (!fscache_cache_is_live(volume->cache))

fs/netfs/fscache_volume.c

102

__fscache_begin_volume_access(volume, cookie, why);

fs/netfs/fscache_volume.c

103

if (!fscache_cache_is_live(volume->cache)) {

fs/netfs/fscache_volume.c

104

fscache_end_volume_access(volume, cookie, fscache_access_unlive);

fs/netfs/fscache_volume.c

119

void fscache_end_volume_access(struct fscache_volume *volume,

fs/netfs/fscache_volume.c

126

n_accesses = atomic_dec_return(&volume->n_accesses);

fs/netfs/fscache_volume.c

127

trace_fscache_access_volume(volume->debug_id, cookie ? cookie->debug_id : 0,

fs/netfs/fscache_volume.c

128

refcount_read(&volume->ref),

fs/netfs/fscache_volume.c

131

wake_up_var(&volume->n_accesses);

fs/netfs/fscache_volume.c

149

static bool fscache_is_acquire_pending(struct fscache_volume *volume)

fs/netfs/fscache_volume.c

151

return test_bit(FSCACHE_VOLUME_ACQUIRE_PENDING, &volume->flags);

fs/netfs/fscache_volume.c

20

struct fscache_volume *fscache_get_volume(struct fscache_volume *volume,

fs/netfs/fscache_volume.c

217

struct fscache_volume *volume;

fs/netfs/fscache_volume.c

233

volume = kzalloc_flex(*volume, coherency, coherency_len);

fs/netfs/fscache_volume.c

234

if (!volume)

fs/netfs/fscache_volume.c

237

volume->cache = cache;

fs/netfs/fscache_volume.c

238

volume->coherency_len = coherency_len;

fs/netfs/fscache_volume.c

240

memcpy(volume->coherency, coherency_data, coherency_len);

fs/netfs/fscache_volume.c

241

INIT_LIST_HEAD(&volume->proc_link);

fs/netfs/fscache_volume.c

242

INIT_WORK(&volume->work, fscache_create_volume_work);

fs/netfs/fscache_volume.c

243

refcount_set(&volume->ref, 1);

fs/netfs/fscache_volume.c

244

spin_lock_init(&volume->lock);

fs/netfs/fscache_volume.c

25

__refcount_inc(&volume->ref, &ref);

fs/netfs/fscache_volume.c

256

volume->key = key;

fs/netfs/fscache_volume.c

257

volume->key_hash = fscache_hash(0, key, hlen);

fs/netfs/fscache_volume.c

259

volume->debug_id = atomic_inc_return(&fscache_volume_debug_id);

fs/netfs/fscache_volume.c

26

trace_fscache_volume(volume->debug_id, ref + 1, where);

fs/netfs/fscache_volume.c

262

list_add_tail(&volume->proc_link, &fscache_volumes);

fs/netfs/fscache_volume.c

263

fscache_see_volume(volume, fscache_volume_new_acquire);

fs/netfs/fscache_volume.c

266

_leave(" = v=%x", volume->debug_id);

fs/netfs/fscache_volume.c

267

return volume;

fs/netfs/fscache_volume.c

27

return volume;

fs/netfs/fscache_volume.c

270

kfree(volume);

fs/netfs/fscache_volume.c

284

struct fscache_volume *volume =

fs/netfs/fscache_volume.c

287

fscache_see_volume(volume, fscache_volume_see_create_work);

fs/netfs/fscache_volume.c

289

ops = volume->cache->ops;

fs/netfs/fscache_volume.c

291

ops->acquire_volume(volume);

fs/netfs/fscache_volume.c

292

fscache_end_cache_access(volume->cache,

fs/netfs/fscache_volume.c

295

clear_and_wake_up_bit(FSCACHE_VOLUME_CREATING, &volume->flags);

fs/netfs/fscache_volume.c

296

fscache_put_volume(volume, fscache_volume_put_create_work);

fs/netfs/fscache_volume.c

30

struct fscache_volume *fscache_try_get_volume(struct fscache_volume *volume,

fs/netfs/fscache_volume.c

302

void fscache_create_volume(struct fscache_volume *volume, bool wait)

fs/netfs/fscache_volume.c

304

if (test_and_set_bit(FSCACHE_VOLUME_CREATING, &volume->flags))

fs/netfs/fscache_volume.c

306

if (volume->cache_priv)

fs/netfs/fscache_volume.c

308

if (!fscache_begin_cache_access(volume->cache,

fs/netfs/fscache_volume.c

312

fscache_get_volume(volume, fscache_volume_get_create_work);

fs/netfs/fscache_volume.c

313

if (!schedule_work(&volume->work))

fs/netfs/fscache_volume.c

314

fscache_put_volume(volume, fscache_volume_put_create_work);

fs/netfs/fscache_volume.c

318

fscache_see_volume(volume, fscache_volume_wait_create_work);

fs/netfs/fscache_volume.c

319

wait_on_bit(&volume->flags, FSCACHE_VOLUME_CREATING,

fs/netfs/fscache_volume.c

324

clear_and_wake_up_bit(FSCACHE_VOLUME_CREATING, &volume->flags);

fs/netfs/fscache_volume.c

335

struct fscache_volume *volume;

fs/netfs/fscache_volume.c

337

volume = fscache_alloc_volume(volume_key, cache_name,

fs/netfs/fscache_volume.c

339

if (!volume)

fs/netfs/fscache_volume.c

342

if (!fscache_hash_volume(volume)) {

fs/netfs/fscache_volume.c

343

fscache_put_volume(volume, fscache_volume_put_hash_collision);

fs/netfs/fscache_volume.c

347

fscache_create_volume(volume, false);

fs/netfs/fscache_volume.c

348

return volume;

fs/netfs/fscache_volume.c

35

if (!__refcount_inc_not_zero(&volume->ref, &ref))

fs/netfs/fscache_volume.c

352

static void fscache_wake_pending_volume(struct fscache_volume *volume,

fs/netfs/fscache_volume.c

359

if (fscache_volume_same(cursor, volume)) {

fs/netfs/fscache_volume.c

371

static void fscache_unhash_volume(struct fscache_volume *volume)

fs/netfs/fscache_volume.c

376

bucket = volume->key_hash & (ARRAY_SIZE(fscache_volume_hash) - 1);

fs/netfs/fscache_volume.c

38

trace_fscache_volume(volume->debug_id, ref + 1, where);

fs/netfs/fscache_volume.c

380

hlist_bl_del(&volume->hash_link);

fs/netfs/fscache_volume.c

381

if (test_bit(FSCACHE_VOLUME_COLLIDED_WITH, &volume->flags))

fs/netfs/fscache_volume.c

382

fscache_wake_pending_volume(volume, h);

fs/netfs/fscache_volume.c

389

static void fscache_free_volume(struct fscache_volume *volume)

fs/netfs/fscache_volume.c

39

return volume;

fs/netfs/fscache_volume.c

391

struct fscache_cache *cache = volume->cache;

fs/netfs/fscache_volume.c

393

if (volume->cache_priv) {

fs/netfs/fscache_volume.c

394

__fscache_begin_volume_access(volume, NULL,

fs/netfs/fscache_volume.c

396

if (volume->cache_priv)

fs/netfs/fscache_volume.c

397

cache->ops->free_volume(volume);

fs/netfs/fscache_volume.c

398

fscache_end_volume_access(volume, NULL,

fs/netfs/fscache_volume.c

403

list_del_init(&volume->proc_link);

fs/netfs/fscache_volume.c

404

atomic_dec(&volume->cache->n_volumes);

fs/netfs/fscache_volume.c

407

if (!hlist_bl_unhashed(&volume->hash_link))

fs/netfs/fscache_volume.c

408

fscache_unhash_volume(volume);

fs/netfs/fscache_volume.c

410

trace_fscache_volume(volume->debug_id, 0, fscache_volume_free);

fs/netfs/fscache_volume.c

411

kfree(volume->key);

fs/netfs/fscache_volume.c

412

kfree(volume);

fs/netfs/fscache_volume.c

420

void fscache_put_volume(struct fscache_volume *volume,

fs/netfs/fscache_volume.c

423

if (volume) {

fs/netfs/fscache_volume.c

424

unsigned int debug_id = volume->debug_id;

fs/netfs/fscache_volume.c

428

zero = __refcount_dec_and_test(&volume->ref, &ref);

fs/netfs/fscache_volume.c

43

static void fscache_see_volume(struct fscache_volume *volume,

fs/netfs/fscache_volume.c

431

fscache_free_volume(volume);

fs/netfs/fscache_volume.c

439

void __fscache_relinquish_volume(struct fscache_volume *volume,

fs/netfs/fscache_volume.c

443

if (WARN_ON(test_and_set_bit(FSCACHE_VOLUME_RELINQUISHED, &volume->flags)))

fs/netfs/fscache_volume.c

447

set_bit(FSCACHE_VOLUME_INVALIDATE, &volume->flags);

fs/netfs/fscache_volume.c

449

memcpy(volume->coherency, coherency_data, volume->coherency_len);

fs/netfs/fscache_volume.c

452

fscache_put_volume(volume, fscache_volume_put_relinquish);

fs/netfs/fscache_volume.c

46

int ref = refcount_read(&volume->ref);

fs/netfs/fscache_volume.c

463

void fscache_withdraw_volume(struct fscache_volume *volume)

fs/netfs/fscache_volume.c

467

_debug("withdraw V=%x", volume->debug_id);

fs/netfs/fscache_volume.c

470

n_accesses = atomic_dec_return(&volume->n_accesses);

fs/netfs/fscache_volume.c

471

trace_fscache_access_volume(volume->debug_id, 0,

fs/netfs/fscache_volume.c

472

refcount_read(&volume->ref),

fs/netfs/fscache_volume.c

475

wait_var_event(&volume->n_accesses,

fs/netfs/fscache_volume.c

476

atomic_read(&volume->n_accesses) == 0);

fs/netfs/fscache_volume.c

48

trace_fscache_volume(volume->debug_id, ref, where);

fs/netfs/fscache_volume.c

486

struct fscache_volume *volume;

fs/netfs/fscache_volume.c

495

volume = list_entry(v, struct fscache_volume, proc_link);

fs/netfs/fscache_volume.c

498

volume->debug_id,

fs/netfs/fscache_volume.c

499

refcount_read(&volume->ref),

fs/netfs/fscache_volume.c

500

atomic_read(&volume->n_cookies),

fs/netfs/fscache_volume.c

501

atomic_read(&volume->n_accesses),

fs/netfs/fscache_volume.c

502

volume->flags,

fs/netfs/fscache_volume.c

503

volume->cache->name ?: "-",

fs/netfs/fscache_volume.c

504

volume->key + 1);

fs/netfs/fscache_volume.c

54

static void __fscache_begin_volume_access(struct fscache_volume *volume,

fs/netfs/fscache_volume.c

60

n_accesses = atomic_inc_return(&volume->n_accesses);

fs/netfs/fscache_volume.c

62

trace_fscache_access_volume(volume->debug_id, cookie ? cookie->debug_id : 0,

fs/netfs/fscache_volume.c

63

refcount_read(&volume->ref),

fs/netfs/fscache_volume.c

96

bool fscache_begin_volume_access(struct fscache_volume *volume,

fs/netfs/internal.h

437

struct fscache_volume *fscache_get_volume(struct fscache_volume *volume,

fs/netfs/internal.h

439

bool fscache_begin_volume_access(struct fscache_volume *volume,

fs/netfs/internal.h

442

void fscache_create_volume(struct fscache_volume *volume, bool wait);

fs/nfs/blocklayout/blocklayout.h

73

u32 volume;

fs/nfs/blocklayout/dev.c

161

b->slice.volume = be32_to_cpup(p++);

fs/nfs/blocklayout/dev.c

447

ret = bl_parse_deviceid(server, d, volumes, v->slice.volume, gfp_mask);

fs/ntfs3/file.c

94

if (copy_to_user(buf, sbi->volume.label, FSLABEL_MAX))

fs/ntfs3/fsntfs.c

1000

sbi->volume.flags = info->flags;

fs/ntfs3/fsntfs.c

1041

if (unlikely(block >= sbi->volume.blocks)) {

fs/ntfs3/fsntfs.c

216

if (sbi->volume.major_ver < 3) {

fs/ntfs3/fsntfs.c

2656

struct ntfs_inode *ni = sbi->volume.ni;

fs/ntfs3/fsntfs.c

2689

if (len >= ARRAY_SIZE(sbi->volume.label))

fs/ntfs3/fsntfs.c

2690

len = ARRAY_SIZE(sbi->volume.label) - 1;

fs/ntfs3/fsntfs.c

2691

memcpy(sbi->volume.label, label, len);

fs/ntfs3/fsntfs.c

2692

sbi->volume.label[len] = 0;

fs/ntfs3/fsntfs.c

958

if (sbi->volume.real_dirty || sb_rdonly(sbi->sb))

fs/ntfs3/fsntfs.c

963

(sbi->volume.flags & VOLUME_FLAG_DIRTY))

fs/ntfs3/fsntfs.c

966

ni = sbi->volume.ni;

fs/ntfs3/fsntfs.c

989

sbi->volume.real_dirty = true;

fs/ntfs3/ntfs_fs.h

296

} volume;

fs/ntfs3/ntfs_fs.h

964

return sbi->volume.major_ver >= 3;

fs/ntfs3/record.c

345

if (alloc_size > mi->sbi->volume.size)

fs/ntfs3/super.c

1094

sbi->volume.size = sectors * boot_sector_size;

fs/ntfs3/super.c

1096

gb = format_size_gb(sbi->volume.size + boot_sector_size, &mb);

fs/ntfs3/super.c

1137

sbi->volume.ser_num = le64_to_cpu(boot->serial_num);

fs/ntfs3/super.c

1140

if (dev_size < sbi->volume.size + boot_sector_size) {

fs/ntfs3/super.c

1151

clusters = sbi->volume.size >> cluster_bits;

fs/ntfs3/super.c

1188

sbi->volume.blocks = sbi->volume.size >> sb->s_blocksize_bits;

fs/ntfs3/super.c

1340

UTF16_LITTLE_ENDIAN, sbi->volume.label,

fs/ntfs3/super.c

1341

sizeof(sbi->volume.label));

fs/ntfs3/super.c

1343

sbi->volume.label[0] = 0;

fs/ntfs3/super.c

1358

sbi->volume.major_ver = info->major_ver;

fs/ntfs3/super.c

1359

sbi->volume.minor_ver = info->minor_ver;

fs/ntfs3/super.c

1360

sbi->volume.flags = info->flags;

fs/ntfs3/super.c

1361

sbi->volume.ni = ni;

fs/ntfs3/super.c

1363

sbi->volume.real_dirty = true;

fs/ntfs3/super.c

1406

if ((sbi->volume.flags & VOLUME_FLAG_DIRTY) && !ro && !options->force) {

fs/ntfs3/super.c

462

if (ro_rw && (sbi->volume.flags & VOLUME_FLAG_DIRTY) &&

fs/ntfs3/super.c

498

sbi->volume.major_ver, sbi->volume.minor_ver,

fs/ntfs3/super.c

502

sbi->volume.real_dirty ? "dirty" : "clean",

fs/ntfs3/super.c

503

(sbi->volume.flags & VOLUME_FLAG_DIRTY) ? "dirty" : "clean");

fs/ntfs3/super.c

519

seq_printf(m, "%s\n", sbi->volume.label);

fs/ntfs3/super.c

691

if (sbi->volume.ni) {

fs/ntfs3/super.c

692

iput(&sbi->volume.ni->vfs_inode);

fs/ntfs3/super.c

693

sbi->volume.ni = NULL;

fs/ntfs3/super.c

753

buf->f_fsid.val[0] = sbi->volume.ser_num;

fs/ntfs3/super.c

754

buf->f_fsid.val[1] = sbi->volume.ser_num >> 32;

fs/ntfs3/super.c

980

sbi->volume.blocks = dev_size >> PAGE_SHIFT;

include/linux/dtlk.h

74

unsigned char volume; /* nV; 0-9 */

include/linux/fscache-cache.h

102

fscache_try_get_volume(struct fscache_volume *volume,

include/linux/fscache-cache.h

104

extern void fscache_put_volume(struct fscache_volume *volume,

include/linux/fscache-cache.h

106

extern void fscache_end_volume_access(struct fscache_volume *volume,

include/linux/fscache-cache.h

57

void (*acquire_volume)(struct fscache_volume *volume);

include/linux/fscache-cache.h

60

void (*free_volume)(struct fscache_volume *volume);

include/linux/fscache-cache.h

96

extern void fscache_withdraw_volume(struct fscache_volume *volume);

include/linux/fscache.h

109

struct fscache_volume *volume; /* Parent volume of this file. */

include/linux/fscache.h

222

void fscache_relinquish_volume(struct fscache_volume *volume,

include/linux/fscache.h

226

if (fscache_volume_valid(volume))

include/linux/fscache.h

227

__fscache_relinquish_volume(volume, coherency_data, invalidate);

include/linux/fscache.h

24

#define fscache_volume_valid(volume) (volume)

include/linux/fscache.h

246

struct fscache_cookie *fscache_acquire_cookie(struct fscache_volume *volume,

include/linux/fscache.h

254

if (!fscache_volume_valid(volume))

include/linux/fscache.h

256

return __fscache_acquire_cookie(volume, advice,

include/linux/fscache.h

31

#define fscache_volume_valid(volume) (0)

include/net/caif/cfctrl.h

77

char volume[20]; /* Volume to mount for RFM */

include/sound/mixer_oss.h

34

int volume[2];

include/sound/pt2258.h

16

unsigned char volume[6];

include/trace/events/afs.h

1438

TP_PROTO(struct afs_cell *cell, struct afs_volume *volume),

include/trace/events/afs.h

1440

TP_ARGS(cell, volume),

include/trace/events/afs.h

1445

__array(char, volume, 24)

include/trace/events/afs.h

1450

__entry->vid = volume->vid;

include/trace/events/afs.h

1454

__len = min_t(int, volume->name_len, 23);

include/trace/events/afs.h

1455

memcpy(__entry->volume, volume->name, __len);

include/trace/events/afs.h

1456

__entry->volume[__len] = 0;

include/trace/events/afs.h

1460

__entry->cell, __entry->volume, __entry->vid)

include/trace/events/cachefiles.h

418

TP_PROTO(struct cachefiles_volume *volume,

include/trace/events/cachefiles.h

422

TP_ARGS(volume, ino, why),

include/trace/events/cachefiles.h

432

__entry->vol = volume->vcookie->debug_id;

include/trace/events/fscache.h

244

__field(unsigned int, volume )

include/trace/events/fscache.h

250

__entry->volume = volume_debug_id;

include/trace/events/fscache.h

256

__entry->volume,

include/trace/events/fscache.h

358

__field(unsigned int, volume )

include/trace/events/fscache.h

366

__entry->volume = volume_debug_id;

include/trace/events/fscache.h

374

__entry->volume,

include/trace/events/fscache.h

417

__field(unsigned int, volume )

include/trace/events/fscache.h

424

__entry->volume = cookie->volume->debug_id;

include/trace/events/fscache.h

425

__entry->v_ref = refcount_read(&cookie->volume->ref);

include/trace/events/fscache.h

426

__entry->v_n_cookies = atomic_read(&cookie->volume->n_cookies);

include/trace/events/fscache.h

431

__entry->volume, __entry->v_ref, __entry->v_n_cookies)

include/trace/events/fscache.h

441

__field(unsigned int, volume )

include/trace/events/fscache.h

450

__entry->volume = cookie->volume->debug_id;

include/trace/events/fscache.h

458

__entry->cookie, __entry->volume, __entry->ref,

include/uapi/linux/caif/caif_socket.h

157

char volume[16];

include/uapi/linux/soundcard.h

295

int volume;

include/uapi/sound/asound_fm.h

37

unsigned char volume; /* 6 bits: volume */

net/caif/cfcnfg.c

271

strscpy(l->u.rfm.volume, s->sockaddr.u.rfm.volume,

net/caif/cfcnfg.c

272

sizeof(l->u.rfm.volume));

net/caif/cfctrl.c

252

cfpkt_add_body(pkt, param->u.rfm.volume,

net/caif/cfctrl.c

253

strlen(param->u.rfm.volume) + 1);

net/caif/cfctrl.c

416

cp = (u8 *) linkparam.u.rfm.volume;

net/caif/cfctrl.c

94

strcmp(p1->u.rfm.volume, p2->u.rfm.volume) == 0;

sound/core/oss/mixer_oss.c

261

left = pslot->volume[0];

sound/core/oss/mixer_oss.c

262

right = pslot->volume[1];

sound/core/oss/mixer_oss.c

272

pslot->volume[0] = left;

sound/core/oss/mixer_oss.c

273

pslot->volume[1] = right;

sound/core/oss/mixer_oss.c

280

int slot, int volume)

sound/core/oss/mixer_oss.c

284

int result = 0, left = volume & 0xff, right = (volume >> 8) & 0xff;

sound/core/oss/mixer_oss.c

300

pslot->volume[0] = left;

sound/core/oss/mixer_oss.c

301

pslot->volume[1] = right;

sound/core/oss/mixer_oss.c

545

*left = snd_mixer_oss_conv1(uctl->value.integer.value[0], uinfo->value.integer.min, uinfo->value.integer.max, &pslot->volume[0]);

sound/core/oss/mixer_oss.c

547

*right = snd_mixer_oss_conv1(uctl->value.integer.value[1], uinfo->value.integer.min, uinfo->value.integer.max, &pslot->volume[1]);

sound/drivers/opl3/opl3_midi.c

57

int volume;

sound/drivers/opl3/opl3_midi.c

59

volume = (vel * chan->gm_volume * chan->gm_expression) / (127*127);

sound/drivers/opl3/opl3_midi.c

60

if (volume > 127)

sound/drivers/opl3/opl3_midi.c

61

volume = 127;

sound/drivers/opl3/opl3_midi.c

65

newvol = opl3_volume_table[volume] + oldvol;

sound/drivers/opl3/opl3_synth.c

491

reg_val |= ~voice->volume & OPL3_TOTAL_LEVEL_MASK;

sound/firewire/oxfw/oxfw-spkr.c

12

s16 volume[6];

sound/firewire/oxfw/oxfw-spkr.c

202

value->value.integer.value[channel_map[i]] = spkr->volume[i];

sound/firewire/oxfw/oxfw-spkr.c

214

s16 volume;

sound/firewire/oxfw/oxfw-spkr.c

229

spkr->volume[i])

sound/firewire/oxfw/oxfw-spkr.c

236

volume = value->value.integer.value[channel_map[i ? i - 1 : 0]];

sound/firewire/oxfw/oxfw-spkr.c

239

spkr->volume_fb_id, &volume,

sound/firewire/oxfw/oxfw-spkr.c

245

spkr->volume[i - 1] = volume;

sound/firewire/oxfw/oxfw-spkr.c

306

&spkr->volume[i], first_ch + i,

sound/i2c/other/pt2258.c

104

if (val0 == pt->volume[base] && val1 == pt->volume[base + 1])

sound/i2c/other/pt2258.c

107

pt->volume[base] = val0;

sound/i2c/other/pt2258.c

115

pt->volume[base + 1] = val1;

sound/i2c/other/pt2258.c

54

pt->volume[i] = 0;

sound/i2c/other/pt2258.c

87

ucontrol->value.integer.value[0] = 79 - pt->volume[base];

sound/i2c/other/pt2258.c

88

ucontrol->value.integer.value[1] = 79 - pt->volume[base + 1];

sound/oss/dmasound/dmasound.h

181

static inline int dmasound_set_volume(int volume)

sound/oss/dmasound/dmasound.h

183

return dmasound.mach.setVolume(volume);

sound/oss/dmasound/dmasound_atari.c

1159

static int FalconSetVolume(int volume)

sound/oss/dmasound/dmasound_atari.c

1161

dmasound.volume_left = VOLUME_VOXWARE_TO_ATT(volume & 0xff);

sound/oss/dmasound/dmasound_atari.c

1162

dmasound.volume_right = VOLUME_VOXWARE_TO_ATT((volume & 0xff00) >> 8);

sound/oss/dmasound/dmasound_atari.c

129

static int TTSetVolume(int volume);

sound/oss/dmasound/dmasound_atari.c

134

static int FalconSetVolume(int volume);

sound/oss/dmasound/dmasound_atari.c

990

static int TTSetVolume(int volume)

sound/oss/dmasound/dmasound_atari.c

992

dmasound.volume_left = VOLUME_VOXWARE_TO_DB(volume & 0xff);

sound/oss/dmasound/dmasound_atari.c

994

dmasound.volume_right = VOLUME_VOXWARE_TO_DB((volume & 0xff00) >> 8);

sound/oss/dmasound/dmasound_paula.c

427

static int AmiSetVolume(int volume)

sound/oss/dmasound/dmasound_paula.c

429

dmasound.volume_left = VOLUME_VOXWARE_TO_AMI(volume & 0xff);

sound/oss/dmasound/dmasound_paula.c

431

dmasound.volume_right = VOLUME_VOXWARE_TO_AMI((volume & 0xff00) >> 8);

sound/oss/dmasound/dmasound_paula.c

83

static int AmiSetVolume(int volume);

sound/oss/dmasound/dmasound_q40.c

49

static int Q40SetVolume(int volume);

sound/oss/dmasound/dmasound_q40.c

572

static int Q40SetVolume(int volume)

sound/pci/cs46xx/cs46xx_dsp_spos.h

107

u16 volume[2];

sound/pci/cs46xx/dsp_spos.c

1949

s->volume[0], s->volume[1]);

sound/pci/cs46xx/dsp_spos.h

212

scb->volume[0] = left;

sound/pci/cs46xx/dsp_spos.h

213

scb->volume[1] = right;

sound/pci/emu10k1/emumixer.c

1453

static void update_emu10k1_send_volume(struct snd_emu10k1 *emu, int voice, unsigned char *volume)

sound/pci/emu10k1/emumixer.c

1455

snd_emu10k1_ptr_write(emu, PTRX_FXSENDAMOUNT_A, voice, volume[0]);

sound/pci/emu10k1/emumixer.c

1456

snd_emu10k1_ptr_write(emu, PTRX_FXSENDAMOUNT_B, voice, volume[1]);

sound/pci/emu10k1/emumixer.c

1457

snd_emu10k1_ptr_write(emu, PSST_FXSENDAMOUNT_C, voice, volume[2]);

sound/pci/emu10k1/emumixer.c

1458

snd_emu10k1_ptr_write(emu, DSL_FXSENDAMOUNT_D, voice, volume[3]);

sound/pci/emu10k1/emumixer.c

1461

snd_emu10k1_compose_audigy_sendamounts(volume));

sound/pci/mixart/mixart.h

38

int volume;

sound/pci/mixart/mixart_mixer.c

711

int volume[2];

sound/pci/mixart/mixart_mixer.c

736

volume[i] = chip->digital_playback_volume[idx][i];

sound/pci/mixart/mixart_mixer.c

738

volume[i] = MIXART_DIGITAL_LEVEL_MIN;

sound/pci/mixart/mixart_mixer.c

742

set_level.stream_level.out_level.left_to_out1_level = mixart_digital_level[volume[0]];

sound/pci/mixart/mixart_mixer.c

743

set_level.stream_level.out_level.right_to_out2_level = mixart_digital_level[volume[1]];

sound/pci/ymfpci/ymfpci_main.c

309

__le32 volume;

sound/pci/ymfpci/ymfpci_main.c

312

volume = cpu_to_le32(chip->pcm_mixer[subs].left << 15);

sound/pci/ymfpci/ymfpci_main.c

313

bank->left_gain_end = volume;

sound/pci/ymfpci/ymfpci_main.c

315

bank->eff2_gain_end = volume;

sound/pci/ymfpci/ymfpci_main.c

318

volume = cpu_to_le32(chip->pcm_mixer[subs].right << 15);

sound/pci/ymfpci/ymfpci_main.c

319

bank->right_gain_end = volume;

sound/pci/ymfpci/ymfpci_main.c

321

bank->eff3_gain_end = volume;

sound/ppc/beep.c

132

if (hz == beep->hz && beep->volume == beep->volume_play) {

sound/ppc/beep.c

142

p[0] = p[1] = beep_wform[j >> 8] * beep->volume;

sound/ppc/beep.c

146

beep->volume_play = beep->volume;

sound/ppc/beep.c

175

ucontrol->value.integer.value[0] = chip->beep->volume;

sound/ppc/beep.c

186

oval = chip->beep->volume;

sound/ppc/beep.c

190

chip->beep->volume = nval;

sound/ppc/beep.c

191

return oval != chip->beep->volume;

sound/ppc/beep.c

21

int volume; /* mixer volume: 0-100 */

sound/ppc/beep.c

236

beep->volume = BEEP_VOLUME;

sound/ppc/burgundy.c

119

long *volume, int shift)

sound/ppc/burgundy.c

123

if (volume[0] < 0 || volume[0] > 100 ||

sound/ppc/burgundy.c

124

volume[1] < 0 || volume[1] > 100)

sound/ppc/burgundy.c

126

lvolume = volume[0] ? volume[0] + BURGUNDY_VOLUME_OFFSET : 0;

sound/ppc/burgundy.c

127

rvolume = volume[1] ? volume[1] + BURGUNDY_VOLUME_OFFSET : 0;

sound/ppc/burgundy.c

138

long *volume, int shift)

sound/ppc/burgundy.c

144

volume[0] = wvolume & 0xff;

sound/ppc/burgundy.c

145

if (volume[0] >= BURGUNDY_VOLUME_OFFSET)

sound/ppc/burgundy.c

146

volume[0] -= BURGUNDY_VOLUME_OFFSET;

sound/ppc/burgundy.c

148

volume[0] = 0;

sound/ppc/burgundy.c

149

volume[1] = (wvolume >> shift) & 0xff;

sound/ppc/burgundy.c

150

if (volume[1] >= BURGUNDY_VOLUME_OFFSET)

sound/ppc/burgundy.c

151

volume[1] -= BURGUNDY_VOLUME_OFFSET;

sound/ppc/burgundy.c

153

volume[1] = 0;

sound/ppc/burgundy.c

204

long *volume, int off)

sound/ppc/burgundy.c

209

lvolume = volume[0] ? volume[0] + BURGUNDY_VOLUME_OFFSET : 0;

sound/ppc/burgundy.c

210

rvolume = volume[1] ? volume[1] + BURGUNDY_VOLUME_OFFSET : 0;

sound/ppc/burgundy.c

218

long *volume, int off)

sound/ppc/burgundy.c

220

volume[0] = snd_pmac_burgundy_rcb(chip, address + off);

sound/ppc/burgundy.c

221

if (volume[0] >= BURGUNDY_VOLUME_OFFSET)

sound/ppc/burgundy.c

222

volume[0] -= BURGUNDY_VOLUME_OFFSET;

sound/ppc/burgundy.c

224

volume[0] = 0;

sound/ppc/burgundy.c

225

volume[1] = snd_pmac_burgundy_rcb(chip, address + off + 0x100);

sound/ppc/burgundy.c

226

if (volume[1] >= BURGUNDY_VOLUME_OFFSET)

sound/ppc/burgundy.c

227

volume[1] -= BURGUNDY_VOLUME_OFFSET;

sound/ppc/burgundy.c

229

volume[1] = 0;

sound/soc/codecs/aw88081.c

262

unsigned int volume;

sound/soc/codecs/aw88081.c

264

volume = min((value + vol_desc->init_volume), (unsigned int)AW88081_MUTE_VOL);

sound/soc/codecs/aw88081.c

266

regmap_update_bits(aw_dev->regmap, AW88081_SYSCTRL2_REG, ~AW88081_VOL_MASK, volume);

sound/soc/codecs/aw88261.c

31

unsigned int real_value, volume;

sound/soc/codecs/aw88261.c

34

volume = min((value + vol_desc->init_volume), (unsigned int)AW88261_MUTE_VOL);

sound/soc/codecs/aw88261.c

35

real_value = DB_TO_REG_VAL(volume);

sound/soc/codecs/aw88395/aw88395_device.c

263

u16 real_value, volume;

sound/soc/codecs/aw88395/aw88395_device.c

266

volume = min((value + vol_desc->init_volume), (unsigned int)AW88395_MUTE_VOL);

sound/soc/codecs/aw88395/aw88395_device.c

267

real_value = db_to_reg_val(volume);

sound/soc/codecs/nau8825.c

298

unsigned int value, volume, ramp_up, from, to;

sound/soc/codecs/nau8825.c

315

for (volume = from; volume < to; volume += step) {

sound/soc/codecs/nau8825.c

317

value = volume;

sound/soc/codecs/nau8825.c

319

value = to - volume + from;

sound/soc/codecs/nau8825.c

404

int i, volume;

sound/soc/codecs/nau8825.c

418

volume = nau8825_xtalk_baktab[i].def &

sound/soc/codecs/nau8825.c

420

nau8825_hpvol_ramp(nau8825, 0, volume, 3);

sound/soc/codecs/nau8825.c

504

int volume, index;

sound/soc/codecs/nau8825.c

518

volume = nau8825_xtalk_baktab[index].def &

sound/soc/codecs/nau8825.c

520

nau8825_hpvol_ramp(nau8825, volume, 0, 3);

sound/soc/intel/atom/sst-mfld-dsp.h

440

s32 volume;

sound/soc/intel/catpt/messages.c

191

u32 channel, u32 volume,

sound/soc/intel/catpt/messages.c

201

input.target_volume = volume;

sound/soc/intel/catpt/messages.h

336

u32 channel, u32 volume,

sound/soc/intel/catpt/pcm.c

126

u32 volume, offset;

sound/soc/intel/catpt/pcm.c

132

memcpy_fromio(&volume, cdev->lpe_ba + offset, sizeof(volume));

sound/soc/intel/catpt/pcm.c

133

return volume;

sound/soc/intel/catpt/pcm.c

139

u32 volume, offset;

sound/soc/intel/catpt/pcm.c

145

memcpy_fromio(&volume, cdev->lpe_ba + offset, sizeof(volume));

sound/soc/intel/catpt/pcm.c

146

return volume;

sound/soc/intel/catpt/pcm.c

812

static u32 dspvol_to_ctlvol(u32 volume)

sound/soc/intel/catpt/pcm.c

814

if (volume > DSP_VOLUME_MAX)

sound/soc/intel/catpt/pcm.c

816

return volume ? __fls(volume) : 0;

sound/soc/renesas/rcar/dvc.c

231

&dvc->volume, channels,

sound/soc/renesas/rcar/dvc.c

38

struct rsnd_kctrl_cfg_m volume;

sound/soc/renesas/rcar/dvc.c

71

#define rsnd_dvc_get_vrdbr(dvc) (0x3ff - (rsnd_kctrl_valm(dvc->volume, 0) >> 13))

sound/soc/renesas/rcar/dvc.c

83

val[i] = rsnd_kctrl_max(dvc->volume);

sound/soc/renesas/rcar/dvc.c

86

val[i] = rsnd_kctrl_valm(dvc->volume, i);

sound/soc/renesas/rcar/mix.c

183

struct rsnd_kctrl_cfg_s *volume;

sound/soc/renesas/rcar/mix.c

189

volume = &mix->volumeA;

sound/soc/renesas/rcar/mix.c

194

volume = &mix->volumeB;

sound/soc/renesas/rcar/mix.c

199

volume = &mix->volumeC;

sound/soc/renesas/rcar/mix.c

204

volume = &mix->volumeD;

sound/soc/renesas/rcar/mix.c

217

volume, VOL_MAX);

sound/soc/renesas/rcar/mix.c

220

rsnd_kctrl_vals(*volume) = VOL_MAX;

sound/soc/renesas/rcar/mix.c

83

(VOL_MAX - rsnd_kctrl_vals(mix->volume##X)) : 0

sound/soc/renesas/siu.h

105

u32 volume;

sound/soc/renesas/siu_dai.c

133

siu_write32(base + SIU_SBDVCA, port_info->playback.volume);

sound/soc/renesas/siu_dai.c

134

siu_write32(base + SIU_SBDVCB, port_info->capture.volume);

sound/soc/renesas/siu_dai.c

364

vol = port_info->playback.volume;

sound/soc/renesas/siu_dai.c

370

vol = port_info->capture.volume;

sound/soc/renesas/siu_dai.c

408

cur_vol = port_info->playback.volume;

sound/soc/renesas/siu_dai.c

410

port_info->playback.volume = new_vol;

sound/soc/renesas/siu_dai.c

414

cur_vol = port_info->capture.volume;

sound/soc/renesas/siu_dai.c

416

port_info->capture.volume = new_vol;

sound/soc/renesas/siu_dai.c

462

(*port_info)->playback.volume = DFLT_VOLUME_LEVEL;

sound/soc/renesas/siu_dai.c

463

(*port_info)->capture.volume = DFLT_VOLUME_LEVEL;

sound/soc/sof/ipc3-topology.c

748

struct sof_ipc_comp_volume *volume;

sound/soc/sof/ipc3-topology.c

750

size_t ipc_size = sizeof(*volume);

sound/soc/sof/ipc3-topology.c

754

volume = sof_comp_alloc(swidget, &ipc_size, swidget->pipeline_id);

sound/soc/sof/ipc3-topology.c

755

if (!volume)

sound/soc/sof/ipc3-topology.c

758

swidget->private = volume;

sound/soc/sof/ipc3-topology.c

761

volume->comp.type = SOF_COMP_VOLUME;

sound/soc/sof/ipc3-topology.c

762

volume->config.hdr.size = sizeof(volume->config);

sound/soc/sof/ipc3-topology.c

765

ret = sof_update_ipc_object(scomp, volume, SOF_VOLUME_TOKENS, swidget->tuples,

sound/soc/sof/ipc3-topology.c

766

swidget->num_tuples, sizeof(*volume), 1);

sound/soc/sof/ipc3-topology.c

771

ret = sof_update_ipc_object(scomp, &volume->config, SOF_COMP_TOKENS,

sound/soc/sof/ipc3-topology.c

773

sizeof(volume->config), 1);

sound/soc/sof/ipc3-topology.c

778

sof_dbg_comp_config(scomp, &volume->config);

sound/soc/sof/ipc3-topology.c

785

volume->min_value = scontrol->volume_table[min_step];

sound/soc/sof/ipc3-topology.c

786

volume->max_value = scontrol->volume_table[max_step];

sound/soc/sof/ipc3-topology.c

787

volume->channels = scontrol->num_channels;

sound/soc/tegra/tegra210_mvc.c

103

mvc->volume[chan] = ((val * (1<<8)) / 100) << 16;

sound/soc/tegra/tegra210_mvc.c

106

mvc->volume[chan] = (val * (1<<8)) / 100;

sound/soc/tegra/tegra210_mvc.c

266

s32 val = mvc->volume[chan];

sound/soc/tegra/tegra210_mvc.c

295

int old_volume = mvc->volume[chan];

sound/soc/tegra/tegra210_mvc.c

306

if (mvc->volume[chan] == old_volume) {

sound/soc/tegra/tegra210_mvc.c

320

mvc->volume[i] = mvc->volume[chan];

sound/soc/tegra/tegra210_mvc.c

326

mvc->volume[chan]);

sound/soc/tegra/tegra210_mvc.c

328

regmap_write(mvc->regmap, mc->reg, mvc->volume[chan]);

sound/soc/tegra/tegra210_mvc.c

362

mvc->volume[i] = TEGRA210_MVC_INIT_VOL_DEFAULT_POLY;

sound/soc/tegra/tegra210_mvc.c

365

mvc->volume[i] = TEGRA210_MVC_INIT_VOL_DEFAULT_LINEAR;

sound/soc/tegra/tegra210_mvc.c

380

mvc->volume[i]);

sound/soc/tegra/tegra210_mvc.c

383

mvc->volume[i]);

sound/soc/tegra/tegra210_mvc.h

116

int volume[TEGRA210_MVC_MAX_CHAN_COUNT];

sound/usb/line6/playback.c

109

int volume, int bytes_per_frame)

sound/usb/line6/playback.c

111

if (volume == 0)

sound/usb/line6/playback.c

124

int val = pov + ((piv * volume) >> 8);

sound/usb/line6/playback.c

21

static void change_volume(struct urb *urb_out, int volume[],

sound/usb/line6/playback.c

26

if (volume[0] == 256 && volume[1] == 256)

sound/usb/line6/playback.c

37

int val = (pv * volume[chn & 1]) >> 8;

sound/usb/line6/playback.c

52

val = (val * volume[chn & 1]) >> 8;