/linux-4.1.27/fs/minix/ |
H A D | itree_v1.c | 24 static int block_to_path(struct inode * inode, long block, int offsets[DEPTH]) block_to_path() argument 29 if (block < 0) { block_to_path() 30 printk("MINIX-fs: block_to_path: block %ld < 0 on dev %s\n", block_to_path() 31 block, bdevname(inode->i_sb->s_bdev, b)); block_to_path() 32 } else if (block >= (minix_sb(inode->i_sb)->s_max_size/BLOCK_SIZE)) { block_to_path() 35 "block %ld too big on dev %s\n", block_to_path() 36 block, bdevname(inode->i_sb->s_bdev, b)); block_to_path() 37 } else if (block < 7) { block_to_path() 38 offsets[n++] = block; block_to_path() 39 } else if ((block -= 7) < 512) { block_to_path() 41 offsets[n++] = block; block_to_path() 43 block -= 512; block_to_path() 45 offsets[n++] = block>>9; block_to_path() 46 offsets[n++] = block & 511; block_to_path() 53 int V1_minix_get_block(struct inode * inode, long block, V1_minix_get_block() argument 56 return get_block(inode, block, bh_result, create); V1_minix_get_block()
|
H A D | itree_v2.c | 26 static int block_to_path(struct inode * inode, long block, int offsets[DEPTH]) block_to_path() argument 32 if (block < 0) { block_to_path() 33 printk("MINIX-fs: block_to_path: block %ld < 0 on dev %s\n", block_to_path() 34 block, bdevname(sb->s_bdev, b)); block_to_path() 35 } else if ((u64)block * (u64)sb->s_blocksize >= block_to_path() 39 "block %ld too big on dev %s\n", block_to_path() 40 block, bdevname(sb->s_bdev, b)); block_to_path() 41 } else if (block < DIRCOUNT) { block_to_path() 42 offsets[n++] = block; block_to_path() 43 } else if ((block -= DIRCOUNT) < INDIRCOUNT(sb)) { block_to_path() 45 offsets[n++] = block; block_to_path() 46 } else if ((block -= INDIRCOUNT(sb)) < INDIRCOUNT(sb) * INDIRCOUNT(sb)) { block_to_path() 48 offsets[n++] = block / INDIRCOUNT(sb); block_to_path() 49 offsets[n++] = block % INDIRCOUNT(sb); block_to_path() 51 block -= INDIRCOUNT(sb) * INDIRCOUNT(sb); block_to_path() 53 offsets[n++] = (block / INDIRCOUNT(sb)) / INDIRCOUNT(sb); block_to_path() 54 offsets[n++] = (block / INDIRCOUNT(sb)) % INDIRCOUNT(sb); block_to_path() 55 offsets[n++] = block % INDIRCOUNT(sb); block_to_path() 62 int V2_minix_get_block(struct inode * inode, long block, V2_minix_get_block() argument 65 return get_block(inode, block, bh_result, create); V2_minix_get_block()
|
H A D | bitmap.c | 12 /* bitmap.c contains the code that handles the inode and block bitmaps */ 41 void minix_free_block(struct inode *inode, unsigned long block) minix_free_block() argument 49 if (block < sbi->s_firstdatazone || block >= sbi->s_nzones) { minix_free_block() 50 printk("Trying to free block not in datazone\n"); minix_free_block() 53 zone = block - sbi->s_firstdatazone + 1; minix_free_block() 64 sb->s_id, block); minix_free_block() 108 int block; minix_V1_raw_inode() local 118 block = 2 + sbi->s_imap_blocks + sbi->s_zmap_blocks + minix_V1_raw_inode() 120 *bh = sb_bread(sb, block); minix_V1_raw_inode() 122 printk("Unable to read inode block\n"); minix_V1_raw_inode() 132 int block; minix_V2_raw_inode() local 144 block = 2 + sbi->s_imap_blocks + sbi->s_zmap_blocks + minix_V2_raw_inode() 146 *bh = sb_bread(sb, block); minix_V2_raw_inode() 148 printk("Unable to read inode block\n"); minix_V2_raw_inode()
|
/linux-4.1.27/sound/isa/gus/ |
H A D | gus_mem.c | 43 struct snd_gf1_mem_block * block) snd_gf1_mem_xalloc() 50 *nblock = *block; snd_gf1_mem_xalloc() 78 int snd_gf1_mem_xfree(struct snd_gf1_mem * alloc, struct snd_gf1_mem_block * block) snd_gf1_mem_xfree() argument 80 if (block->share) { /* ok.. shared block */ snd_gf1_mem_xfree() 81 block->share--; snd_gf1_mem_xfree() 85 if (alloc->first == block) { snd_gf1_mem_xfree() 86 alloc->first = block->next; snd_gf1_mem_xfree() 87 if (block->next) snd_gf1_mem_xfree() 88 block->next->prev = NULL; snd_gf1_mem_xfree() 90 block->prev->next = block->next; snd_gf1_mem_xfree() 91 if (block->next) snd_gf1_mem_xfree() 92 block->next->prev = block->prev; snd_gf1_mem_xfree() 94 if (alloc->last == block) { snd_gf1_mem_xfree() 95 alloc->last = block->prev; snd_gf1_mem_xfree() 96 if (block->prev) snd_gf1_mem_xfree() 97 block->prev->next = NULL; snd_gf1_mem_xfree() 99 block->next->prev = block->prev; snd_gf1_mem_xfree() 100 if (block->prev) snd_gf1_mem_xfree() 101 block->prev->next = block->next; snd_gf1_mem_xfree() 103 kfree(block->name); snd_gf1_mem_xfree() 104 kfree(block); snd_gf1_mem_xfree() 111 struct snd_gf1_mem_block *block; snd_gf1_mem_look() local 113 for (block = alloc->first; block; block = block->next) { snd_gf1_mem_look() 114 if (block->ptr == address) { snd_gf1_mem_look() 115 return block; snd_gf1_mem_look() 124 struct snd_gf1_mem_block *block; snd_gf1_mem_share() local 129 for (block = alloc->first; block; block = block->next) snd_gf1_mem_share() 130 if (!memcmp(share_id, block->share_id, snd_gf1_mem_share() 131 sizeof(block->share_id))) snd_gf1_mem_share() 132 return block; snd_gf1_mem_share() 137 struct snd_gf1_mem_block * block, snd_gf1_mem_find() 148 block->flags = w_16 ? SNDRV_GF1_MEM_BLOCK_16BIT : 0; snd_gf1_mem_find() 149 block->owner = SNDRV_GF1_MEM_OWNER_DRIVER; snd_gf1_mem_find() 150 block->share = 0; snd_gf1_mem_find() 151 block->share_id[0] = block->share_id[1] = snd_gf1_mem_find() 152 block->share_id[2] = block->share_id[3] = 0; snd_gf1_mem_find() 153 block->name = NULL; snd_gf1_mem_find() 154 block->prev = block->next = NULL; snd_gf1_mem_find() 172 block->ptr = ptr1; snd_gf1_mem_find() 173 block->size = size; snd_gf1_mem_find() 180 block->ptr = info[idx].address; snd_gf1_mem_find() 181 block->size = size; snd_gf1_mem_find() 192 struct snd_gf1_mem_block block, *nblock; snd_gf1_mem_alloc() local 209 if (snd_gf1_mem_find(alloc, &block, size, w_16, align) < 0) { snd_gf1_mem_alloc() 214 memcpy(&block.share_id, share_id, sizeof(block.share_id)); snd_gf1_mem_alloc() 215 block.owner = owner; snd_gf1_mem_alloc() 216 block.name = kstrdup(name, GFP_KERNEL); snd_gf1_mem_alloc() 217 nblock = snd_gf1_mem_xalloc(alloc, &block); snd_gf1_mem_alloc() 225 struct snd_gf1_mem_block *block; snd_gf1_mem_free() local 228 if ((block = snd_gf1_mem_look(alloc, address)) != NULL) { snd_gf1_mem_free() 229 result = snd_gf1_mem_xfree(alloc, block); snd_gf1_mem_free() 240 struct snd_gf1_mem_block block; snd_gf1_mem_init() local 251 memset(&block, 0, sizeof(block)); snd_gf1_mem_init() 252 block.owner = SNDRV_GF1_MEM_OWNER_DRIVER; snd_gf1_mem_init() 254 block.ptr = 0; snd_gf1_mem_init() 255 block.size = 1024; snd_gf1_mem_init() 256 block.name = kstrdup("InterWave LFOs", GFP_KERNEL); snd_gf1_mem_init() 257 if (snd_gf1_mem_xalloc(alloc, &block) == NULL) snd_gf1_mem_init() 260 block.ptr = gus->gf1.default_voice_address; snd_gf1_mem_init() 261 block.size = 4; snd_gf1_mem_init() 262 block.name = kstrdup("Voice default (NULL's)", GFP_KERNEL); snd_gf1_mem_init() 263 if (snd_gf1_mem_xalloc(alloc, &block) == NULL) snd_gf1_mem_init() 275 struct snd_gf1_mem_block *block, *nblock; snd_gf1_mem_done() local 278 block = alloc->first; snd_gf1_mem_done() 279 while (block) { snd_gf1_mem_done() 280 nblock = block->next; snd_gf1_mem_done() 281 snd_gf1_mem_xfree(alloc, block); snd_gf1_mem_done() 282 block = nblock; snd_gf1_mem_done() 293 struct snd_gf1_mem_block *block; snd_gf1_mem_info_read() local 311 for (block = alloc->first, i = 0; block; block = block->next, i++) { snd_gf1_mem_info_read() 312 used += block->size; snd_gf1_mem_info_read() 313 snd_iprintf(buffer, "Block %i at 0x%lx onboard 0x%x size %i (0x%x):\n", i, (long) block, block->ptr, block->size, block->size); snd_gf1_mem_info_read() 314 if (block->share || snd_gf1_mem_info_read() 315 block->share_id[0] || block->share_id[1] || snd_gf1_mem_info_read() 316 block->share_id[2] || block->share_id[3]) snd_gf1_mem_info_read() 318 block->share, snd_gf1_mem_info_read() 319 block->share_id[0], block->share_id[1], snd_gf1_mem_info_read() 320 block->share_id[2], block->share_id[3]); snd_gf1_mem_info_read() 322 block->flags & SNDRV_GF1_MEM_BLOCK_16BIT ? " 16-bit" : ""); snd_gf1_mem_info_read() 324 switch (block->owner) { snd_gf1_mem_info_read() 326 snd_iprintf(buffer, "driver - %s\n", block->name); snd_gf1_mem_info_read() 345 ultra_iprintf(buffer, " Verify: free = %i, max 8-bit block = %i, max 16-bit block = %i\n", snd_gf1_mem_info_read() 42 snd_gf1_mem_xalloc(struct snd_gf1_mem * alloc, struct snd_gf1_mem_block * block) snd_gf1_mem_xalloc() argument 136 snd_gf1_mem_find(struct snd_gf1_mem * alloc, struct snd_gf1_mem_block * block, unsigned int size, int w_16, int align) snd_gf1_mem_find() argument
|
H A D | gus_dma.c | 97 struct snd_gf1_dma_block *block; snd_gf1_dma_next_block() local 99 /* PCM block have bigger priority than synthesizer one */ snd_gf1_dma_next_block() 101 block = gus->gf1.dma_data_pcm; snd_gf1_dma_next_block() 102 if (gus->gf1.dma_data_pcm_last == block) { snd_gf1_dma_next_block() 106 gus->gf1.dma_data_pcm = block->next; snd_gf1_dma_next_block() 109 block = gus->gf1.dma_data_synth; snd_gf1_dma_next_block() 110 if (gus->gf1.dma_data_synth_last == block) { snd_gf1_dma_next_block() 114 gus->gf1.dma_data_synth = block->next; snd_gf1_dma_next_block() 117 block = NULL; snd_gf1_dma_next_block() 119 if (block) { snd_gf1_dma_next_block() 120 gus->gf1.dma_ack = block->ack; snd_gf1_dma_next_block() 121 gus->gf1.dma_private_data = block->private_data; snd_gf1_dma_next_block() 123 return block; snd_gf1_dma_next_block() 129 struct snd_gf1_dma_block *block; snd_gf1_dma_interrupt() local 142 block = snd_gf1_dma_next_block(gus); snd_gf1_dma_interrupt() 144 snd_gf1_dma_program(gus, block->addr, block->buf_addr, block->count, (unsigned short) block->cmd); snd_gf1_dma_interrupt() 145 kfree(block); snd_gf1_dma_interrupt() 149 block->addr, block->buf_addr, block->count, block->cmd); snd_gf1_dma_interrupt() 172 struct snd_gf1_dma_block *block; snd_gf1_dma_done() local 180 while ((block = gus->gf1.dma_data_pcm)) { snd_gf1_dma_done() 181 gus->gf1.dma_data_pcm = block->next; snd_gf1_dma_done() 182 kfree(block); snd_gf1_dma_done() 184 while ((block = gus->gf1.dma_data_synth)) { snd_gf1_dma_done() 185 gus->gf1.dma_data_synth = block->next; snd_gf1_dma_done() 186 kfree(block); snd_gf1_dma_done() 201 struct snd_gf1_dma_block *block; snd_gf1_dma_transfer_block() local 203 block = kmalloc(sizeof(*block), atomic ? GFP_ATOMIC : GFP_KERNEL); snd_gf1_dma_transfer_block() 204 if (block == NULL) { snd_gf1_dma_transfer_block() 208 *block = *__block; snd_gf1_dma_transfer_block() 209 block->next = NULL; snd_gf1_dma_transfer_block() 212 block->addr, (long) block->buffer, block->count, snd_gf1_dma_transfer_block() 213 block->cmd); snd_gf1_dma_transfer_block() 223 gus->gf1.dma_data_synth_last->next = block; snd_gf1_dma_transfer_block() 224 gus->gf1.dma_data_synth_last = block; snd_gf1_dma_transfer_block() 227 gus->gf1.dma_data_synth_last = block; snd_gf1_dma_transfer_block() 231 gus->gf1.dma_data_pcm_last->next = block; snd_gf1_dma_transfer_block() 232 gus->gf1.dma_data_pcm_last = block; snd_gf1_dma_transfer_block() 235 gus->gf1.dma_data_pcm_last = block; snd_gf1_dma_transfer_block() 240 block = snd_gf1_dma_next_block(gus); snd_gf1_dma_transfer_block() 242 if (block == NULL) snd_gf1_dma_transfer_block() 244 snd_gf1_dma_program(gus, block->addr, block->buf_addr, block->count, (unsigned short) block->cmd); snd_gf1_dma_transfer_block() 245 kfree(block); snd_gf1_dma_transfer_block()
|
/linux-4.1.27/drivers/video/fbdev/ |
H A D | edid.h | 72 #define PIXEL_CLOCK_LO (unsigned)block[ 0 ] 73 #define PIXEL_CLOCK_HI (unsigned)block[ 1 ] 75 #define H_ACTIVE_LO (unsigned)block[ 2 ] 76 #define H_BLANKING_LO (unsigned)block[ 3 ] 77 #define H_ACTIVE_HI UPPER_NIBBLE( (unsigned)block[ 4 ] ) 79 #define H_BLANKING_HI LOWER_NIBBLE( (unsigned)block[ 4 ] ) 82 #define V_ACTIVE_LO (unsigned)block[ 5 ] 83 #define V_BLANKING_LO (unsigned)block[ 6 ] 84 #define V_ACTIVE_HI UPPER_NIBBLE( (unsigned)block[ 7 ] ) 86 #define V_BLANKING_HI LOWER_NIBBLE( (unsigned)block[ 7 ] ) 89 #define H_SYNC_OFFSET_LO (unsigned)block[ 8 ] 90 #define H_SYNC_WIDTH_LO (unsigned)block[ 9 ] 92 #define V_SYNC_OFFSET_LO UPPER_NIBBLE( (unsigned)block[ 10 ] ) 93 #define V_SYNC_WIDTH_LO LOWER_NIBBLE( (unsigned)block[ 10 ] ) 95 #define V_SYNC_WIDTH_HI ((unsigned)block[ 11 ] & (1|2)) 96 #define V_SYNC_OFFSET_HI (((unsigned)block[ 11 ] & (4|8)) >> 2) 98 #define H_SYNC_WIDTH_HI (((unsigned)block[ 11 ] & (16|32)) >> 4) 99 #define H_SYNC_OFFSET_HI (((unsigned)block[ 11 ] & (64|128)) >> 6) 107 #define H_SIZE_LO (unsigned)block[ 12 ] 108 #define V_SIZE_LO (unsigned)block[ 13 ] 110 #define H_SIZE_HI UPPER_NIBBLE( (unsigned)block[ 14 ] ) 111 #define V_SIZE_HI LOWER_NIBBLE( (unsigned)block[ 14 ] ) 116 #define H_BORDER (unsigned)block[ 15 ] 117 #define V_BORDER (unsigned)block[ 16 ] 119 #define FLAGS (unsigned)block[ 17 ] 127 #define V_MIN_RATE block[ 5 ] 128 #define V_MAX_RATE block[ 6 ] 129 #define H_MIN_RATE block[ 7 ] 130 #define H_MAX_RATE block[ 8 ] 131 #define MAX_PIXEL_CLOCK (((int)block[ 9 ]) * 10) 132 #define GTF_SUPPORT block[10]
|
H A D | c2p_core.h | 66 /* First n x 1 block */ transp8() 68 /* Second n x 1 block */ transp8() 70 /* Third n x 1 block */ transp8() 72 /* Fourth n x 1 block */ transp8() 77 /* First n x 2 block */ transp8() 80 /* Second n x 2 block */ transp8() 86 /* Single n x 4 block */ transp8() 108 /* First n x 1 block */ transp4() 110 /* Second n x 1 block */ transp4() 115 /* Single n x 2 block */ transp4() 135 /* Single n x 2 block */ transp4x()
|
/linux-4.1.27/crypto/ |
H A D | cast6_generic.c | 165 static inline void Q(u32 *block, u8 *Kr, u32 *Km) Q() argument 168 block[2] ^= F1(block[3], Kr[0], Km[0]); Q() 169 block[1] ^= F2(block[2], Kr[1], Km[1]); Q() 170 block[0] ^= F3(block[1], Kr[2], Km[2]); Q() 171 block[3] ^= F1(block[0], Kr[3], Km[3]); Q() 175 static inline void QBAR(u32 *block, u8 *Kr, u32 *Km) QBAR() argument 178 block[3] ^= F1(block[0], Kr[3], Km[3]); QBAR() 179 block[0] ^= F3(block[1], Kr[2], Km[2]); QBAR() 180 block[1] ^= F2(block[2], Kr[1], Km[1]); QBAR() 181 block[2] ^= F1(block[3], Kr[0], Km[0]); QBAR() 188 u32 block[4]; __cast6_encrypt() local 192 block[0] = be32_to_cpu(src[0]); __cast6_encrypt() 193 block[1] = be32_to_cpu(src[1]); __cast6_encrypt() 194 block[2] = be32_to_cpu(src[2]); __cast6_encrypt() 195 block[3] = be32_to_cpu(src[3]); __cast6_encrypt() 197 Km = c->Km[0]; Kr = c->Kr[0]; Q(block, Kr, Km); __cast6_encrypt() 198 Km = c->Km[1]; Kr = c->Kr[1]; Q(block, Kr, Km); __cast6_encrypt() 199 Km = c->Km[2]; Kr = c->Kr[2]; Q(block, Kr, Km); __cast6_encrypt() 200 Km = c->Km[3]; Kr = c->Kr[3]; Q(block, Kr, Km); __cast6_encrypt() 201 Km = c->Km[4]; Kr = c->Kr[4]; Q(block, Kr, Km); __cast6_encrypt() 202 Km = c->Km[5]; Kr = c->Kr[5]; Q(block, Kr, Km); __cast6_encrypt() 203 Km = c->Km[6]; Kr = c->Kr[6]; QBAR(block, Kr, Km); __cast6_encrypt() 204 Km = c->Km[7]; Kr = c->Kr[7]; QBAR(block, Kr, Km); __cast6_encrypt() 205 Km = c->Km[8]; Kr = c->Kr[8]; QBAR(block, Kr, Km); __cast6_encrypt() 206 Km = c->Km[9]; Kr = c->Kr[9]; QBAR(block, Kr, Km); __cast6_encrypt() 207 Km = c->Km[10]; Kr = c->Kr[10]; QBAR(block, Kr, Km); __cast6_encrypt() 208 Km = c->Km[11]; Kr = c->Kr[11]; QBAR(block, Kr, Km); __cast6_encrypt() 210 dst[0] = cpu_to_be32(block[0]); __cast6_encrypt() 211 dst[1] = cpu_to_be32(block[1]); __cast6_encrypt() 212 dst[2] = cpu_to_be32(block[2]); __cast6_encrypt() 213 dst[3] = cpu_to_be32(block[3]); __cast6_encrypt() 226 u32 block[4]; __cast6_decrypt() local 230 block[0] = be32_to_cpu(src[0]); __cast6_decrypt() 231 block[1] = be32_to_cpu(src[1]); __cast6_decrypt() 232 block[2] = be32_to_cpu(src[2]); __cast6_decrypt() 233 block[3] = be32_to_cpu(src[3]); __cast6_decrypt() 235 Km = c->Km[11]; Kr = c->Kr[11]; Q(block, Kr, Km); __cast6_decrypt() 236 Km = c->Km[10]; Kr = c->Kr[10]; Q(block, Kr, Km); __cast6_decrypt() 237 Km = c->Km[9]; Kr = c->Kr[9]; Q(block, Kr, Km); __cast6_decrypt() 238 Km = c->Km[8]; Kr = c->Kr[8]; Q(block, Kr, Km); __cast6_decrypt() 239 Km = c->Km[7]; Kr = c->Kr[7]; Q(block, Kr, Km); __cast6_decrypt() 240 Km = c->Km[6]; Kr = c->Kr[6]; Q(block, Kr, Km); __cast6_decrypt() 241 Km = c->Km[5]; Kr = c->Kr[5]; QBAR(block, Kr, Km); __cast6_decrypt() 242 Km = c->Km[4]; Kr = c->Kr[4]; QBAR(block, Kr, Km); __cast6_decrypt() 243 Km = c->Km[3]; Kr = c->Kr[3]; QBAR(block, Kr, Km); __cast6_decrypt() 244 Km = c->Km[2]; Kr = c->Kr[2]; QBAR(block, Kr, Km); __cast6_decrypt() 245 Km = c->Km[1]; Kr = c->Kr[1]; QBAR(block, Kr, Km); __cast6_decrypt() 246 Km = c->Km[0]; Kr = c->Kr[0]; QBAR(block, Kr, Km); __cast6_decrypt() 248 dst[0] = cpu_to_be32(block[0]); __cast6_decrypt() 249 dst[1] = cpu_to_be32(block[1]); __cast6_decrypt() 250 dst[2] = cpu_to_be32(block[2]); __cast6_decrypt() 251 dst[3] = cpu_to_be32(block[3]); __cast6_decrypt()
|
H A D | md5.c | 46 le32_to_cpu_array(ctx->block, sizeof(ctx->block) / sizeof(u32)); md5_transform_helper() 47 md5_transform(ctx->hash, ctx->block); md5_transform_helper() 66 const u32 avail = sizeof(mctx->block) - (mctx->byte_count & 0x3f); md5_update() 71 memcpy((char *)mctx->block + (sizeof(mctx->block) - avail), md5_update() 76 memcpy((char *)mctx->block + (sizeof(mctx->block) - avail), md5_update() 83 while (len >= sizeof(mctx->block)) { md5_update() 84 memcpy(mctx->block, data, sizeof(mctx->block)); md5_update() 86 data += sizeof(mctx->block); md5_update() 87 len -= sizeof(mctx->block); md5_update() 90 memcpy(mctx->block, data, len); md5_update() 99 char *p = (char *)mctx->block + offset; md5_final() 106 p = (char *)mctx->block; md5_final() 111 mctx->block[14] = mctx->byte_count << 3; md5_final() 112 mctx->block[15] = mctx->byte_count >> 29; md5_final() 113 le32_to_cpu_array(mctx->block, (sizeof(mctx->block) - md5_final() 115 md5_transform(mctx->hash, mctx->block); md5_final()
|
H A D | md4.c | 38 u32 block[MD4_BLOCK_WORDS]; member in struct:md4_ctx 152 le32_to_cpu_array(ctx->block, ARRAY_SIZE(ctx->block)); md4_transform_helper() 153 md4_transform(ctx->hash, ctx->block); md4_transform_helper() 172 const u32 avail = sizeof(mctx->block) - (mctx->byte_count & 0x3f); md4_update() 177 memcpy((char *)mctx->block + (sizeof(mctx->block) - avail), md4_update() 182 memcpy((char *)mctx->block + (sizeof(mctx->block) - avail), md4_update() 189 while (len >= sizeof(mctx->block)) { md4_update() 190 memcpy(mctx->block, data, sizeof(mctx->block)); md4_update() 192 data += sizeof(mctx->block); md4_update() 193 len -= sizeof(mctx->block); md4_update() 196 memcpy(mctx->block, data, len); md4_update() 205 char *p = (char *)mctx->block + offset; md4_final() 212 p = (char *)mctx->block; md4_final() 217 mctx->block[14] = mctx->byte_count << 3; md4_final() 218 mctx->block[15] = mctx->byte_count >> 29; md4_final() 219 le32_to_cpu_array(mctx->block, (sizeof(mctx->block) - md4_final() 221 md4_transform(mctx->hash, mctx->block); md4_final()
|
/linux-4.1.27/fs/efs/ |
H A D | dir.c | 25 efs_block_t block; efs_readdir() local 33 block = ctx->pos >> EFS_DIRBSIZE_BITS; efs_readdir() 35 /* each block contains at most 256 slots */ efs_readdir() 39 while (block < inode->i_blocks) { efs_readdir() 43 /* read the dir block */ efs_readdir() 44 bh = sb_bread(inode->i_sb, efs_bmap(inode, block)); efs_readdir() 47 pr_err("%s(): failed to read dir block %d\n", efs_readdir() 48 __func__, block); efs_readdir() 55 pr_err("%s(): invalid directory block\n", __func__); efs_readdir() 74 pr_debug("%s(): block %d slot %d/%d: inode %u, name \"%s\", namelen %u\n", efs_readdir() 75 __func__, block, slot, dirblock->slots-1, efs_readdir() 80 ctx->pos = (block << EFS_DIRBSIZE_BITS) | slot; efs_readdir() 84 pr_warn("directory entry %d exceeds directory block\n", efs_readdir() 98 block++; efs_readdir() 100 ctx->pos = (block << EFS_DIRBSIZE_BITS) | slot; efs_readdir()
|
H A D | file.c | 25 pr_warn("%s(): block %d >= %ld (filesize %ld)\n", efs_get_block() 26 __func__, block, inode->i_blocks, inode->i_size); efs_get_block() 36 int efs_bmap(struct inode *inode, efs_block_t block) { efs_bmap() argument 38 if (block < 0) { efs_bmap() 39 pr_warn("%s(): block < 0\n", __func__); efs_bmap() 44 if (!(block < inode->i_blocks)) { efs_bmap() 49 pr_warn("%s(): block %d >= %ld (filesize %ld)\n", efs_bmap() 50 __func__, block, inode->i_blocks, inode->i_size); efs_bmap() 55 return efs_map_block(inode, block); efs_bmap()
|
H A D | inode.c | 20 static sector_t _efs_bmap(struct address_space *mapping, sector_t block) _efs_bmap() argument 22 return generic_block_bmap(mapping,block,efs_get_block); _efs_bmap() 55 efs_block_t block, offset; efs_iget() local 73 ** work out the inode block index, (considering initially that the efs_iget() 74 ** inodes are stored as consecutive blocks). then work out the block efs_iget() 76 ** offset of the inode within that block. efs_iget() 82 block = sb->fs_start + sb->first_block + efs_iget() 90 bh = sb_bread(inode->i_sb, block); efs_iget() 92 pr_warn("%s() failed at block %d\n", __func__, block); efs_iget() 177 efs_extent_check(efs_extent *ptr, efs_block_t block, struct efs_sb_info *sb) { efs_extent_check() argument 183 * given an extent and a logical block within a file, efs_extent_check() 184 * can this block be found within this extent ? efs_extent_check() 190 if ((block >= offset) && (block < offset+length)) { efs_extent_check() 191 return(sb->fs_start + start + block - offset); efs_extent_check() 197 efs_block_t efs_map_block(struct inode *inode, efs_block_t block) { efs_map_block() argument 211 if ((result = efs_extent_check(&in->extents[last], block, sb))) efs_map_block() 228 if ((result = efs_extent_check(&in->extents[cur], block, sb))) { efs_map_block() 234 pr_err("%s() failed to map block %u (dir)\n", __func__, block); efs_map_block() 238 pr_debug("%s(): indirect search for logical block %u\n", efs_map_block() 239 __func__, block); efs_map_block() 261 pr_err("couldn't find direct extent for indirect extent %d (block %u)\n", efs_map_block() 262 cur, block); efs_map_block() 267 /* work out block number and offset of this indirect extent */ efs_map_block() 279 pr_err("%s() failed at block %d\n", efs_map_block() 283 pr_debug("%s(): read indirect extent block %d\n", efs_map_block() 294 pr_err("extent %d has bad magic number in block %d\n", efs_map_block() 300 if ((result = efs_extent_check(&ext, block, sb))) { efs_map_block() 307 pr_err("%s() failed to map block %u (indir)\n", __func__, block); efs_map_block()
|
H A D | namei.c | 24 efs_block_t block; efs_find_entry() local 30 for(block = 0; block < inode->i_blocks; block++) { efs_find_entry() 32 bh = sb_bread(inode->i_sb, efs_bmap(inode, block)); efs_find_entry() 34 pr_err("%s(): failed to read dir block %d\n", efs_find_entry() 35 __func__, block); efs_find_entry() 42 pr_err("%s(): invalid directory block\n", __func__); efs_find_entry()
|
/linux-4.1.27/arch/arm/mach-cns3xxx/ |
H A D | pm.c | 18 void cns3xxx_pwr_clk_en(unsigned int block) cns3xxx_pwr_clk_en() argument 22 reg |= (block & PM_CLK_GATE_REG_MASK); cns3xxx_pwr_clk_en() 27 void cns3xxx_pwr_clk_dis(unsigned int block) cns3xxx_pwr_clk_dis() argument 31 reg &= ~(block & PM_CLK_GATE_REG_MASK); cns3xxx_pwr_clk_dis() 36 void cns3xxx_pwr_power_up(unsigned int block) cns3xxx_pwr_power_up() argument 40 reg &= ~(block & CNS3XXX_PWR_PLL_ALL); cns3xxx_pwr_power_up() 48 void cns3xxx_pwr_power_down(unsigned int block) cns3xxx_pwr_power_down() argument 53 reg |= (block & CNS3XXX_PWR_PLL_ALL); cns3xxx_pwr_power_down() 58 static void cns3xxx_pwr_soft_rst_force(unsigned int block) cns3xxx_pwr_soft_rst_force() argument 66 if (block & 0x30000001) { cns3xxx_pwr_soft_rst_force() 67 reg &= ~(block & PM_SOFT_RST_REG_MASK); cns3xxx_pwr_soft_rst_force() 69 reg &= ~(block & PM_SOFT_RST_REG_MASK); cns3xxx_pwr_soft_rst_force() 71 reg |= (block & PM_SOFT_RST_REG_MASK); cns3xxx_pwr_soft_rst_force() 77 void cns3xxx_pwr_soft_rst(unsigned int block) cns3xxx_pwr_soft_rst() argument 81 if (soft_reset & block) { cns3xxx_pwr_soft_rst() 82 /* SPI/I2C/GPIO use the same block, reset once. */ cns3xxx_pwr_soft_rst() 85 soft_reset |= block; cns3xxx_pwr_soft_rst() 87 cns3xxx_pwr_soft_rst_force(block); cns3xxx_pwr_soft_rst()
|
H A D | pm.h | 16 void cns3xxx_pwr_clk_en(unsigned int block); 17 void cns3xxx_pwr_clk_dis(unsigned int block); 18 void cns3xxx_pwr_power_up(unsigned int block); 19 void cns3xxx_pwr_power_down(unsigned int block);
|
/linux-4.1.27/fs/lockd/ |
H A D | svclock.c | 42 static void nlmsvc_release_block(struct nlm_block *block); 43 static void nlmsvc_insert_block(struct nlm_block *block, unsigned long); 44 static void nlmsvc_remove_block(struct nlm_block *block); 89 nlmsvc_insert_block_locked(struct nlm_block *block, unsigned long when) nlmsvc_insert_block_locked() argument 94 dprintk("lockd: nlmsvc_insert_block(%p, %ld)\n", block, when); nlmsvc_insert_block_locked() 95 if (list_empty(&block->b_list)) { nlmsvc_insert_block_locked() 96 kref_get(&block->b_count); nlmsvc_insert_block_locked() 98 list_del_init(&block->b_list); nlmsvc_insert_block_locked() 115 list_add_tail(&block->b_list, pos); nlmsvc_insert_block_locked() 116 block->b_when = when; nlmsvc_insert_block_locked() 119 static void nlmsvc_insert_block(struct nlm_block *block, unsigned long when) nlmsvc_insert_block() argument 122 nlmsvc_insert_block_locked(block, when); nlmsvc_insert_block() 127 * Remove a block from the global list 130 nlmsvc_remove_block(struct nlm_block *block) nlmsvc_remove_block() argument 132 if (!list_empty(&block->b_list)) { nlmsvc_remove_block() 134 list_del_init(&block->b_list); nlmsvc_remove_block() 136 nlmsvc_release_block(block); nlmsvc_remove_block() 141 * Find a block for a given lock 146 struct nlm_block *block; nlmsvc_lookup_block() local 153 list_for_each_entry(block, &nlm_blocked, b_list) { nlmsvc_lookup_block() 154 fl = &block->b_call->a_args.lock.fl; nlmsvc_lookup_block() 156 block->b_file, fl->fl_pid, nlmsvc_lookup_block() 159 nlmdbg_cookie2a(&block->b_call->a_args.cookie)); nlmsvc_lookup_block() 160 if (block->b_file == file && nlm_compare_locks(fl, &lock->fl)) { nlmsvc_lookup_block() 161 kref_get(&block->b_count); nlmsvc_lookup_block() 162 return block; nlmsvc_lookup_block() 179 * Find a block with a given NLM cookie. 184 struct nlm_block *block; nlmsvc_find_block() local 186 list_for_each_entry(block, &nlm_blocked, b_list) { nlmsvc_find_block() 187 if (nlm_cookie_match(&block->b_call->a_args.cookie,cookie)) nlmsvc_find_block() 194 dprintk("nlmsvc_find_block(%s): block=%p\n", nlmdbg_cookie2a(cookie), block); nlmsvc_find_block() 195 kref_get(&block->b_count); nlmsvc_find_block() 196 return block; nlmsvc_find_block() 200 * Create a block and initialize it. 219 struct nlm_block *block; nlmsvc_create_block() local 226 /* Allocate memory for block, and initialize arguments */ nlmsvc_create_block() 227 block = kzalloc(sizeof(*block), GFP_KERNEL); nlmsvc_create_block() 228 if (block == NULL) nlmsvc_create_block() 230 kref_init(&block->b_count); nlmsvc_create_block() 231 INIT_LIST_HEAD(&block->b_list); nlmsvc_create_block() 232 INIT_LIST_HEAD(&block->b_flist); nlmsvc_create_block() 242 dprintk("lockd: created block %p...\n", block); nlmsvc_create_block() 244 /* Create and initialize the block */ nlmsvc_create_block() 245 block->b_daemon = rqstp->rq_server; nlmsvc_create_block() 246 block->b_host = host; nlmsvc_create_block() 247 block->b_file = file; nlmsvc_create_block() 251 list_add(&block->b_flist, &file->f_blocks); nlmsvc_create_block() 254 block->b_call = call; nlmsvc_create_block() 256 call->a_block = block; nlmsvc_create_block() 258 return block; nlmsvc_create_block() 261 kfree(block); nlmsvc_create_block() 268 * Delete a block. 272 static int nlmsvc_unlink_block(struct nlm_block *block) nlmsvc_unlink_block() argument 275 dprintk("lockd: unlinking block %p...\n", block); nlmsvc_unlink_block() 277 /* Remove block from list */ nlmsvc_unlink_block() 278 status = posix_unblock_lock(&block->b_call->a_args.lock.fl); nlmsvc_unlink_block() 279 nlmsvc_remove_block(block); nlmsvc_unlink_block() 285 struct nlm_block *block = container_of(kref, struct nlm_block, b_count); nlmsvc_free_block() local 286 struct nlm_file *file = block->b_file; nlmsvc_free_block() 288 dprintk("lockd: freeing block %p...\n", block); nlmsvc_free_block() 290 /* Remove block from file's list of blocks */ nlmsvc_free_block() 291 list_del_init(&block->b_flist); nlmsvc_free_block() 294 nlmsvc_freegrantargs(block->b_call); nlmsvc_free_block() 295 nlmsvc_release_call(block->b_call); nlmsvc_free_block() 296 nlm_release_file(block->b_file); nlmsvc_free_block() 297 kfree(block); nlmsvc_free_block() 300 static void nlmsvc_release_block(struct nlm_block *block) nlmsvc_release_block() argument 302 if (block != NULL) nlmsvc_release_block() 303 kref_put_mutex(&block->b_count, nlmsvc_free_block, &block->b_file->f_mutex); nlmsvc_release_block() 314 struct nlm_block *block, *next; nlmsvc_traverse_blocks() local 318 list_for_each_entry_safe(block, next, &file->f_blocks, b_flist) { nlmsvc_traverse_blocks() 319 if (!match(block->b_host, host)) nlmsvc_traverse_blocks() 323 if (list_empty(&block->b_list)) nlmsvc_traverse_blocks() 325 kref_get(&block->b_count); nlmsvc_traverse_blocks() 327 nlmsvc_unlink_block(block); nlmsvc_traverse_blocks() 328 nlmsvc_release_block(block); nlmsvc_traverse_blocks() 372 nlmsvc_defer_lock_rqst(struct svc_rqst *rqstp, struct nlm_block *block) nlmsvc_defer_lock_rqst() argument 376 block->b_flags |= B_QUEUED; nlmsvc_defer_lock_rqst() 378 nlmsvc_insert_block(block, NLM_TIMEOUT); nlmsvc_defer_lock_rqst() 380 block->b_cache_req = &rqstp->rq_chandle; nlmsvc_defer_lock_rqst() 382 block->b_deferred_req = nlmsvc_defer_lock_rqst() 383 rqstp->rq_chandle.defer(block->b_cache_req); nlmsvc_defer_lock_rqst() 384 if (block->b_deferred_req != NULL) nlmsvc_defer_lock_rqst() 387 dprintk("lockd: nlmsvc_defer_lock_rqst block %p flags %d status %d\n", nlmsvc_defer_lock_rqst() 388 block, block->b_flags, ntohl(status)); nlmsvc_defer_lock_rqst() 394 * Attempt to establish a lock, and if it can't be granted, block it 402 struct nlm_block *block = NULL; nlmsvc_lock() local 416 /* Get existing block (in case client is busy-waiting) nlmsvc_lock() 417 * or create new block nlmsvc_lock() 419 block = nlmsvc_lookup_block(file, lock); nlmsvc_lock() 420 if (block == NULL) { nlmsvc_lock() 421 block = nlmsvc_create_block(rqstp, host, file, lock, cookie); nlmsvc_lock() 423 if (block == NULL) nlmsvc_lock() 425 lock = &block->b_call->a_args.lock; nlmsvc_lock() 429 if (block->b_flags & B_QUEUED) { nlmsvc_lock() 430 dprintk("lockd: nlmsvc_lock deferred block %p flags %d\n", nlmsvc_lock() 431 block, block->b_flags); nlmsvc_lock() 432 if (block->b_granted) { nlmsvc_lock() 433 nlmsvc_unlink_block(block); nlmsvc_lock() 437 if (block->b_flags & B_TIMED_OUT) { nlmsvc_lock() 438 nlmsvc_unlink_block(block); nlmsvc_lock() 469 * to put it back on lockd's block list nlmsvc_lock() 480 ret = nlmsvc_defer_lock_rqst(rqstp, block); nlmsvc_lock() 493 nlmsvc_insert_block(block, NLM_NEVER); nlmsvc_lock() 496 nlmsvc_release_block(block); nlmsvc_lock() 559 * afterwards. In this case the block will still be there, and hence 593 struct nlm_block *block; nlmsvc_cancel_blocked() local 607 block = nlmsvc_lookup_block(file, lock); nlmsvc_cancel_blocked() 609 if (block != NULL) { nlmsvc_cancel_blocked() 610 vfs_cancel_lock(block->b_file->f_file, nlmsvc_cancel_blocked() 611 &block->b_call->a_args.lock.fl); nlmsvc_cancel_blocked() 612 status = nlmsvc_unlink_block(block); nlmsvc_cancel_blocked() 613 nlmsvc_release_block(block); nlmsvc_cancel_blocked() 623 * In all cases it will move the block to the head of nlm_blocked q where 628 nlmsvc_update_deferred_block(struct nlm_block *block, int result) nlmsvc_update_deferred_block() argument 630 block->b_flags |= B_GOT_CALLBACK; nlmsvc_update_deferred_block() 632 block->b_granted = 1; nlmsvc_update_deferred_block() 634 block->b_flags |= B_TIMED_OUT; nlmsvc_update_deferred_block() 639 struct nlm_block *block; nlmsvc_grant_deferred() local 643 list_for_each_entry(block, &nlm_blocked, b_list) { nlmsvc_grant_deferred() 644 if (nlm_compare_locks(&block->b_call->a_args.lock.fl, fl)) { nlmsvc_grant_deferred() 645 dprintk("lockd: nlmsvc_notify_blocked block %p flags %d\n", nlmsvc_grant_deferred() 646 block, block->b_flags); nlmsvc_grant_deferred() 647 if (block->b_flags & B_QUEUED) { nlmsvc_grant_deferred() 648 if (block->b_flags & B_TIMED_OUT) { nlmsvc_grant_deferred() 652 nlmsvc_update_deferred_block(block, result); nlmsvc_grant_deferred() 654 block->b_granted = 1; nlmsvc_grant_deferred() 656 nlmsvc_insert_block_locked(block, 0); nlmsvc_grant_deferred() 657 svc_wake_up(block->b_daemon); nlmsvc_grant_deferred() 664 printk(KERN_WARNING "lockd: grant for unknown block\n"); nlmsvc_grant_deferred() 673 * the block to the head of nlm_blocked where it can be picked up by lockd. 678 struct nlm_block *block; nlmsvc_notify_blocked() local 680 dprintk("lockd: VFS unblock notification for block %p\n", fl); nlmsvc_notify_blocked() 682 list_for_each_entry(block, &nlm_blocked, b_list) { nlmsvc_notify_blocked() 683 if (nlm_compare_locks(&block->b_call->a_args.lock.fl, fl)) { nlmsvc_notify_blocked() 684 nlmsvc_insert_block_locked(block, 0); nlmsvc_notify_blocked() 686 svc_wake_up(block->b_daemon); nlmsvc_notify_blocked() 691 printk(KERN_WARNING "lockd: notification for unknown block!\n"); nlmsvc_notify_blocked() 729 nlmsvc_grant_blocked(struct nlm_block *block) nlmsvc_grant_blocked() argument 731 struct nlm_file *file = block->b_file; nlmsvc_grant_blocked() 732 struct nlm_lock *lock = &block->b_call->a_args.lock; nlmsvc_grant_blocked() 736 dprintk("lockd: grant blocked lock %p\n", block); nlmsvc_grant_blocked() 738 kref_get(&block->b_count); nlmsvc_grant_blocked() 740 /* Unlink block request from list */ nlmsvc_grant_blocked() 741 nlmsvc_unlink_block(block); nlmsvc_grant_blocked() 746 if (block->b_granted) { nlmsvc_grant_blocked() 747 nlm_rebind_host(block->b_host); nlmsvc_grant_blocked() 768 nlmsvc_insert_block(block, NLM_NEVER); nlmsvc_grant_blocked() 769 nlmsvc_release_block(block); nlmsvc_grant_blocked() 774 nlmsvc_insert_block(block, 10 * HZ); nlmsvc_grant_blocked() 775 nlmsvc_release_block(block); nlmsvc_grant_blocked() 782 block->b_granted = 1; nlmsvc_grant_blocked() 784 /* keep block on the list, but don't reattempt until the RPC nlmsvc_grant_blocked() 787 nlmsvc_insert_block(block, NLM_NEVER); nlmsvc_grant_blocked() 792 error = nlm_async_call(block->b_call, NLMPROC_GRANTED_MSG, nlmsvc_grant_blocked() 797 nlmsvc_insert_block(block, 10 * HZ); nlmsvc_grant_blocked() 811 struct nlm_block *block = call->a_block; nlmsvc_grant_callback() local 817 /* if the block is not on a list at this point then it has nlmsvc_grant_callback() 820 * FIXME: it's possible that the block is removed from the list nlmsvc_grant_callback() 825 if (list_empty(&block->b_list)) nlmsvc_grant_callback() 829 * move the block towards the head of the queue only, no harm nlmsvc_grant_callback() 838 nlmsvc_insert_block_locked(block, timeout); nlmsvc_grant_callback() 839 svc_wake_up(block->b_daemon); nlmsvc_grant_callback() 861 * block. 866 struct nlm_block *block; nlmsvc_grant_reply() local 870 if (!(block = nlmsvc_find_block(cookie))) nlmsvc_grant_reply() 873 if (block) { nlmsvc_grant_reply() 876 nlmsvc_insert_block(block, 10 * HZ); nlmsvc_grant_reply() 879 * In both cases, the block should be removed. */ nlmsvc_grant_reply() 880 nlmsvc_unlink_block(block); nlmsvc_grant_reply() 883 nlmsvc_release_block(block); nlmsvc_grant_reply() 886 /* Helper function to handle retry of a deferred block. 891 retry_deferred_block(struct nlm_block *block) retry_deferred_block() argument 893 if (!(block->b_flags & B_GOT_CALLBACK)) retry_deferred_block() 894 block->b_flags |= B_TIMED_OUT; retry_deferred_block() 895 nlmsvc_insert_block(block, NLM_TIMEOUT); retry_deferred_block() 896 dprintk("revisit block %p flags %d\n", block, block->b_flags); retry_deferred_block() 897 if (block->b_deferred_req) { retry_deferred_block() 898 block->b_deferred_req->revisit(block->b_deferred_req, 0); retry_deferred_block() 899 block->b_deferred_req = NULL; retry_deferred_block() 912 struct nlm_block *block; nlmsvc_retry_blocked() local 916 block = list_entry(nlm_blocked.next, struct nlm_block, b_list); nlmsvc_retry_blocked() 918 if (block->b_when == NLM_NEVER) nlmsvc_retry_blocked() 920 if (time_after(block->b_when, jiffies)) { nlmsvc_retry_blocked() 921 timeout = block->b_when - jiffies; nlmsvc_retry_blocked() 927 block, block->b_when); nlmsvc_retry_blocked() 928 if (block->b_flags & B_QUEUED) { nlmsvc_retry_blocked() 929 dprintk("nlmsvc_retry_blocked delete block (%p, granted=%d, flags=%d)\n", nlmsvc_retry_blocked() 930 block, block->b_granted, block->b_flags); nlmsvc_retry_blocked() 931 retry_deferred_block(block); nlmsvc_retry_blocked() 933 nlmsvc_grant_blocked(block); nlmsvc_retry_blocked()
|
H A D | clntlock.c | 100 struct nlm_wait *block; nlmclnt_prepare_block() local 102 block = kmalloc(sizeof(*block), GFP_KERNEL); nlmclnt_prepare_block() 103 if (block != NULL) { nlmclnt_prepare_block() 104 block->b_host = host; nlmclnt_prepare_block() 105 block->b_lock = fl; nlmclnt_prepare_block() 106 init_waitqueue_head(&block->b_wait); nlmclnt_prepare_block() 107 block->b_status = nlm_lck_blocked; nlmclnt_prepare_block() 110 list_add(&block->b_list, &nlm_blocked); nlmclnt_prepare_block() 113 return block; nlmclnt_prepare_block() 116 void nlmclnt_finish_block(struct nlm_wait *block) nlmclnt_finish_block() argument 118 if (block == NULL) nlmclnt_finish_block() 121 list_del(&block->b_list); nlmclnt_finish_block() 123 kfree(block); nlmclnt_finish_block() 129 int nlmclnt_block(struct nlm_wait *block, struct nlm_rqst *req, long timeout) nlmclnt_block() argument 133 /* A borken server might ask us to block even if we didn't nlmclnt_block() 136 if (block == NULL) nlmclnt_block() 147 ret = wait_event_interruptible_timeout(block->b_wait, nlmclnt_block() 148 block->b_status != nlm_lck_blocked, nlmclnt_block() 153 if (block->b_status == nlm_lck_denied_grace_period) nlmclnt_block() 154 block->b_status = nlm_lck_blocked; nlmclnt_block() 155 req->a_res.status = block->b_status; nlmclnt_block() 166 struct nlm_wait *block; nlmclnt_grant() local 174 list_for_each_entry(block, &nlm_blocked, b_list) { nlmclnt_grant() 175 struct file_lock *fl_blocked = block->b_lock; nlmclnt_grant() 187 if (!rpc_cmp_addr(nlm_addr(block->b_host), addr)) nlmclnt_grant() 194 block->b_status = nlm_granted; nlmclnt_grant() 195 wake_up(&block->b_wait); nlmclnt_grant() 230 struct nlm_wait *block; reclaimer() local 288 list_for_each_entry(block, &nlm_blocked, b_list) { reclaimer() 289 if (block->b_host == host) { reclaimer() 290 block->b_status = nlm_lck_denied_grace_period; reclaimer() 291 wake_up(&block->b_wait); reclaimer()
|
/linux-4.1.27/drivers/mmc/card/ |
H A D | Makefile | 6 mmc_block-objs := block.o queue.o
|
/linux-4.1.27/drivers/w1/ |
H A D | w1_netlink.c | 60 struct w1_cb_block *block; member in struct:w1_cb_node 68 * @block: block to calculate 74 static u16 w1_reply_len(struct w1_cb_block *block) w1_reply_len() argument 76 if (!block->cn) w1_reply_len() 78 return (u8 *)block->cn - (u8 *)block->first_cn + block->cn->len; w1_reply_len() 81 static void w1_unref_block(struct w1_cb_block *block) w1_unref_block() argument 83 if (atomic_sub_return(1, &block->refcnt) == 0) { w1_unref_block() 84 u16 len = w1_reply_len(block); w1_unref_block() 86 cn_netlink_send_mult(block->first_cn, len, w1_unref_block() 87 block->portid, 0, GFP_KERNEL); w1_unref_block() 89 kfree(block); w1_unref_block() 95 * @block: block to make space on 101 static void w1_reply_make_space(struct w1_cb_block *block, u16 space) w1_reply_make_space() argument 103 u16 len = w1_reply_len(block); w1_reply_make_space() 104 if (len + space >= block->maxlen) { w1_reply_make_space() 105 cn_netlink_send_mult(block->first_cn, len, block->portid, 0, GFP_KERNEL); w1_reply_make_space() 106 block->first_cn->len = 0; w1_reply_make_space() 107 block->cn = NULL; w1_reply_make_space() 108 block->msg = NULL; w1_reply_make_space() 109 block->cmd = NULL; w1_reply_make_space() 114 static void w1_netlink_check_send(struct w1_cb_block *block) w1_netlink_check_send() argument 116 if (!(block->request_cn.flags & W1_CN_BUNDLE) && block->cn) w1_netlink_check_send() 117 w1_reply_make_space(block, block->maxlen); w1_netlink_check_send() 121 * w1_netlink_setup_msg() - prepare to write block->msg 122 * @block: block to operate on 125 * block->cn will be setup with the correct ack, advancing if needed 126 * block->cn->len does not include space for block->msg 127 * block->msg advances but remains uninitialized 129 static void w1_netlink_setup_msg(struct w1_cb_block *block, u32 ack) w1_netlink_setup_msg() argument 131 if (block->cn && block->cn->ack == ack) { w1_netlink_setup_msg() 132 block->msg = (struct w1_netlink_msg *)(block->cn->data + block->cn->len); w1_netlink_setup_msg() 135 if (block->cn) w1_netlink_setup_msg() 136 block->cn = (struct cn_msg *)(block->cn->data + w1_netlink_setup_msg() 137 block->cn->len); w1_netlink_setup_msg() 139 block->cn = block->first_cn; w1_netlink_setup_msg() 141 memcpy(block->cn, &block->request_cn, sizeof(*block->cn)); w1_netlink_setup_msg() 142 block->cn->len = 0; w1_netlink_setup_msg() 143 block->cn->ack = ack; w1_netlink_setup_msg() 144 block->msg = (struct w1_netlink_msg *)block->cn->data; w1_netlink_setup_msg() 152 static void w1_netlink_queue_cmd(struct w1_cb_block *block, w1_netlink_queue_cmd() argument 156 w1_reply_make_space(block, sizeof(struct cn_msg) + w1_netlink_queue_cmd() 163 w1_netlink_setup_msg(block, block->request_cn.seq + 1); w1_netlink_queue_cmd() 164 memcpy(block->msg, block->cur_msg, sizeof(*block->msg)); w1_netlink_queue_cmd() 165 block->cn->len += sizeof(*block->msg); w1_netlink_queue_cmd() 166 block->msg->len = 0; w1_netlink_queue_cmd() 167 block->cmd = (struct w1_netlink_cmd *)(block->msg->data); w1_netlink_queue_cmd() 170 if (block->cmd != cmd) w1_netlink_queue_cmd() 171 memcpy(block->cmd, cmd, space); w1_netlink_queue_cmd() 172 block->cn->len += space; w1_netlink_queue_cmd() 173 block->msg->len += space; w1_netlink_queue_cmd() 179 static void w1_netlink_queue_status(struct w1_cb_block *block, w1_netlink_queue_status() argument 184 w1_reply_make_space(block, space); w1_netlink_queue_status() 185 w1_netlink_setup_msg(block, block->request_cn.ack); w1_netlink_queue_status() 187 memcpy(block->msg, req_msg, sizeof(*req_msg)); w1_netlink_queue_status() 188 block->cn->len += sizeof(*req_msg); w1_netlink_queue_status() 189 block->msg->len = 0; w1_netlink_queue_status() 190 block->msg->status = (u8)-error; w1_netlink_queue_status() 192 struct w1_netlink_cmd *cmd = (struct w1_netlink_cmd *)block->msg->data; w1_netlink_queue_status() 194 block->cn->len += sizeof(*cmd); w1_netlink_queue_status() 195 block->msg->len += sizeof(*cmd); w1_netlink_queue_status() 198 w1_netlink_check_send(block); w1_netlink_queue_status() 208 * Use when a block isn't available to queue the message to and cn, msg 255 struct w1_cb_block *block = dev->priv; w1_send_slave() local 256 struct w1_netlink_cmd *cache_cmd = block->cmd; w1_send_slave() 259 w1_reply_make_space(block, sizeof(*data)); w1_send_slave() 262 if (!block->cmd) { w1_send_slave() 264 w1_netlink_queue_cmd(block, cache_cmd); w1_send_slave() 267 data = (u64 *)(block->cmd->data + block->cmd->len); w1_send_slave() 270 block->cn->len += sizeof(*data); w1_send_slave() 271 block->msg->len += sizeof(*data); w1_send_slave() 272 block->cmd->len += sizeof(*data); w1_send_slave() 472 dev->priv = node->block; w1_process_cb() 475 node->block->cur_msg = node->msg; w1_process_cb() 487 w1_netlink_check_send(node->block); w1_process_cb() 489 w1_netlink_queue_status(node->block, node->msg, cmd, err); w1_process_cb() 498 w1_netlink_queue_status(node->block, node->msg, cmd, err); w1_process_cb() 501 * the block w1_process_cb() 514 w1_unref_block(node->block); w1_process_cb() 562 struct w1_cb_block *block = NULL; w1_cn_callback() local 610 /* allocate space for the block, a copy of the original message, w1_cn_callback() 614 * cn->len doesn't include itself which is part of the block w1_cn_callback() 616 size = /* block + original message */ w1_cn_callback() 622 block = kzalloc(size, GFP_KERNEL); w1_cn_callback() 623 if (!block) { w1_cn_callback() 631 atomic_set(&block->refcnt, 1); w1_cn_callback() 632 block->portid = nsp->portid; w1_cn_callback() 633 memcpy(&block->request_cn, cn, sizeof(*cn) + cn->len); w1_cn_callback() 634 node = (struct w1_cb_node *)(block->request_cn.data + cn->len); w1_cn_callback() 645 block->maxlen = reply_size; w1_cn_callback() 646 block->first_cn = (struct cn_msg *)(node + node_count); w1_cn_callback() 647 memset(block->first_cn, 0, sizeof(*block->first_cn)); w1_cn_callback() 697 atomic_inc(&block->refcnt); w1_cn_callback() 699 node->block = block; w1_cn_callback() 700 node->msg = (struct w1_netlink_msg *)((u8 *)&block->request_cn + w1_cn_callback() 712 /* Can't queue because that modifies block and another w1_cn_callback() 728 if (block) w1_cn_callback() 729 w1_unref_block(block); w1_cn_callback()
|
/linux-4.1.27/arch/mips/alchemy/common/ |
H A D | vss.c | 2 * Au1300 media block power gating (VSS) 14 #define VSS_CLKRST 0x04 /* clock/block control */ 21 /* enable a block as outlined in the databook */ __enable_block() 22 static inline void __enable_block(int block) __enable_block() argument 24 void __iomem *base = (void __iomem *)VSS_ADDR(block); __enable_block() 52 /* disable a block as outlined in the databook */ __disable_block() 53 static inline void __disable_block(int block) __disable_block() argument 55 void __iomem *base = (void __iomem *)VSS_ADDR(block); __disable_block() 69 void au1300_vss_block_control(int block, int enable) au1300_vss_block_control() argument 76 /* only one block at a time */ au1300_vss_block_control() 79 __enable_block(block); au1300_vss_block_control() 81 __disable_block(block); au1300_vss_block_control()
|
H A D | usb.c | 2 * USB block power/access management abstraction. 4 * Au1000+: The OHCI block control register is at the far end of the OHCI memory 26 /* Au1000 USB block config bits */ 28 #define USBHEN_CE (1 << 3) /* OHCI block clock enable */ 29 #define USBHEN_E (1 << 2) /* OHCI block enable */ 30 #define USBHEN_C (1 << 1) /* OHCI block coherency bit */ 114 /* no USB block active, do disable all PHYs */ __au1300_usb_phyctl() 130 r = __raw_readl(base + USB_DWC_CTRL3); /* enable OHCI block */ __au1300_ohci_control() 264 static inline int au1300_usb_control(int block, int enable) au1300_usb_control() argument 270 switch (block) { au1300_usb_control() 359 static inline int au1200_usb_control(int block, int enable) au1200_usb_control() argument 364 switch (block) { au1200_usb_control() 381 /* initialize USB block(s) to a known working state */ au1200_usb_init() 457 static inline int au1000_usb_control(int block, int enable, unsigned long rb, au1000_usb_control() argument 462 switch (block) { au1000_usb_control() 474 * @block: USB block to target 475 * @enable: set 1 to enable a block, 0 to disable 477 int alchemy_usb_control(int block, int enable) alchemy_usb_control() argument 487 ret = au1000_usb_control(block, enable, alchemy_usb_control() 491 ret = au1000_usb_control(block, enable, alchemy_usb_control() 495 ret = au1200_usb_control(block, enable); alchemy_usb_control() 498 ret = au1300_usb_control(block, enable); alchemy_usb_control()
|
/linux-4.1.27/fs/quota/ |
H A D | quota_tree.h | 12 * Structure of header of block with quota structures. It is padded to 16 bytes so 13 * there will be space for exactly 21 quota-entries in a block 16 __le32 dqdh_next_free; /* Number of next block with free entry */ 17 __le32 dqdh_prev_free; /* Number of previous block with free entry */ 18 __le16 dqdh_entries; /* Number of valid entries in block */
|
/linux-4.1.27/fs/befs/ |
H A D | io.c | 30 befs_blocknr_t block = 0; befs_bread_iaddr() local 43 block = iaddr2blockno(sb, &iaddr); befs_bread_iaddr() 45 befs_debug(sb, "%s: offset = %lu", __func__, (unsigned long)block); befs_bread_iaddr() 47 bh = sb_bread(sb, block); befs_bread_iaddr() 50 befs_error(sb, "Failed to read block %lu", befs_bread_iaddr() 51 (unsigned long)block); befs_bread_iaddr() 64 befs_bread(struct super_block *sb, befs_blocknr_t block) befs_bread() argument 68 befs_debug(sb, "---> Enter %s %lu", __func__, (unsigned long)block); befs_bread() 70 bh = sb_bread(sb, block); befs_bread() 73 befs_error(sb, "Failed to read block %lu", befs_bread() 74 (unsigned long)block); befs_bread()
|
H A D | datastream.c | 53 befs_blocknr_t block; /* block coresponding to pos */ befs_read_datastream() local 56 block = pos >> BEFS_SB(sb)->block_shift; befs_read_datastream() 58 *off = pos - (block << BEFS_SB(sb)->block_shift); befs_read_datastream() 60 if (befs_fblock2brun(sb, ds, block, &run) != BEFS_OK) { befs_read_datastream() 61 befs_error(sb, "BeFS: Error finding disk addr of block %lu", befs_read_datastream() 62 (unsigned long)block); befs_read_datastream() 68 befs_error(sb, "BeFS: Error reading block %lu from datastream", befs_read_datastream() 69 (unsigned long)block); befs_read_datastream() 79 * Takes a file position and gives back a brun who's starting block 80 * is block number fblock of the file. 107 "befs_fblock2brun() was asked to find block %lu, " befs_fblock2brun() 136 befs_error(sb, "BeFS: Error reading datastream block " befs_read_lsymlink() 179 metablocks = 1; /* Start with 1 block for inode */ befs_count_blocks() 181 /* Size of indirect block */ befs_count_blocks() 186 Double indir block, plus all the indirect blocks it mapps befs_count_blocks() 187 In the double-indirect range, all block runs of data are befs_count_blocks() 189 how many data block runs are in the double-indirect region, befs_count_blocks() 216 Finds the block run that starts at file block number blockno 230 contains the blockno-th filesystem block. This is necessary 231 because the block runs map variable amounts of data. Simply 233 incrementing this by the length of each block run as we come 238 When/if blockno is found, if blockno is inside of a block 240 of the block run, so that blockno is the start and len is 258 befs_error(sb, "%s passed block outside of direct region", befs_find_brun_direct() 283 Finds the block run that starts at file block number blockno 296 For each block in the indirect run of the datastream, read 331 "disk block %lu from the indirect brun", befs_find_brun_indirect() 352 "<--- %s found file block " befs_find_brun_indirect() 366 "file block %lu", __func__, (unsigned long)blockno); befs_find_brun_indirect() 373 Finds the block run that starts at file block number blockno 386 The block runs in the double-indirect region are different. 388 block run maps a constant amount of file data. This means 389 that we can directly calculate how many block runs into the 391 maps a particular filesystem block. 394 inode addresses in the double-indirect block will point us 395 to the indirect block that contains the mapping for the data, 397 indirect block maps the data block we are after. 404 the indirect block and perform a similar process to find 405 the actual block run that maps the data block we are interested 439 * the indirect block pointed to by the double indirect block befs_find_brun_dblindirect() 444 * the double indirect block befs_find_brun_dblindirect() 454 * the indirect block contains pos. befs_find_brun_dblindirect() 461 /* Read double indirect block */ befs_find_brun_dblindirect() 466 "of the double-indirect block", __func__, befs_find_brun_dblindirect() 476 "double-indirect block at blockno %lu", __func__, befs_find_brun_dblindirect() 491 /* Read indirect block */ befs_find_brun_dblindirect() 496 "of the indirect block", __func__, indir_indx); befs_find_brun_dblindirect() 503 befs_error(sb, "%s couldn't read the indirect block " befs_find_brun_dblindirect() 524 befs_debug(sb, "Found file block %lu in double_indirect[%d][%d]," befs_find_brun_dblindirect()
|
/linux-4.1.27/sound/pci/ctxfi/ |
H A D | ctvmem.c | 29 * Find or create vm block based on requested @size. 35 struct ct_vm_block *block = NULL, *entry; get_vm_block() local 49 break; /* found a block that is big enough */ get_vm_block() 58 block = entry; get_vm_block() 62 block = kzalloc(sizeof(*block), GFP_KERNEL); get_vm_block() 63 if (!block) get_vm_block() 66 block->addr = entry->addr; get_vm_block() 67 block->size = size; get_vm_block() 68 list_add(&block->list, &vm->used); get_vm_block() 75 return block; get_vm_block() 78 static void put_vm_block(struct ct_vm *vm, struct ct_vm_block *block) put_vm_block() argument 83 block->size = CT_PAGE_ALIGN(block->size); put_vm_block() 86 list_del(&block->list); put_vm_block() 87 vm->size += block->size; put_vm_block() 91 if (entry->addr >= (block->addr + block->size)) put_vm_block() 95 list_add_tail(&block->list, &vm->unused); put_vm_block() 96 entry = block; put_vm_block() 98 if ((block->addr + block->size) == entry->addr) { put_vm_block() 99 entry->addr = block->addr; put_vm_block() 100 entry->size += block->size; put_vm_block() 101 kfree(block); put_vm_block() 103 __list_add(&block->list, pos->prev, pos); put_vm_block() 104 entry = block; put_vm_block() 129 struct ct_vm_block *block; ct_vm_map() local 135 block = get_vm_block(vm, size, atc); ct_vm_map() 136 if (block == NULL) { ct_vm_map() 138 "No virtual memory block that is big enough to allocate!\n"); ct_vm_map() 143 pte_start = (block->addr >> CT_PAGE_SHIFT); ct_vm_map() 144 pages = block->size >> CT_PAGE_SHIFT; ct_vm_map() 151 block->size = size; ct_vm_map() 152 return block; ct_vm_map() 155 static void ct_vm_unmap(struct ct_vm *vm, struct ct_vm_block *block) ct_vm_unmap() argument 158 put_vm_block(vm, block); ct_vm_unmap() 179 struct ct_vm_block *block; ct_vm_create() local 209 block = kzalloc(sizeof(*block), GFP_KERNEL); ct_vm_create() 210 if (NULL != block) { ct_vm_create() 211 block->addr = 0; ct_vm_create() 212 block->size = vm->size; ct_vm_create() 213 list_add(&block->list, &vm->unused); ct_vm_create()
|
/linux-4.1.27/drivers/gpio/ |
H A D | gpio-sch311x.c | 43 struct sch311x_gpio_block { /* one GPIO block runtime data */ 48 spinlock_t lock; /* lock for this GPIO block */ 145 struct sch311x_gpio_block *block = to_sch311x_gpio_block(chip); sch311x_gpio_request() local 147 if (block->config_regs[offset] == 0) /* GPIO is not available */ sch311x_gpio_request() 150 if (!request_region(block->runtime_reg + block->config_regs[offset], sch311x_gpio_request() 153 block->runtime_reg + block->config_regs[offset]); sch311x_gpio_request() 161 struct sch311x_gpio_block *block = to_sch311x_gpio_block(chip); sch311x_gpio_free() local 163 if (block->config_regs[offset] == 0) /* GPIO is not available */ sch311x_gpio_free() 166 release_region(block->runtime_reg + block->config_regs[offset], 1); sch311x_gpio_free() 171 struct sch311x_gpio_block *block = to_sch311x_gpio_block(chip); sch311x_gpio_get() local 174 spin_lock(&block->lock); sch311x_gpio_get() 175 data = inb(block->runtime_reg + block->data_reg); sch311x_gpio_get() 176 spin_unlock(&block->lock); sch311x_gpio_get() 181 static void __sch311x_gpio_set(struct sch311x_gpio_block *block, __sch311x_gpio_set() argument 184 unsigned char data = inb(block->runtime_reg + block->data_reg); __sch311x_gpio_set() 189 outb(data, block->runtime_reg + block->data_reg); __sch311x_gpio_set() 195 struct sch311x_gpio_block *block = to_sch311x_gpio_block(chip); sch311x_gpio_set() local 197 spin_lock(&block->lock); sch311x_gpio_set() 198 __sch311x_gpio_set(block, offset, value); sch311x_gpio_set() 199 spin_unlock(&block->lock); sch311x_gpio_set() 204 struct sch311x_gpio_block *block = to_sch311x_gpio_block(chip); sch311x_gpio_direction_in() local 206 spin_lock(&block->lock); sch311x_gpio_direction_in() 207 outb(SCH311X_GPIO_CONF_IN, block->runtime_reg + sch311x_gpio_direction_in() 208 block->config_regs[offset]); sch311x_gpio_direction_in() 209 spin_unlock(&block->lock); sch311x_gpio_direction_in() 217 struct sch311x_gpio_block *block = to_sch311x_gpio_block(chip); sch311x_gpio_direction_out() local 219 spin_lock(&block->lock); sch311x_gpio_direction_out() 221 outb(SCH311X_GPIO_CONF_OUT, block->runtime_reg + sch311x_gpio_direction_out() 222 block->config_regs[offset]); sch311x_gpio_direction_out() 224 __sch311x_gpio_set(block, offset, value); sch311x_gpio_direction_out() 226 spin_unlock(&block->lock); sch311x_gpio_direction_out() 234 struct sch311x_gpio_block *block; sch311x_gpio_probe() local 251 block = &priv->blocks[i]; sch311x_gpio_probe() 253 spin_lock_init(&block->lock); sch311x_gpio_probe() 255 block->chip.label = DRV_NAME; sch311x_gpio_probe() 256 block->chip.owner = THIS_MODULE; sch311x_gpio_probe() 257 block->chip.request = sch311x_gpio_request; sch311x_gpio_probe() 258 block->chip.free = sch311x_gpio_free; sch311x_gpio_probe() 259 block->chip.direction_input = sch311x_gpio_direction_in; sch311x_gpio_probe() 260 block->chip.direction_output = sch311x_gpio_direction_out; sch311x_gpio_probe() 261 block->chip.get = sch311x_gpio_get; sch311x_gpio_probe() 262 block->chip.set = sch311x_gpio_set; sch311x_gpio_probe() 263 block->chip.ngpio = 8; sch311x_gpio_probe() 264 block->chip.dev = &pdev->dev; sch311x_gpio_probe() 265 block->chip.base = sch311x_gpio_blocks[i].base; sch311x_gpio_probe() 266 block->config_regs = sch311x_gpio_blocks[i].config_regs; sch311x_gpio_probe() 267 block->data_reg = sch311x_gpio_blocks[i].data_reg; sch311x_gpio_probe() 268 block->runtime_reg = pdata->runtime_reg; sch311x_gpio_probe() 270 err = gpiochip_add(&block->chip); sch311x_gpio_probe() 277 "SMSC SCH311x GPIO block %d registered.\n", i); sch311x_gpio_probe() 301 "SMSC SCH311x GPIO block %d unregistered.\n", i); sch311x_gpio_remove()
|
/linux-4.1.27/drivers/mtd/ |
H A D | inftlmount.c | 48 unsigned int i, block; find_boot_record() local 68 for (block = 0; block < inftl->nb_blocks; block++) { find_boot_record() 75 ret = mtd_read(mtd, block * inftl->EraseSize, SECTORSIZE, find_boot_record() 83 printk(KERN_WARNING "INFTL: block read at 0x%x " find_boot_record() 85 block * inftl->EraseSize, find_boot_record() 89 "failures for this block will " find_boot_record() 102 block * inftl->EraseSize + SECTORSIZE + 8, find_boot_record() 107 "(err %d)\n", block * inftl->EraseSize, find_boot_record() 120 mtd_read(mtd, block * inftl->EraseSize + 4096, SECTORSIZE, find_boot_record() 185 block >>= mh->BlockMultiplierBits; find_boot_record() 217 * to erase the hidden block for full find_boot_record() 299 /* Mark this boot record (NFTL MediaHeader) block as reserved */ find_boot_record() 300 inftl->PUtable[block] = BLOCK_RESERVED; find_boot_record() 314 inftl->MediaUnit = block; find_boot_record() 372 int INFTL_formatblock(struct INFTLrecord *inftl, int block) INFTL_formatblock() argument 380 pr_debug("INFTL: INFTL_formatblock(inftl=%p,block=%d)\n", inftl, block); INFTL_formatblock() 389 instr->addr = block * inftl->EraseSize; INFTL_formatblock() 393 mark only the failed block in the bbt. */ INFTL_formatblock() 399 printk(KERN_WARNING "INFTL: error while formatting block %d\n", INFTL_formatblock() 400 block); INFTL_formatblock() 419 instr->addr = block * inftl->EraseSize + SECTORSIZE * 2; INFTL_formatblock() 424 /* could not format, update the bad block table (caller is responsible INFTL_formatblock() 440 unsigned int block = first_block, block1; format_chain() local 442 printk(KERN_WARNING "INFTL: formatting chain at block %d\n", format_chain() 446 block1 = inftl->PUtable[block]; format_chain() 448 printk(KERN_WARNING "INFTL: formatting block %d\n", block); format_chain() 449 if (INFTL_formatblock(inftl, block) < 0) { format_chain() 453 inftl->PUtable[block] = BLOCK_RESERVED; format_chain() 455 inftl->PUtable[block] = BLOCK_FREE; format_chain() 458 /* Goto next block on the chain */ format_chain() 459 block = block1; format_chain() 461 if (block == BLOCK_NIL || block >= inftl->lastEUN) format_chain() 513 int logical, block, i; INFTL_dumpVUchains() local 520 block = s->VUtable[logical]; INFTL_dumpVUchains() 521 if (block >= s->nb_blocks) INFTL_dumpVUchains() 523 pr_debug(" LOGICAL %d --> %d ", logical, block); INFTL_dumpVUchains() 525 if (s->PUtable[block] == BLOCK_NIL) INFTL_dumpVUchains() 527 block = s->PUtable[block]; INFTL_dumpVUchains() 528 pr_debug("%d ", block); INFTL_dumpVUchains() 540 unsigned int block, first_block, prev_block, last_block; INFTL_mount() local 561 logical_block = block = BLOCK_NIL; INFTL_mount() 575 * Any block that is in any way invalid will be left in the INFTL_mount() 587 block = first_block; INFTL_mount() 592 (s->PUtable[block] != BLOCK_NOTEXPLORED)) { INFTL_mount() 593 /* Nothing to do here, onto next block */ INFTL_mount() 597 if (inftl_read_oob(mtd, block * s->EraseSize + 8, INFTL_mount() 599 inftl_read_oob(mtd, block * s->EraseSize + INFTL_mount() 610 ANACtable[block] = h0.ANAC; INFTL_mount() 612 /* Previous block is relative to start of Partition */ INFTL_mount() 617 if (s->PUtable[block] != BLOCK_NOTEXPLORED) { INFTL_mount() 621 s->PUtable[last_block] = block; INFTL_mount() 626 /* Check for invalid block */ INFTL_mount() 628 printk(KERN_WARNING "INFTL: corrupt block %d " INFTL_mount() 630 "mark 0x%x?\n", block, first_block, INFTL_mount() 644 s->PUtable[block] = BLOCK_FREE; INFTL_mount() 648 /* Sanity checks on block numbers */ INFTL_mount() 654 "block %d in chain %d?\n", INFTL_mount() 655 block, first_block); INFTL_mount() 671 * Current block is valid, so if we followed a virtual INFTL_mount() 673 * block pointer in our PUtable now. Then move onto INFTL_mount() 674 * the previous block in the chain. INFTL_mount() 676 s->PUtable[block] = BLOCK_NIL; INFTL_mount() 678 s->PUtable[last_block] = block; INFTL_mount() 679 last_block = block; INFTL_mount() 680 block = prev_block; INFTL_mount() 683 if (block == BLOCK_NIL) INFTL_mount() 686 /* Validate next block before following it... */ INFTL_mount() 687 if (block > s->lastEUN) { INFTL_mount() 689 "block %d in chain %d?\n", block, INFTL_mount() 703 * newest block in the chain, but it is the newest we have INFTL_mount() 720 block = s->VUtable[logical_block]; INFTL_mount() 724 if (block >= BLOCK_RESERVED) INFTL_mount() 727 ANAC = ANACtable[block]; INFTL_mount() 729 if (s->PUtable[block] == BLOCK_NIL) INFTL_mount() 731 if (s->PUtable[block] > s->lastEUN) { INFTL_mount() 734 s->PUtable[block], logical_block); INFTL_mount() 735 s->PUtable[block] = BLOCK_NIL; INFTL_mount() 738 if (ANACtable[block] != ANAC) { INFTL_mount() 742 * newest block and oldest block. INFTL_mount() 744 s->VUtable[logical_block] = block; INFTL_mount() 750 last_block = block; INFTL_mount() 751 block = s->PUtable[block]; INFTL_mount() 767 * Third pass, format unreferenced blocks and init free block count. INFTL_mount() 773 for (block = s->firstEUN; block <= s->lastEUN; block++) { INFTL_mount() 774 if (s->PUtable[block] == BLOCK_NOTEXPLORED) { INFTL_mount() 775 printk("INFTL: unreferenced block %d, formatting it\n", INFTL_mount() 776 block); INFTL_mount() 777 if (INFTL_formatblock(s, block) < 0) INFTL_mount() 778 s->PUtable[block] = BLOCK_RESERVED; INFTL_mount() 780 s->PUtable[block] = BLOCK_FREE; INFTL_mount() 782 if (s->PUtable[block] == BLOCK_FREE) { INFTL_mount() 785 s->LastFreeEUN = block; INFTL_mount()
|
H A D | nftlmount.c | 41 unsigned int block, boot_record_count = 0; find_boot_record() local 61 for (block = 0; block < nftl->nb_blocks; block++) { find_boot_record() 66 ret = mtd_read(mtd, block * nftl->EraseSize, SECTORSIZE, find_boot_record() 75 block * nftl->EraseSize, nftl->mbd.mtd->index, ret); find_boot_record() 77 printk(KERN_WARNING "Further failures for this block will not be printed\n"); find_boot_record() 86 block * nftl->EraseSize, nftl->mbd.mtd->index); find_boot_record() 92 ret = nftl_read_oob(mtd, block * nftl->EraseSize + find_boot_record() 97 block * nftl->EraseSize, nftl->mbd.mtd->index, ret); find_boot_record() 107 block * nftl->EraseSize, nftl->mbd.mtd->index, find_boot_record() 113 ret = mtd->read(mtd, block * nftl->EraseSize, SECTORSIZE, find_boot_record() 117 block * nftl->EraseSize, nftl->mbd.mtd->index, ret); find_boot_record() 124 block * nftl->EraseSize, nftl->mbd.mtd->index); find_boot_record() 137 nftl->MediaUnit * nftl->EraseSize, block * nftl->EraseSize); find_boot_record() 146 nftl->SpareMediaUnit = block; find_boot_record() 148 /* Mark this boot record (NFTL MediaHeader) block as reserved */ find_boot_record() 149 nftl->ReplUnitTable[block] = BLOCK_RESERVED; find_boot_record() 224 /* Mark this boot record (NFTL MediaHeader) block as reserved */ find_boot_record() 225 nftl->ReplUnitTable[block] = BLOCK_RESERVED; find_boot_record() 230 The new DiskOnChip driver already scanned the bad block table. Just query it. find_boot_record() 234 block * nftl->EraseSize + i + find_boot_record() 254 nftl->MediaUnit = block; find_boot_record() 257 } /* foreach (block) */ find_boot_record() 307 int NFTL_formatblock(struct NFTLrecord *nftl, int block) NFTL_formatblock() argument 316 if (nftl_read_oob(mtd, block * nftl->EraseSize + SECTORSIZE + 8, NFTL_formatblock() 332 instr->addr = block * nftl->EraseSize; NFTL_formatblock() 337 printk("Error while formatting block %d\n", block); NFTL_formatblock() 345 /* wrap (almost impossible with current flash) or free block */ NFTL_formatblock() 356 if (nftl_write_oob(mtd, block * nftl->EraseSize + SECTORSIZE + NFTL_formatblock() 361 /* could not format, update the bad block table (caller is responsible NFTL_formatblock() 373 * not updated according (due to power failure or something) which leaves the block 374 * in an inconsistent state. So we have to check if a block is really FREE in this 379 unsigned int block, i, status; check_sectors_in_chain() local 385 block = first_block; check_sectors_in_chain() 389 block * nftl->EraseSize + i * SECTORSIZE, check_sectors_in_chain() 400 check_free_sectors(nftl, block * nftl->EraseSize + i * SECTORSIZE, check_sectors_in_chain() 402 printk("Incorrect free sector %d in block %d: " check_sectors_in_chain() 404 i, block); check_sectors_in_chain() 409 nftl_write_oob(mtd, block * check_sectors_in_chain() 421 block = nftl->ReplUnitTable[block]; check_sectors_in_chain() 422 if (!(block == BLOCK_NIL || block < nftl->nb_blocks)) check_sectors_in_chain() 423 printk("incorrect ReplUnitTable[] : %d\n", block); check_sectors_in_chain() 424 if (block == BLOCK_NIL || block >= nftl->nb_blocks) check_sectors_in_chain() 432 unsigned int length = 0, block = first_block; calc_chain_length() local 443 block = nftl->ReplUnitTable[block]; calc_chain_length() 444 if (!(block == BLOCK_NIL || block < nftl->nb_blocks)) calc_chain_length() 445 printk("incorrect ReplUnitTable[] : %d\n", block); calc_chain_length() 446 if (block == BLOCK_NIL || block >= nftl->nb_blocks) calc_chain_length() 455 * It is not strictly correct to begin from the first block of the chain because 457 * flag in a block inside it. But is it really a problem ? 464 unsigned int block = first_block, block1; format_chain() local 466 printk("Formatting chain at block %d\n", first_block); format_chain() 469 block1 = nftl->ReplUnitTable[block]; format_chain() 471 printk("Formatting block %d\n", block); format_chain() 472 if (NFTL_formatblock(nftl, block) < 0) { format_chain() 474 nftl->ReplUnitTable[block] = BLOCK_RESERVED; format_chain() 476 nftl->ReplUnitTable[block] = BLOCK_FREE; format_chain() 479 /* goto next block on the chain */ format_chain() 480 block = block1; format_chain() 482 if (!(block == BLOCK_NIL || block < nftl->nb_blocks)) format_chain() 483 printk("incorrect ReplUnitTable[] : %d\n", block); format_chain() 484 if (block == BLOCK_NIL || block >= nftl->nb_blocks) format_chain() 489 /* check_and_mark_free_block: Verify that a block is free in the NFTL sense (valid erase mark) or 495 static int check_and_mark_free_block(struct NFTLrecord *nftl, int block) check_and_mark_free_block() argument 503 if (nftl_read_oob(mtd, block * nftl->EraseSize + SECTORSIZE + 8, 8, check_and_mark_free_block() 509 /* if no erase mark, the block must be totally free. This is check_and_mark_free_block() 511 if (check_free_sectors (nftl, block * nftl->EraseSize, nftl->EraseSize, 1) != 0) check_and_mark_free_block() 514 /* free block : write erase mark */ check_and_mark_free_block() 519 block * nftl->EraseSize + SECTORSIZE + 8, 8, check_and_mark_free_block() 527 if (check_free_sectors (nftl, block * nftl->EraseSize + i, check_and_mark_free_block() 531 if (nftl_read_oob(mtd, block * nftl->EraseSize + i, check_and_mark_free_block() 556 static int get_fold_mark(struct NFTLrecord *nftl, unsigned int block) get_fold_mark() argument 562 if (nftl_read_oob(mtd, block * nftl->EraseSize + 2 * SECTORSIZE + 8, get_fold_mark() 573 unsigned int block, first_block, is_first_block; NFTL_mount() local 591 /* first pass : explore each block chain */ NFTL_mount() 594 /* if the block was not already explored, we can look at it */ NFTL_mount() 596 block = first_block; NFTL_mount() 601 /* read the block header. If error, we format the chain */ NFTL_mount() 603 block * s->EraseSize + 8, 8, NFTL_mount() 606 block * s->EraseSize + NFTL_mount() 609 s->ReplUnitTable[block] = BLOCK_NIL; NFTL_mount() 622 /* invalid/free block test */ NFTL_mount() 626 if (check_and_mark_free_block(s, block) < 0) { NFTL_mount() 628 printk("Formatting block %d\n", block); NFTL_mount() 629 if (NFTL_formatblock(s, block) < 0) { NFTL_mount() 630 /* could not format: reserve the block */ NFTL_mount() 631 s->ReplUnitTable[block] = BLOCK_RESERVED; NFTL_mount() 633 s->ReplUnitTable[block] = BLOCK_FREE; NFTL_mount() 636 /* free block: mark it */ NFTL_mount() 637 s->ReplUnitTable[block] = BLOCK_FREE; NFTL_mount() 639 /* directly examine the next block. */ NFTL_mount() 642 /* the block was in a chain : this is bad. We NFTL_mount() 645 block, first_block); NFTL_mount() 646 s->ReplUnitTable[block] = BLOCK_NIL; NFTL_mount() 654 /* this block is not the first block in chain : NFTL_mount() 662 printk("Block %d: incorrect logical block: %d expected: %d\n", NFTL_mount() 663 block, logical_block, first_logical_block); NFTL_mount() 669 /* we accept that a block is marked as first NFTL_mount() 670 block while being last block in a chain NFTL_mount() 672 if (get_fold_mark(s, block) != FOLD_MARK_IN_PROGRESS || NFTL_mount() 674 printk("Block %d: incorrectly marked as first block in chain\n", NFTL_mount() 675 block); NFTL_mount() 680 printk("Block %d: folding in progress - ignoring first block flag\n", NFTL_mount() 681 block); NFTL_mount() 688 s->ReplUnitTable[block] = BLOCK_NIL; NFTL_mount() 691 printk("Block %d: referencing invalid block %d\n", NFTL_mount() 692 block, rep_block); NFTL_mount() 694 s->ReplUnitTable[block] = BLOCK_NIL; NFTL_mount() 698 we accept that the last block of a chain has NFTL_mount() 701 last block appeared first */ NFTL_mount() 706 printk("Block %d: folding in progress - ignoring first block flag\n", NFTL_mount() 708 s->ReplUnitTable[block] = rep_block; NFTL_mount() 711 printk("Block %d: referencing block %d already in another chain\n", NFTL_mount() 712 block, rep_block); NFTL_mount() 715 s->ReplUnitTable[block] = BLOCK_NIL; NFTL_mount() 720 s->ReplUnitTable[block] = rep_block; NFTL_mount() 721 block = rep_block; NFTL_mount() 738 printk("Could read foldmark at block %d\n", first_block); NFTL_mount() 771 /* second pass to format unreferenced blocks and init free block count */ NFTL_mount() 775 for (block = 0; block < s->nb_blocks; block++) { NFTL_mount() 776 if (s->ReplUnitTable[block] == BLOCK_NOTEXPLORED) { NFTL_mount() 777 printk("Unreferenced block %d, formatting it\n", block); NFTL_mount() 778 if (NFTL_formatblock(s, block) < 0) NFTL_mount() 779 s->ReplUnitTable[block] = BLOCK_RESERVED; NFTL_mount() 781 s->ReplUnitTable[block] = BLOCK_FREE; NFTL_mount() 783 if (s->ReplUnitTable[block] == BLOCK_FREE) { NFTL_mount() 785 s->LastFreeEUN = block; NFTL_mount()
|
H A D | sm_ftl.c | 147 * Read LBA associated with block 148 * returns -1, if block is erased 159 /* First test for erased block */ sm_read_lba() 195 static loff_t sm_mkoffset(struct sm_ftl *ftl, int zone, int block, int boffset) sm_mkoffset() argument 199 WARN_ON(block >= ftl->zone_size); sm_mkoffset() 202 if (block == -1) sm_mkoffset() 205 return (zone * SM_MAX_ZONE_SIZE + block) * ftl->block_size + boffset; sm_mkoffset() 210 int *zone, int *block, int *boffset) sm_break_offset() 213 *block = do_div(offset, ftl->max_lba); sm_break_offset() 237 int zone, int block, int boffset, sm_read_sector() 247 if (block == -1) { sm_read_sector() 267 if (zone == 0 && block == ftl->cis_block && boffset == sm_read_sector() 278 ret = mtd_read_oob(mtd, sm_mkoffset(ftl, zone, block, boffset), &ops); sm_read_sector() 282 dbg("read of block %d at zone %d, failed due to error (%d)", sm_read_sector() 283 block, zone, ret); sm_read_sector() 300 dbg("read of block %d at zone %d, failed because it is marked" sm_read_sector() 301 " as bad" , block, zone); sm_read_sector() 309 dbg("read of block %d at zone %d, failed due to ECC error", sm_read_sector() 310 block, zone); sm_read_sector() 319 int zone, int block, int boffset, sm_write_sector() 328 if (zone == 0 && (block == ftl->cis_block || block == 0)) { sm_write_sector() 343 ret = mtd_write_oob(mtd, sm_mkoffset(ftl, zone, block, boffset), &ops); sm_write_sector() 348 dbg("write to block %d at zone %d, failed with error %d", sm_write_sector() 349 block, zone, ret); sm_write_sector() 362 /* ------------------------ block IO ------------------------------------- */ 364 /* Write a block using data and lba, and invalid sector bitmap */ sm_write_block() 366 int zone, int block, int lba, sm_write_block() 387 sm_printk("sector %d of block at LBA %d of zone %d" sm_write_block() 401 if (!sm_write_sector(ftl, zone, block, boffset, sm_write_block() 407 /* If write fails. try to erase the block */ sm_write_block() 410 This is intended to repair block that are marked sm_write_block() 413 if (sm_erase_block(ftl, zone, block, 0)) sm_write_block() 419 sm_mark_block_bad(ftl, zone, block); sm_write_block() 427 /* Mark whole block at offset 'offs' as bad. */ sm_mark_block_bad() 428 static void sm_mark_block_bad(struct sm_ftl *ftl, int zone, int block) sm_mark_block_bad() argument 442 sm_printk("marking block %d of zone %d as bad", block, zone); sm_mark_block_bad() 448 sm_write_sector(ftl, zone, block, boffset, NULL, &oob); sm_mark_block_bad() 452 * Erase a block within a zone 453 * If erase succeeds, it updates free block fifo, otherwise marks block as bad 455 static int sm_erase_block(struct sm_ftl *ftl, int zone_num, uint16_t block, sm_erase_block() argument 464 erase.addr = sm_mkoffset(ftl, zone_num, block, 0); sm_erase_block() 473 if (zone_num == 0 && (block == ftl->cis_block || block == 0)) { sm_erase_block() 479 sm_printk("erase of block %d in zone %d failed", sm_erase_block() 480 block, zone_num); sm_erase_block() 488 sm_printk("erase of block %d in zone %d failed after wait", sm_erase_block() 489 block, zone_num); sm_erase_block() 495 (const unsigned char *)&block, sizeof(block)); sm_erase_block() 499 sm_mark_block_bad(ftl, zone_num, block); sm_erase_block() 509 /* Thoroughly test that block is valid. */ sm_check_block() 510 static int sm_check_block(struct sm_ftl *ftl, int zone, int block) sm_check_block() argument 519 /* First just check that block doesn't look fishy */ sm_check_block() 526 if (sm_read_sector(ftl, zone, block, boffset, NULL, &oob)) sm_check_block() 539 /* If the block is sliced (partially erased usually) erase it */ sm_check_block() 541 sm_erase_block(ftl, zone, block, 1); sm_check_block() 689 int block, boffset; sm_find_cis() local 693 /* Search for first valid block */ sm_find_cis() 694 for (block = 0 ; block < ftl->zone_size - ftl->max_lba ; block++) { sm_find_cis() 696 if (sm_read_sector(ftl, 0, block, 0, NULL, &oob)) sm_find_cis() 708 /* Search for first valid sector in this block */ sm_find_cis() 712 if (sm_read_sector(ftl, 0, block, boffset, NULL, &oob)) sm_find_cis() 723 ftl->cis_block = block; sm_find_cis() 735 dbg("CIS block found at offset %x", sm_find_cis() 736 block * ftl->block_size + sm_find_cis() 762 uint16_t block; sm_init_zone() local 784 for (block = 0 ; block < ftl->zone_size ; block++) { sm_init_zone() 787 if (zone_num == 0 && block <= ftl->cis_block) sm_init_zone() 791 if (sm_read_sector(ftl, zone_num, block, 0, NULL, &oob)) sm_init_zone() 794 /* Test to see if block is erased. It is enough to test sm_init_zone() 798 (unsigned char *)&block, 2); sm_init_zone() 802 /* If block is marked as bad, skip it */ sm_init_zone() 804 /* However the way the block valid status is defined, ensures sm_init_zone() 807 dbg("PH %04d <-> <marked bad>", block); sm_init_zone() 814 /* Invalid LBA means that block is damaged. */ sm_init_zone() 818 dbg("PH %04d <-> LBA %04d(bad)", block, lba); sm_init_zone() 826 dbg_verbose("PH %04d <-> LBA %04d", block, lba); sm_init_zone() 827 zone->lba_to_phys_table[lba] = block; sm_init_zone() 833 lba, zone->lba_to_phys_table[lba], block, zone_num); sm_init_zone() 835 /* Test that this block is valid*/ sm_init_zone() 836 if (sm_check_block(ftl, zone_num, block)) sm_init_zone() 839 /* Test now the old block */ sm_init_zone() 842 zone->lba_to_phys_table[lba] = block; sm_init_zone() 851 sm_erase_block(ftl, zone_num, block, 1); sm_init_zone() 864 /* Randomize first block we write to */ sm_init_zone() 870 (unsigned char *)&block, 2); sm_init_zone() 872 kfifo_in(&zone->free_sectors, (const unsigned char *)&block, 2); sm_init_zone() 898 /* Initialize the one block cache */ sm_cache_init() 908 /* Put sector in one block cache */ sm_cache_put() 948 /* Try to read all unread areas of the cache block*/ sm_cache_flush() 964 /* we could still continue by erasing/writing the current block, sm_cache_flush() 981 /* Write succesfull, so erase and free the old block */ sm_cache_flush() 1016 int zone_num, block, boffset; sm_read() local 1018 sm_break_offset(ftl, sect_no << 9, &zone_num, &block, &boffset); sm_read() 1029 if (ftl->cache_zone == zone_num && ftl->cache_block == block) { sm_read() 1035 /* Translate the block and return if doesn't exist in the table */ sm_read() 1036 block = zone->lba_to_phys_table[block]; sm_read() 1038 if (block == -1) { sm_read() 1043 if (sm_read_sector(ftl, zone_num, block, boffset, buf, NULL)) { sm_read() 1061 int error = 0, zone_num, block, boffset; sm_write() local 1064 sm_break_offset(ftl, sec_no << 9, &zone_num, &block, &boffset); sm_write() 1077 if (ftl->cache_block != block || ftl->cache_zone != zone_num) { sm_write() 1083 ftl->cache_block = block; sm_write() 1203 dbg("each block consists of %d bytes", sm_add_mtd() 209 sm_break_offset(struct sm_ftl *ftl, loff_t offset, int *zone, int *block, int *boffset) sm_break_offset() argument 236 sm_read_sector(struct sm_ftl *ftl, int zone, int block, int boffset, uint8_t *buffer, struct sm_oob *oob) sm_read_sector() argument 318 sm_write_sector(struct sm_ftl *ftl, int zone, int block, int boffset, uint8_t *buffer, struct sm_oob *oob) sm_write_sector() argument 365 sm_write_block(struct sm_ftl *ftl, uint8_t *buf, int zone, int block, int lba, unsigned long invalid_bitmap) sm_write_block() argument
|
H A D | rfd_ftl.c | 56 struct block { struct 79 int reserved_block; /* block next up for reclaim */ 80 int current_block; /* block to write to */ 87 struct block *blocks; 94 struct block *block = &part->blocks[block_no]; build_block_map() local 97 block->offset = part->block_size * block_no; build_block_map() 100 block->state = BLOCK_UNUSED; build_block_map() 104 block->state = BLOCK_OK; build_block_map() 115 block->free_sectors++; build_block_map() 138 part->sector_map[entry] = block->offset + build_block_map() 141 block->used_sectors++; build_block_map() 144 if (block->free_sectors == part->data_sectors_per_block) build_block_map() 163 /* each erase block has three bytes header, followed by the map */ scan_header() 187 part->blocks = kcalloc(part->total_blocks, sizeof(struct block), scan_header() 326 static int erase_block(struct partition *part, int block) erase_block() argument 337 erase->addr = part->blocks[block].offset; erase_block() 341 part->blocks[block].state = BLOCK_ERASING; erase_block() 342 part->blocks[block].free_sectors = 0; erase_block() 447 int block, best_block, score, old_sector_block; reclaim_block() local 460 for (block=0; block<part->total_blocks; block++) { reclaim_block() 463 if (block == part->reserved_block) reclaim_block() 471 if (part->blocks[block].free_sectors) reclaim_block() 474 this_score = part->blocks[block].used_sectors; reclaim_block() 476 if (block == old_sector_block) reclaim_block() 479 /* no point in moving a full block */ reclaim_block() 480 if (part->blocks[block].used_sectors == reclaim_block() 485 this_score += part->blocks[block].erases; reclaim_block() 488 best_block = block; reclaim_block() 499 pr_debug("reclaim_block: reclaiming block #%d with %d used " reclaim_block() 513 * IMPROVE: It would be best to choose the block with the most deleted sectors, 519 int block, stop; find_free_block() local 521 block = part->current_block == -1 ? find_free_block() 523 stop = block; find_free_block() 526 if (part->blocks[block].free_sectors && find_free_block() 527 block != part->reserved_block) find_free_block() 528 return block; find_free_block() 530 if (part->blocks[block].state == BLOCK_UNUSED) find_free_block() 531 erase_block(part, block); find_free_block() 533 if (++block >= part->total_blocks) find_free_block() 534 block = 0; find_free_block() 536 } while (block != stop); find_free_block() 543 int rc, block; find_writable_block() local 546 block = find_free_block(part); find_writable_block() 548 if (block == -1) { find_writable_block() 554 block = find_free_block(part); find_writable_block() 557 if (block == -1) { find_writable_block() 563 rc = mtd_read(part->mbd.mtd, part->blocks[block].offset, find_writable_block() 573 part->blocks[block].offset); find_writable_block() 577 part->current_block = block; find_writable_block() 585 int block, offset, rc; mark_sector_deleted() local 590 block = old_addr / part->block_size; mark_sector_deleted() 594 addr = part->blocks[block].offset + mark_sector_deleted() 607 if (block == part->current_block) mark_sector_deleted() 610 part->blocks[block].used_sectors--; mark_sector_deleted() 612 if (!part->blocks[block].used_sectors && mark_sector_deleted() 613 !part->blocks[block].free_sectors) mark_sector_deleted() 614 rc = erase_block(part, block); mark_sector_deleted() 620 static int find_free_sector(const struct partition *part, const struct block *block) find_free_sector() argument 624 i = stop = part->data_sectors_per_block - block->free_sectors; find_free_sector() 642 struct block *block; do_writesect() local 657 block = &part->blocks[part->current_block]; do_writesect() 659 i = find_free_sector(part, block); do_writesect() 667 block->offset; do_writesect() 686 addr = block->offset + (HEADER_MAP_OFFSET + i) * sizeof(u16); do_writesect() 698 block->used_sectors++; do_writesect() 699 block->free_sectors--; do_writesect()
|
H A D | sm_ftl.h | 35 int block_size; /* block size in bytes */ 42 int cis_block; /* CIS block location */ 43 int cis_boffset; /* CIS offset in the block */ 48 int cache_block; /* block number of cached block */ 49 int cache_zone; /* zone of cached block */ 50 unsigned char *cache_data; /* cached block data */ 90 static int sm_erase_block(struct sm_ftl *ftl, int zone_num, uint16_t block, 92 static void sm_mark_block_bad(struct sm_ftl *ftl, int zone_num, int block);
|
H A D | inftlcore.c | 42 * Maximum number of loops while examining next block, to have a 229 /* Scan for a free block */ INFTL_findfreeblock() 255 int block, silly; INFTL_foldchain() local 276 * 512-byte block within the Chain. INFTL_foldchain() 280 for (block = 0; block < inftl->EraseSize/SECTORSIZE; block ++) { INFTL_foldchain() 281 if ((BlockMap[block] != BLOCK_NIL) || INFTL_foldchain() 282 BlockDeleted[block]) INFTL_foldchain() 286 + (block * SECTORSIZE), 16, &retlen, INFTL_foldchain() 297 BlockMap[block] = thisEUN; INFTL_foldchain() 300 BlockDeleted[block] = 1; INFTL_foldchain() 304 "for block %d in EUN %d: %x\n", INFTL_foldchain() 305 block, thisEUN, status); INFTL_foldchain() 320 * OK. We now know the location of every block in the Virtual Unit INFTL_foldchain() 326 for (block = 0; block < inftl->EraseSize/SECTORSIZE ; block++) { INFTL_foldchain() 334 if (BlockMap[block] == targetEUN || (pendingblock == INFTL_foldchain() 335 (thisVUC * (inftl->EraseSize / SECTORSIZE) + block))) { INFTL_foldchain() 340 * Copy only in non free block (free blocks can only INFTL_foldchain() 343 if (BlockMap[block] == BLOCK_NIL) INFTL_foldchain() 347 (inftl->EraseSize * BlockMap[block]) + (block * SECTORSIZE), INFTL_foldchain() 353 (inftl->EraseSize * BlockMap[block]) + (block * SECTORSIZE), INFTL_foldchain() 364 (block * SECTORSIZE), SECTORSIZE, &retlen, INFTL_foldchain() 389 /* Unlink the last block from the chain. */ INFTL_foldchain() 395 * Could not erase : mark block as reserved. INFTL_foldchain() 471 * for this block. Make it available if it isn't already. 473 static inline u16 INFTL_findwriteunit(struct INFTLrecord *inftl, unsigned block) INFTL_findwriteunit() argument 475 unsigned int thisVUC = block / (inftl->EraseSize / SECTORSIZE); INFTL_findwriteunit() 477 unsigned long blockofs = (block * SECTORSIZE) & (inftl->EraseSize -1); INFTL_findwriteunit() 485 pr_debug("INFTL: INFTL_findwriteunit(inftl=%p,block=%d)\n", INFTL_findwriteunit() 486 inftl, block); INFTL_findwriteunit() 491 * a free space for the block in question. INFTL_findwriteunit() 502 pr_debug("INFTL: status of block %d in EUN %d is %x\n", INFTL_findwriteunit() 503 block , writeEUN, status); INFTL_findwriteunit() 517 * Invalid block. Don't use it any more. INFTL_findwriteunit() 529 /* Skip to next block in chain */ INFTL_findwriteunit() 550 thisEUN = INFTL_makefreeblock(inftl, block); INFTL_findwriteunit() 579 * Insert new block into virtual chain. Firstly update the INFTL_findwriteunit() 580 * block headers in flash... INFTL_findwriteunit() 644 int block, silly; INFTL_trydeletechain() local 667 for (block = 0; block < inftl->EraseSize/SECTORSIZE; block++) { INFTL_trydeletechain() 668 if (BlockUsed[block] || BlockDeleted[block]) INFTL_trydeletechain() 672 + (block * SECTORSIZE), 8 , &retlen, INFTL_trydeletechain() 683 BlockUsed[block] = 1; INFTL_trydeletechain() 686 BlockDeleted[block] = 1; INFTL_trydeletechain() 690 "for block %d in EUN %d: 0x%x\n", INFTL_trydeletechain() 691 block, thisEUN, status); INFTL_trydeletechain() 704 for (block = 0; block < inftl->EraseSize/SECTORSIZE; block++) INFTL_trydeletechain() 705 if (BlockUsed[block]) INFTL_trydeletechain() 709 * For each block in the chain free it and make it available INFTL_trydeletechain() 737 * Could not erase : mark block as reserved. INFTL_trydeletechain() 758 static int INFTL_deleteblock(struct INFTLrecord *inftl, unsigned block) INFTL_deleteblock() argument 760 unsigned int thisEUN = inftl->VUtable[block / (inftl->EraseSize / SECTORSIZE)]; INFTL_deleteblock() 761 unsigned long blockofs = (block * SECTORSIZE) & (inftl->EraseSize - 1); INFTL_deleteblock() 769 "block=%d)\n", inftl, block); INFTL_deleteblock() 789 "block %d in EUN %d: 0x%x\n", INFTL_deleteblock() 790 block, thisEUN, status); INFTL_deleteblock() 797 block / (inftl->EraseSize / SECTORSIZE)); INFTL_deleteblock() 812 INFTL_trydeletechain(inftl, block / (inftl->EraseSize / SECTORSIZE)); INFTL_deleteblock() 817 static int inftl_writeblock(struct mtd_blktrans_dev *mbd, unsigned long block, inftl_writeblock() argument 822 unsigned long blockofs = (block * SECTORSIZE) & (inftl->EraseSize - 1); inftl_writeblock() 827 pr_debug("INFTL: inftl_writeblock(inftl=%p,block=%ld," inftl_writeblock() 828 "buffer=%p)\n", inftl, block, buffer); inftl_writeblock() 830 /* Is block all zero? */ inftl_writeblock() 836 writeEUN = INFTL_findwriteunit(inftl, block); inftl_writeblock() 840 "block to write to\n"); inftl_writeblock() 842 * If we _still_ haven't got a block to use, inftl_writeblock() 859 INFTL_deleteblock(inftl, block); inftl_writeblock() 865 static int inftl_readblock(struct mtd_blktrans_dev *mbd, unsigned long block, inftl_readblock() argument 869 unsigned int thisEUN = inftl->VUtable[block / (inftl->EraseSize / SECTORSIZE)]; inftl_readblock() 870 unsigned long blockofs = (block * SECTORSIZE) & (inftl->EraseSize - 1); inftl_readblock() 877 pr_debug("INFTL: inftl_readblock(inftl=%p,block=%ld," inftl_readblock() 878 "buffer=%p)\n", inftl, block, buffer); inftl_readblock() 898 "block %ld in EUN %d: 0x%04x\n", inftl_readblock() 899 block, thisEUN, status); inftl_readblock() 906 block / (inftl->EraseSize / SECTORSIZE)); inftl_readblock() 915 /* The requested block is not on the media, return all 0x00 */ inftl_readblock()
|
H A D | nftlcore.c | 41 /* maximum number of loops while examining next block, to have a 205 /* For a given Virtual Unit Chain: find or create a free block and NFTL_findfreeblock() 218 /* Scan for a free block */ NFTL_findfreeblock() 251 int block; NFTL_foldchain() local 270 512-byte block within the Chain. NFTL_foldchain() 278 for (block = 0; block < nftl->EraseSize / 512; block ++) { NFTL_foldchain() 280 (block * 512), 16 , &retlen, NFTL_foldchain() 282 if (block == 2) { NFTL_foldchain() 295 BlockLastState[block] = status; NFTL_foldchain() 299 BlockFreeFound[block] = 1; NFTL_foldchain() 303 if (!BlockFreeFound[block]) NFTL_foldchain() 304 BlockMap[block] = thisEUN; NFTL_foldchain() 308 "in Virtual Unit Chain %d for block %d\n", NFTL_foldchain() 309 thisVUC, block); NFTL_foldchain() 312 if (!BlockFreeFound[block]) NFTL_foldchain() 313 BlockMap[block] = BLOCK_NIL; NFTL_foldchain() 317 "in Virtual Unit Chain %d for block %d\n", NFTL_foldchain() 318 thisVUC, block); NFTL_foldchain() 324 printk("Unknown status for block %d in EUN %d: %x\n", NFTL_foldchain() 325 block, thisEUN, status); NFTL_foldchain() 341 with them (i.e. BlockMap[block] != BLOCK_NIL) are NFTL_foldchain() 343 block. If not, we're going to have to fold out-of-place NFTL_foldchain() 346 for (block = 0; block < nftl->EraseSize / 512 ; block++) { NFTL_foldchain() 347 if (BlockLastState[block] != SECTOR_FREE && NFTL_foldchain() 348 BlockMap[block] != BLOCK_NIL && NFTL_foldchain() 349 BlockMap[block] != targetEUN) { NFTL_foldchain() 351 "block %d was %x lastEUN, " NFTL_foldchain() 353 thisVUC, block, BlockLastState[block], NFTL_foldchain() 354 BlockMap[block], NFTL_foldchain() 355 BlockMap[block]== targetEUN ? "==" : "!=", NFTL_foldchain() 399 /* OK. We now know the location of every block in the Virtual Unit Chain, NFTL_foldchain() 404 for (block = 0; block < nftl->EraseSize / 512 ; block++) { NFTL_foldchain() 409 if (BlockMap[block] == targetEUN || NFTL_foldchain() 410 (pendingblock == (thisVUC * (nftl->EraseSize / 512) + block))) { NFTL_foldchain() 414 /* copy only in non free block (free blocks can only NFTL_foldchain() 416 if (BlockMap[block] == BLOCK_NIL) NFTL_foldchain() 420 (nftl->EraseSize * BlockMap[block]) + (block * 512), NFTL_foldchain() 426 (nftl->EraseSize * BlockMap[block]) + (block * 512), NFTL_foldchain() 437 (block * 512), 512, &retlen, movebuf, (char *)&oob); NFTL_foldchain() 447 /* OK. We've moved the whole lot into the new block. Now we have to free the original blocks. */ NFTL_foldchain() 457 /* For each block in the old chain (except the targetEUN of course), NFTL_foldchain() 465 /* could not erase : mark block as reserved NFTL_foldchain() 533 for this block. Make it available if it isn't already 535 static inline u16 NFTL_findwriteunit(struct NFTLrecord *nftl, unsigned block) NFTL_findwriteunit() argument 538 u16 thisVUC = block / (nftl->EraseSize / 512); NFTL_findwriteunit() 541 unsigned long blockofs = (block * 512) & (nftl->EraseSize -1); NFTL_findwriteunit() 548 a free space for the block in question. NFTL_findwriteunit() 568 pr_debug("Status of block %d in EUN %d is %x\n", NFTL_findwriteunit() 569 block , writeEUN, le16_to_cpu(bci.Status)); NFTL_findwriteunit() 581 // Invalid block. Don't use it any more. Must implement. NFTL_findwriteunit() 592 /* Skip to next block in chain */ NFTL_findwriteunit() 599 /* Try to find an already-free block */ NFTL_findwriteunit() 639 /* We've found a free block. Insert it into the chain. */ NFTL_findwriteunit() 642 thisVUC |= 0x8000; /* It's a replacement block */ NFTL_findwriteunit() 644 /* The first block in a new chain */ NFTL_findwriteunit() 661 /* we link the new block to the chain only after the NFTL_findwriteunit() 662 block is ready. It avoids the case where the chain NFTL_findwriteunit() 663 could point to a free block */ NFTL_findwriteunit() 687 static int nftl_writeblock(struct mtd_blktrans_dev *mbd, unsigned long block, nftl_writeblock() argument 692 unsigned long blockofs = (block * 512) & (nftl->EraseSize - 1); nftl_writeblock() 696 writeEUN = NFTL_findwriteunit(nftl, block); nftl_writeblock() 700 "NFTL_writeblock(): Cannot find block to write to\n"); nftl_writeblock() 701 /* If we _still_ haven't got a block to use, we're screwed */ nftl_writeblock() 714 static int nftl_readblock(struct mtd_blktrans_dev *mbd, unsigned long block, nftl_readblock() argument 720 u16 thisEUN = nftl->EUNtable[block / (nftl->EraseSize / 512)]; nftl_readblock() 721 unsigned long blockofs = (block * 512) & (nftl->EraseSize - 1); nftl_readblock() 751 printk("Unknown status for block %ld in EUN %d: %x\n", nftl_readblock() 752 block, thisEUN, status); nftl_readblock() 758 block / (nftl->EraseSize / 512)); nftl_readblock() 767 /* the requested block is not on the media, return all 0x00 */ nftl_readblock()
|
H A D | mtdblock_ro.c | 30 unsigned long block, char *buf) mtdblock_readsect() 34 if (mtd_read(dev->mtd, (block * 512), 512, &retlen, buf)) mtdblock_readsect() 40 unsigned long block, char *buf) mtdblock_writesect() 44 if (mtd_write(dev->mtd, (block * 512), 512, &retlen, buf)) mtdblock_writesect() 99 MODULE_DESCRIPTION("Simple read-only block device emulation access to MTD devices"); 29 mtdblock_readsect(struct mtd_blktrans_dev *dev, unsigned long block, char *buf) mtdblock_readsect() argument 39 mtdblock_writesect(struct mtd_blktrans_dev *dev, unsigned long block, char *buf) mtdblock_writesect() argument
|
/linux-4.1.27/arch/mips/cavium-octeon/crypto/ |
H A D | octeon-md5.c | 56 const u64 *block = _block; octeon_md5_transform() local 58 write_octeon_64bit_block_dword(block[0], 0); octeon_md5_transform() 59 write_octeon_64bit_block_dword(block[1], 1); octeon_md5_transform() 60 write_octeon_64bit_block_dword(block[2], 2); octeon_md5_transform() 61 write_octeon_64bit_block_dword(block[3], 3); octeon_md5_transform() 62 write_octeon_64bit_block_dword(block[4], 4); octeon_md5_transform() 63 write_octeon_64bit_block_dword(block[5], 5); octeon_md5_transform() 64 write_octeon_64bit_block_dword(block[6], 6); octeon_md5_transform() 65 octeon_md5_start(block[7]); octeon_md5_transform() 85 const u32 avail = sizeof(mctx->block) - (mctx->byte_count & 0x3f); octeon_md5_update() 92 memcpy((char *)mctx->block + (sizeof(mctx->block) - avail), octeon_md5_update() 97 memcpy((char *)mctx->block + (sizeof(mctx->block) - avail), data, octeon_md5_update() 103 octeon_md5_transform(mctx->block); octeon_md5_update() 107 while (len >= sizeof(mctx->block)) { octeon_md5_update() 109 data += sizeof(mctx->block); octeon_md5_update() 110 len -= sizeof(mctx->block); octeon_md5_update() 116 memcpy(mctx->block, data, len); octeon_md5_update() 125 char *p = (char *)mctx->block + offset; octeon_md5_final() 137 octeon_md5_transform(mctx->block); octeon_md5_final() 138 p = (char *)mctx->block; octeon_md5_final() 143 mctx->block[14] = cpu_to_le32(mctx->byte_count << 3); octeon_md5_final() 144 mctx->block[15] = cpu_to_le32(mctx->byte_count >> 29); octeon_md5_final() 145 octeon_md5_transform(mctx->block); octeon_md5_final()
|
H A D | octeon-sha512.c | 61 const u64 *block = _block; octeon_sha512_transform() local 63 write_octeon_64bit_block_sha512(block[0], 0); octeon_sha512_transform() 64 write_octeon_64bit_block_sha512(block[1], 1); octeon_sha512_transform() 65 write_octeon_64bit_block_sha512(block[2], 2); octeon_sha512_transform() 66 write_octeon_64bit_block_sha512(block[3], 3); octeon_sha512_transform() 67 write_octeon_64bit_block_sha512(block[4], 4); octeon_sha512_transform() 68 write_octeon_64bit_block_sha512(block[5], 5); octeon_sha512_transform() 69 write_octeon_64bit_block_sha512(block[6], 6); octeon_sha512_transform() 70 write_octeon_64bit_block_sha512(block[7], 7); octeon_sha512_transform() 71 write_octeon_64bit_block_sha512(block[8], 8); octeon_sha512_transform() 72 write_octeon_64bit_block_sha512(block[9], 9); octeon_sha512_transform() 73 write_octeon_64bit_block_sha512(block[10], 10); octeon_sha512_transform() 74 write_octeon_64bit_block_sha512(block[11], 11); octeon_sha512_transform() 75 write_octeon_64bit_block_sha512(block[12], 12); octeon_sha512_transform() 76 write_octeon_64bit_block_sha512(block[13], 13); octeon_sha512_transform() 77 write_octeon_64bit_block_sha512(block[14], 14); octeon_sha512_transform() 78 octeon_sha512_start(block[15]); octeon_sha512_transform()
|
H A D | octeon-crypto.h | 66 * The value is the final block dword (64-bit). 77 * The value is the final block dword (64-bit). 88 * The value is the final block dword (64-bit). 140 * The value is the final block word (64-bit). 151 * The value is the final block dword (64-bit). 162 * The value is the final block dword (64-bit). 214 * The value is the final block word (64-bit).
|
H A D | octeon-sha1.c | 66 const u64 *block = _block; octeon_sha1_transform() local 68 write_octeon_64bit_block_dword(block[0], 0); octeon_sha1_transform() 69 write_octeon_64bit_block_dword(block[1], 1); octeon_sha1_transform() 70 write_octeon_64bit_block_dword(block[2], 2); octeon_sha1_transform() 71 write_octeon_64bit_block_dword(block[3], 3); octeon_sha1_transform() 72 write_octeon_64bit_block_dword(block[4], 4); octeon_sha1_transform() 73 write_octeon_64bit_block_dword(block[5], 5); octeon_sha1_transform() 74 write_octeon_64bit_block_dword(block[6], 6); octeon_sha1_transform() 75 octeon_sha1_start(block[7]); octeon_sha1_transform()
|
/linux-4.1.27/drivers/s390/block/ |
H A D | dasd_genhd.c | 29 int dasd_gendisk_alloc(struct dasd_block *block) dasd_gendisk_alloc() argument 36 base = block->base; dasd_gendisk_alloc() 76 gdp->queue = block->request_queue; dasd_gendisk_alloc() 77 block->gdp = gdp; dasd_gendisk_alloc() 78 set_capacity(block->gdp, 0); dasd_gendisk_alloc() 79 add_disk(block->gdp); dasd_gendisk_alloc() 86 void dasd_gendisk_free(struct dasd_block *block) dasd_gendisk_free() argument 88 if (block->gdp) { dasd_gendisk_free() 89 del_gendisk(block->gdp); dasd_gendisk_free() 90 block->gdp->private_data = NULL; dasd_gendisk_free() 91 put_disk(block->gdp); dasd_gendisk_free() 92 block->gdp = NULL; dasd_gendisk_free() 99 int dasd_scan_partitions(struct dasd_block *block) dasd_scan_partitions() argument 105 bdev = bdget_disk(block->gdp, 0); dasd_scan_partitions() 107 DBF_DEV_EVENT(DBF_ERR, block->base, "%s", dasd_scan_partitions() 114 DBF_DEV_EVENT(DBF_ERR, block->base, dasd_scan_partitions() 128 DBF_DEV_EVENT(DBF_ERR, block->base, dasd_scan_partitions() 143 block->bdev = bdev; dasd_scan_partitions() 151 void dasd_destroy_partitions(struct dasd_block *block) dasd_destroy_partitions() argument 162 bdev = block->bdev; dasd_destroy_partitions() 163 block->bdev = NULL; dasd_destroy_partitions() 174 for (bpart.pno = block->gdp->minors - 1; bpart.pno > 0; bpart.pno--) dasd_destroy_partitions() 177 invalidate_partition(block->gdp, 0); dasd_destroy_partitions() 180 set_capacity(block->gdp, 0); dasd_destroy_partitions()
|
H A D | dasd_ioctl.c | 59 (loff_t)get_capacity(base->block->gdp) << 9); dasd_ioctl_enable() 83 * BIODASDDISABLE to disable accesses to the device via the block dasd_ioctl_disable() 103 static int dasd_ioctl_quiesce(struct dasd_block *block) dasd_ioctl_quiesce() argument 108 base = block->base; dasd_ioctl_quiesce() 124 static int dasd_ioctl_resume(struct dasd_block *block) dasd_ioctl_resume() argument 129 base = block->base; dasd_ioctl_resume() 139 dasd_schedule_block_bh(block); dasd_ioctl_resume() 146 static int dasd_ioctl_abortio(struct dasd_block *block) dasd_ioctl_abortio() argument 152 base = block->base; dasd_ioctl_abortio() 160 spin_lock_irqsave(&block->request_queue_lock, flags); dasd_ioctl_abortio() 161 spin_lock(&block->queue_lock); dasd_ioctl_abortio() 162 list_for_each_entry_safe(cqr, n, &block->ccw_queue, blocklist) { dasd_ioctl_abortio() 167 spin_unlock(&block->queue_lock); dasd_ioctl_abortio() 169 spin_lock(&block->queue_lock); dasd_ioctl_abortio() 172 spin_unlock(&block->queue_lock); dasd_ioctl_abortio() 173 spin_unlock_irqrestore(&block->request_queue_lock, flags); dasd_ioctl_abortio() 175 dasd_schedule_block_bh(block); dasd_ioctl_abortio() 182 static int dasd_ioctl_allowio(struct dasd_block *block) dasd_ioctl_allowio() argument 186 base = block->base; dasd_ioctl_allowio() 203 dasd_format(struct dasd_block *block, struct format_data_t *fdata) dasd_format() argument 210 base = block->base; dasd_format() 231 struct block_device *bdev = bdget_disk(block->gdp, 0); dasd_format() 295 rc = dasd_format(base->block, &fdata); dasd_ioctl_format() 304 static int dasd_ioctl_reset_profile(struct dasd_block *block) dasd_ioctl_reset_profile() argument 306 dasd_profile_reset(&block->profile); dasd_ioctl_reset_profile() 313 static int dasd_ioctl_read_profile(struct dasd_block *block, void __user *argp) dasd_ioctl_read_profile() argument 322 spin_lock_bh(&block->profile.lock); dasd_ioctl_read_profile() 323 if (block->profile.data) { dasd_ioctl_read_profile() 324 data->dasd_io_reqs = block->profile.data->dasd_io_reqs; dasd_ioctl_read_profile() 325 data->dasd_io_sects = block->profile.data->dasd_io_sects; dasd_ioctl_read_profile() 326 memcpy(data->dasd_io_secs, block->profile.data->dasd_io_secs, dasd_ioctl_read_profile() 328 memcpy(data->dasd_io_times, block->profile.data->dasd_io_times, dasd_ioctl_read_profile() 330 memcpy(data->dasd_io_timps, block->profile.data->dasd_io_timps, dasd_ioctl_read_profile() 332 memcpy(data->dasd_io_time1, block->profile.data->dasd_io_time1, dasd_ioctl_read_profile() 334 memcpy(data->dasd_io_time2, block->profile.data->dasd_io_time2, dasd_ioctl_read_profile() 337 block->profile.data->dasd_io_time2ps, dasd_ioctl_read_profile() 339 memcpy(data->dasd_io_time3, block->profile.data->dasd_io_time3, dasd_ioctl_read_profile() 342 block->profile.data->dasd_io_nr_req, dasd_ioctl_read_profile() 344 spin_unlock_bh(&block->profile.lock); dasd_ioctl_read_profile() 346 spin_unlock_bh(&block->profile.lock); dasd_ioctl_read_profile() 357 static int dasd_ioctl_reset_profile(struct dasd_block *block) dasd_ioctl_reset_profile() argument 362 static int dasd_ioctl_read_profile(struct dasd_block *block, void __user *argp) dasd_ioctl_read_profile() argument 371 static int dasd_ioctl_information(struct dasd_block *block, dasd_ioctl_information() argument 382 base = block->base; dasd_ioctl_information() 412 dasd_info->open_count = atomic_read(&block->open_count); dasd_ioctl_information() 413 if (!block->bdev) dasd_ioctl_information() 421 (dasd_check_blocksize(block->bp_block))) dasd_ioctl_information() 429 if (block->request_queue->request_fn) { dasd_ioctl_information() 434 spin_lock_irqsave(&block->lock, flags); dasd_ioctl_information() 435 list_for_each(l, &block->request_queue->queue_head) dasd_ioctl_information() 437 spin_unlock_irqrestore(&block->lock, flags); dasd_ioctl_information() 486 static int dasd_ioctl_readall_cmb(struct dasd_block *block, unsigned int cmd, dasd_ioctl_readall_cmb() argument 493 ret = cmf_readall(block->base->cdev, &data); dasd_ioctl_readall_cmb() 502 struct dasd_block *block; dasd_ioctl() local 520 block = base->block; dasd_ioctl() 530 rc = dasd_ioctl_quiesce(block); dasd_ioctl() 533 rc = dasd_ioctl_resume(block); dasd_ioctl() 536 rc = dasd_ioctl_abortio(block); dasd_ioctl() 539 rc = dasd_ioctl_allowio(block); dasd_ioctl() 545 rc = dasd_ioctl_information(block, cmd, argp); dasd_ioctl() 548 rc = dasd_ioctl_information(block, cmd, argp); dasd_ioctl() 551 rc = dasd_ioctl_read_profile(block, argp); dasd_ioctl() 554 rc = dasd_ioctl_reset_profile(block); dasd_ioctl() 569 rc = dasd_ioctl_readall_cmb(block, cmd, argp); dasd_ioctl() 575 rc = base->discipline->ioctl(block, cmd, argp); dasd_ioctl()
|
H A D | dasd_proc.c | 38 struct dasd_block *block; dasd_devices_show() local 44 if (device->block) dasd_devices_show() 45 block = device->block; dasd_devices_show() 58 if (block->gdp) dasd_devices_show() 60 MAJOR(disk_devt(block->gdp)), dasd_devices_show() 61 MINOR(disk_devt(block->gdp))); dasd_devices_show() 65 if (block->gdp) dasd_devices_show() 66 seq_printf(m, " is %-8s", block->gdp->disk_name); dasd_devices_show() 89 if (dasd_check_blocksize(block->bp_block)) dasd_devices_show() 94 block->bp_block, block->blocks, dasd_devices_show() 95 ((block->bp_block >> 9) * dasd_devices_show() 96 block->blocks) >> 11); dasd_devices_show() 157 if (device->block) dasd_stats_all_block_on() 158 rc = dasd_profile_on(&device->block->profile); dasd_stats_all_block_on() 175 if (device->block) dasd_stats_all_block_off() 176 dasd_profile_off(&device->block->profile); dasd_stats_all_block_off() 190 if (device->block) dasd_stats_all_block_reset() 191 dasd_profile_reset(&device->block->profile); dasd_stats_all_block_reset()
|
H A D | dasd_diag.c | 3 * Based on.......: linux/drivers/s390/block/mdisk.c 65 /* Perform DIAG250 call with block I/O parameter list iob (input and output) 92 /* Initialize block I/O to DIAG device using the specified blocksize and 93 * block offset. On success, return zero and set end_block to contain the 121 /* Remove block I/O environment for device. Return zero on success, non-zero 146 rc = mdsk_init_io(device, device->block->bp_block, 0, NULL); dasd_diag_erp() 223 mdsk_init_io(device, device->block->bp_block, 0, NULL); dasd_diag_term_IO() 316 struct dasd_block *block; dasd_diag_check_device() local 337 block = dasd_alloc_block(); dasd_diag_check_device() 338 if (IS_ERR(block)) { dasd_diag_check_device() 340 "could not allocate dasd block structure"); dasd_diag_check_device() 343 return PTR_ERR(block); dasd_diag_check_device() 345 device->block = block; dasd_diag_check_device() 346 block->base = device; dasd_diag_check_device() 364 /* Figure out position of label block */ dasd_diag_check_device() 432 /* check for label block */ dasd_diag_check_device() 435 /* get formatted blocksize from label block */ dasd_diag_check_device() 437 block->blocks = (unsigned long) label->block_count; dasd_diag_check_device() 439 block->blocks = end_block; dasd_diag_check_device() 440 block->bp_block = bsize; dasd_diag_check_device() 441 block->s2b_shift = 0; /* bits to shift 512 to get a block */ dasd_diag_check_device() 443 block->s2b_shift++; dasd_diag_check_device() 444 rc = mdsk_init_io(device, block->bp_block, 0, NULL); dasd_diag_check_device() 452 pr_info("%s: New DASD with %ld byte/block, total size %ld " dasd_diag_check_device() 454 (unsigned long) block->bp_block, dasd_diag_check_device() 455 (unsigned long) (block->blocks << dasd_diag_check_device() 456 block->s2b_shift) >> 1, dasd_diag_check_device() 464 device->block = NULL; dasd_diag_check_device() 465 dasd_free_block(block); dasd_diag_check_device() 475 dasd_diag_fill_geometry(struct dasd_block *block, struct hd_geometry *geo) dasd_diag_fill_geometry() argument 477 if (dasd_check_blocksize(block->bp_block) != 0) dasd_diag_fill_geometry() 479 geo->cylinders = (block->blocks << block->s2b_shift) >> 10; dasd_diag_fill_geometry() 481 geo->sectors = 128 >> block->s2b_shift; dasd_diag_fill_geometry() 497 /* Create DASD request from block device request. Return pointer to new 500 struct dasd_block *block, dasd_diag_build_cp() 520 blksize = block->bp_block; dasd_diag_build_cp() 521 /* Calculate record id of first and last block. */ dasd_diag_build_cp() 522 first_rec = blk_rq_pos(req) >> block->s2b_shift; dasd_diag_build_cp() 524 (blk_rq_pos(req) + blk_rq_sectors(req) - 1) >> block->s2b_shift; dasd_diag_build_cp() 531 count += bv.bv_len >> (block->s2b_shift + 9); rq_for_each_segment() 562 block->base->features & DASD_FEATURE_FAILFAST) 566 cqr->block = block; 499 dasd_diag_build_cp(struct dasd_device *memdev, struct dasd_block *block, struct request *req) dasd_diag_build_cp() argument
|
H A D | dasd.c | 96 /* Get two pages for normal block device operations. */ dasd_alloc_device() 147 struct dasd_block *block; dasd_alloc_block() local 149 block = kzalloc(sizeof(*block), GFP_ATOMIC); dasd_alloc_block() 150 if (!block) dasd_alloc_block() 153 atomic_set(&block->open_count, -1); dasd_alloc_block() 155 spin_lock_init(&block->request_queue_lock); dasd_alloc_block() 156 atomic_set(&block->tasklet_scheduled, 0); dasd_alloc_block() 157 tasklet_init(&block->tasklet, dasd_alloc_block() 159 (unsigned long) block); dasd_alloc_block() 160 INIT_LIST_HEAD(&block->ccw_queue); dasd_alloc_block() 161 spin_lock_init(&block->queue_lock); dasd_alloc_block() 162 init_timer(&block->timer); dasd_alloc_block() 163 block->timer.function = dasd_block_timeout; dasd_alloc_block() 164 block->timer.data = (unsigned long) block; dasd_alloc_block() 165 spin_lock_init(&block->profile.lock); dasd_alloc_block() 167 return block; dasd_alloc_block() 174 void dasd_free_block(struct dasd_block *block) dasd_free_block() argument 176 kfree(block); dasd_free_block() 193 if (device->block) { dasd_state_new_to_known() 194 rc = dasd_alloc_queue(device->block); dasd_state_new_to_known() 223 if (device->block) dasd_state_known_to_new() 224 dasd_free_queue(device->block); dasd_state_known_to_new() 249 struct dasd_block *block = device->block; dasd_state_known_to_basic() local 253 if (block) { dasd_state_known_to_basic() 254 rc = dasd_gendisk_alloc(block); dasd_state_known_to_basic() 257 block->debugfs_dentry = dasd_state_known_to_basic() 258 dasd_debugfs_setup(block->gdp->disk_name, dasd_state_known_to_basic() 260 dasd_profile_init(&block->profile, block->debugfs_dentry); dasd_state_known_to_basic() 262 dasd_profile_on(&device->block->profile); dasd_state_known_to_basic() 294 if (device->block) { dasd_state_basic_to_known() 295 dasd_profile_exit(&device->block->profile); dasd_state_basic_to_known() 296 debugfs_remove(device->block->debugfs_dentry); dasd_state_basic_to_known() 297 dasd_gendisk_free(device->block); dasd_state_basic_to_known() 298 dasd_block_clear_timer(device->block); dasd_state_basic_to_known() 324 * After the analysis ccw is done (do_analysis returned 0) the block 332 struct dasd_block *block; dasd_state_basic_to_ready() local 335 block = device->block; dasd_state_basic_to_ready() 337 if (block) { dasd_state_basic_to_ready() 338 if (block->base->discipline->do_analysis != NULL) dasd_state_basic_to_ready() 339 rc = block->base->discipline->do_analysis(block); dasd_state_basic_to_ready() 347 dasd_setup_queue(block); dasd_state_basic_to_ready() 348 set_capacity(block->gdp, dasd_state_basic_to_ready() 349 block->blocks << block->s2b_shift); dasd_state_basic_to_ready() 351 rc = dasd_scan_partitions(block); dasd_state_basic_to_ready() 368 if (device->block) _wait_for_empty_queues() 370 list_empty(&device->block->ccw_queue); _wait_for_empty_queues() 376 * Remove device from block device layer. Destroy dirty buffers. 385 if (device->block) { dasd_state_ready_to_basic() 386 struct dasd_block *block = device->block; dasd_state_ready_to_basic() local 387 rc = dasd_flush_block_queue(block); dasd_state_ready_to_basic() 392 dasd_flush_request_queue(block); dasd_state_ready_to_basic() 393 dasd_destroy_partitions(block); dasd_state_ready_to_basic() 394 block->blocks = 0; dasd_state_ready_to_basic() 395 block->bp_block = 0; dasd_state_ready_to_basic() 396 block->s2b_shift = 0; dasd_state_ready_to_basic() 423 if (device->block) { dasd_state_ready_to_online() 424 dasd_schedule_block_bh(device->block); dasd_state_ready_to_online() 426 disk = device->block->gdp; dasd_state_ready_to_online() 430 disk = device->block->bdev->bd_disk; dasd_state_ready_to_online() 456 if (device->block && !(device->features & DASD_FEATURE_USERAW)) { dasd_state_online_to_ready() 457 disk = device->block->bdev->bd_disk; dasd_state_online_to_ready() 688 static void dasd_profile_start(struct dasd_block *block, dasd_profile_start() argument 698 if (dasd_global_profile_level || block->profile.data) dasd_profile_start() 699 list_for_each(l, &block->ccw_queue) dasd_profile_start() 711 spin_lock(&block->profile.lock); dasd_profile_start() 712 if (block->profile.data) { dasd_profile_start() 713 block->profile.data->dasd_io_nr_req[counter]++; dasd_profile_start() 715 block->profile.data->dasd_read_nr_req[counter]++; dasd_profile_start() 717 spin_unlock(&block->profile.lock); dasd_profile_start() 798 static void dasd_profile_end(struct dasd_block *block, dasd_profile_end() argument 810 block->profile.data || dasd_profile_end() 837 cqr->startdev != block->base, dasd_profile_end() 847 spin_lock(&block->profile.lock); dasd_profile_end() 848 if (block->profile.data) dasd_profile_end() 849 dasd_profile_end_add_data(block->profile.data, dasd_profile_end() 850 cqr->startdev != block->base, dasd_profile_end() 857 spin_unlock(&block->profile.lock); dasd_profile_end() 862 cqr->startdev != block->base, dasd_profile_end() 1114 #define dasd_profile_start(block, cqr, req) do {} while (0) 1115 #define dasd_profile_end(block, cqr, req) do {} while (0) 1377 if (((cqr->block && dasd_start_IO() 1378 test_bit(DASD_FLAG_LOCK_STOLEN, &cqr->block->base->flags)) || dasd_start_IO() 1569 if (device->block) dasd_generic_handle_state_change() 1570 dasd_schedule_block_bh(device->block); dasd_generic_handle_state_change() 1740 if (!ref_cqr->block) __dasd_device_recovery() 1746 ref_cqr->block == cqr->block) { __dasd_device_recovery() 1788 struct dasd_block *block; __dasd_device_process_final_queue() local 1796 block = cqr->block; list_for_each_safe() 1799 if (block) list_for_each_safe() 1800 spin_lock_bh(&block->queue_lock); list_for_each_safe() 1821 if (block) list_for_each_safe() 1822 spin_unlock_bh(&block->queue_lock); list_for_each_safe() 1924 * device then all block layer requests must have been removed before 2396 if (device->block) dasd_sleep_on_immediatly() 2397 dasd_schedule_block_bh(device->block); dasd_sleep_on_immediatly() 2452 * Timeout function for dasd_block. This is used when the block layer 2459 struct dasd_block *block; dasd_block_timeout() local 2461 block = (struct dasd_block *) ptr; dasd_block_timeout() 2462 spin_lock_irqsave(get_ccwdev_lock(block->base->cdev), flags); dasd_block_timeout() 2464 dasd_device_remove_stop_bits(block->base, DASD_STOPPED_PENDING); dasd_block_timeout() 2465 spin_unlock_irqrestore(get_ccwdev_lock(block->base->cdev), flags); dasd_block_timeout() 2466 dasd_schedule_block_bh(block); dasd_block_timeout() 2472 void dasd_block_set_timer(struct dasd_block *block, int expires) dasd_block_set_timer() argument 2475 del_timer(&block->timer); dasd_block_set_timer() 2477 mod_timer(&block->timer, jiffies + expires); dasd_block_set_timer() 2484 void dasd_block_clear_timer(struct dasd_block *block) dasd_block_clear_timer() argument 2486 del_timer(&block->timer); dasd_block_clear_timer() 2507 * Fetch requests from the block device queue. 2509 static void __dasd_process_request_queue(struct dasd_block *block) __dasd_process_request_queue() argument 2516 queue = block->request_queue; __dasd_process_request_queue() 2517 basedev = block->base; __dasd_process_request_queue() 2523 * We requeue request from the block device queue to the ccw __dasd_process_request_queue() 2526 * for that. State DASD_STATE_ONLINE is normal block device __dasd_process_request_queue() 2530 while ((req = blk_fetch_request(block->request_queue))) __dasd_process_request_queue() 2560 cqr = basedev->discipline->build_cp(basedev, block, req); __dasd_process_request_queue() 2573 if (!list_empty(&block->ccw_queue)) __dasd_process_request_queue() 2581 dasd_block_set_timer(block, HZ/2); __dasd_process_request_queue() 2600 list_add_tail(&cqr->blocklist, &block->ccw_queue); __dasd_process_request_queue() 2602 dasd_profile_start(block, cqr, req); __dasd_process_request_queue() 2613 dasd_profile_end(cqr->block, cqr, req); __dasd_cleanup_cqr() 2614 status = cqr->block->base->discipline->free_cp(cqr, req); __dasd_cleanup_cqr() 2632 static void __dasd_process_block_ccw_queue(struct dasd_block *block, __dasd_process_block_ccw_queue() argument 2639 struct dasd_device *base = block->base; __dasd_process_block_ccw_queue() 2643 list_for_each_safe(l, n, &block->ccw_queue) { __dasd_process_block_ccw_queue() 2698 dasd_schedule_block_bh(cqr->block); dasd_return_cqr_cb() 2701 static void __dasd_block_start_head(struct dasd_block *block) __dasd_block_start_head() argument 2705 if (list_empty(&block->ccw_queue)) __dasd_block_start_head() 2711 list_for_each_entry(cqr, &block->ccw_queue, blocklist) { __dasd_block_start_head() 2714 if (test_bit(DASD_FLAG_LOCK_STOLEN, &block->base->flags) && __dasd_block_start_head() 2718 dasd_schedule_block_bh(block); __dasd_block_start_head() 2722 if (block->base->stopped & ~DASD_STOPPED_PENDING && __dasd_block_start_head() 2724 (!dasd_eer_enabled(block->base))) { __dasd_block_start_head() 2727 dasd_schedule_block_bh(block); __dasd_block_start_head() 2731 if (block->base->stopped) __dasd_block_start_head() 2736 cqr->startdev = block->base; __dasd_block_start_head() 2747 * block layer request queue, creates ccw requests, enqueues them on 2750 static void dasd_block_tasklet(struct dasd_block *block) dasd_block_tasklet() argument 2756 atomic_set(&block->tasklet_scheduled, 0); dasd_block_tasklet() 2758 spin_lock(&block->queue_lock); dasd_block_tasklet() 2760 __dasd_process_block_ccw_queue(block, &final_queue); dasd_block_tasklet() 2761 spin_unlock(&block->queue_lock); dasd_block_tasklet() 2763 spin_lock_irq(&block->request_queue_lock); dasd_block_tasklet() 2769 spin_lock(&block->queue_lock); dasd_block_tasklet() 2770 /* Get new request from the block device request queue */ dasd_block_tasklet() 2771 __dasd_process_request_queue(block); dasd_block_tasklet() 2773 __dasd_block_start_head(block); dasd_block_tasklet() 2774 spin_unlock(&block->queue_lock); dasd_block_tasklet() 2775 spin_unlock_irq(&block->request_queue_lock); dasd_block_tasklet() 2778 dasd_put_device(block->base); dasd_block_tasklet() 2787 * Requeue a request back to the block request queue 2788 * only works for block requests 2792 struct dasd_block *block = cqr->block; _dasd_requeue_request() local 2796 if (!block) _dasd_requeue_request() 2798 spin_lock_irqsave(&block->queue_lock, flags); _dasd_requeue_request() 2800 blk_requeue_request(block->request_queue, req); _dasd_requeue_request() 2801 spin_unlock_irqrestore(&block->queue_lock, flags); _dasd_requeue_request() 2809 * block layer. 2811 static int dasd_flush_block_queue(struct dasd_block *block) dasd_flush_block_queue() argument 2818 spin_lock_bh(&block->queue_lock); dasd_flush_block_queue() 2821 list_for_each_entry_safe(cqr, n, &block->ccw_queue, blocklist) { dasd_flush_block_queue() 2839 spin_unlock_bh(&block->queue_lock); dasd_flush_block_queue() 2846 spin_lock_bh(&block->queue_lock); dasd_flush_block_queue() 2847 __dasd_process_erp(block->base, cqr); dasd_flush_block_queue() 2848 spin_unlock_bh(&block->queue_lock); dasd_flush_block_queue() 2854 spin_lock_irq(&block->request_queue_lock); dasd_flush_block_queue() 2858 spin_unlock_irq(&block->request_queue_lock); dasd_flush_block_queue() 2866 void dasd_schedule_block_bh(struct dasd_block *block) dasd_schedule_block_bh() argument 2869 if (atomic_cmpxchg(&block->tasklet_scheduled, 0, 1) != 0) dasd_schedule_block_bh() 2871 /* life cycle of block is bound to it's base device */ dasd_schedule_block_bh() 2872 dasd_get_device(block->base); dasd_schedule_block_bh() 2873 tasklet_hi_schedule(&block->tasklet); dasd_schedule_block_bh() 2879 * SECTION: external block device operations 2888 struct dasd_block *block; do_dasd_request() local 2890 block = queue->queuedata; do_dasd_request() 2891 spin_lock(&block->queue_lock); do_dasd_request() 2892 /* Get new request from the block device request queue */ do_dasd_request() 2893 __dasd_process_request_queue(block); do_dasd_request() 2895 __dasd_block_start_head(block); do_dasd_request() 2896 spin_unlock(&block->queue_lock); do_dasd_request() 2900 * Block timeout callback, called from the block layer 2912 struct dasd_block *block = req->q->queuedata; dasd_times_out() local 2919 device = cqr->startdev ? cqr->startdev : block->base; dasd_times_out() 2926 spin_lock(&block->queue_lock); dasd_times_out() 2941 &block->ccw_queue, blocklist) { dasd_times_out() 2969 dasd_schedule_block_bh(block); dasd_times_out() 2970 spin_unlock(&block->queue_lock); dasd_times_out() 2978 static int dasd_alloc_queue(struct dasd_block *block) dasd_alloc_queue() argument 2980 block->request_queue = blk_init_queue(do_dasd_request, dasd_alloc_queue() 2981 &block->request_queue_lock); dasd_alloc_queue() 2982 if (block->request_queue == NULL) dasd_alloc_queue() 2985 block->request_queue->queuedata = block; dasd_alloc_queue() 2993 static void dasd_setup_queue(struct dasd_block *block) dasd_setup_queue() argument 2997 if (block->base->features & DASD_FEATURE_USERAW) { dasd_setup_queue() 3007 max = block->base->discipline->max_blocks << block->s2b_shift; dasd_setup_queue() 3009 blk_queue_logical_block_size(block->request_queue, dasd_setup_queue() 3010 block->bp_block); dasd_setup_queue() 3011 blk_queue_max_hw_sectors(block->request_queue, max); dasd_setup_queue() 3012 blk_queue_max_segments(block->request_queue, -1L); dasd_setup_queue() 3016 blk_queue_max_segment_size(block->request_queue, PAGE_SIZE); dasd_setup_queue() 3017 blk_queue_segment_boundary(block->request_queue, PAGE_SIZE - 1); dasd_setup_queue() 3023 static void dasd_free_queue(struct dasd_block *block) dasd_free_queue() argument 3025 if (block->request_queue) { dasd_free_queue() 3026 blk_cleanup_queue(block->request_queue); dasd_free_queue() 3027 block->request_queue = NULL; dasd_free_queue() 3034 static void dasd_flush_request_queue(struct dasd_block *block) dasd_flush_request_queue() argument 3038 if (!block->request_queue) dasd_flush_request_queue() 3041 spin_lock_irq(&block->request_queue_lock); dasd_flush_request_queue() 3042 while ((req = blk_fetch_request(block->request_queue))) dasd_flush_request_queue() 3044 spin_unlock_irq(&block->request_queue_lock); dasd_flush_request_queue() 3056 atomic_inc(&base->block->open_count); dasd_open() 3095 atomic_dec(&base->block->open_count); dasd_open() 3104 atomic_dec(&base->block->open_count); dasd_release() 3126 base->discipline->fill_geometry(base->block, geo); dasd_getgeo() 3127 geo->start = get_start_sect(bdev) >> base->block->s2b_shift; dasd_getgeo() 3143 * end of block device operations 3246 struct dasd_block *block; dasd_generic_remove() local 3269 block = device->block; dasd_generic_remove() 3272 * life cycle of block is bound to device, so delete it after dasd_generic_remove() 3275 if (block) dasd_generic_remove() 3276 dasd_free_block(block); dasd_generic_remove() 3322 /* check_device will allocate block device if necessary */ dasd_generic_set_online() 3339 if (device->block) dasd_generic_set_online() 3340 dasd_free_block(device->block); dasd_generic_set_online() 3356 struct dasd_block *block; dasd_generic_set_offline() local 3370 if (device->block) { dasd_generic_set_offline() 3371 max_count = device->block->bdev ? 0 : -1; dasd_generic_set_offline() 3372 open_count = atomic_read(&device->block->open_count); dasd_generic_set_offline() 3420 rc = fsync_bdev(device->block->bdev); dasd_generic_set_offline() 3435 block = device->block; dasd_generic_set_offline() 3438 * life cycle of block is bound to device, so delete it after dasd_generic_set_offline() 3441 if (block) dasd_generic_set_offline() 3442 dasd_free_block(block); dasd_generic_set_offline() 3493 if (device->block) dasd_generic_path_operational() 3494 dasd_schedule_block_bh(device->block); dasd_generic_path_operational() 3619 /* clear active requests and requeue them to block layer if possible */ dasd_generic_pm_freeze() 3648 block device requests */ dasd_generic_pm_freeze() 3652 /* remove requests from device and block queue */ dasd_generic_pm_freeze() 3656 /* remove the request from the block queue */ dasd_generic_pm_freeze() 3662 if (cqr->block) dasd_generic_pm_freeze() 3664 cqr->block->base->discipline->free_cp( dasd_generic_pm_freeze() 3710 if (device->block) dasd_generic_restore_device() 3711 dasd_schedule_block_bh(device->block); dasd_generic_restore_device() 3820 if (device->block) dasd_generic_shutdown() 3821 dasd_schedule_block_bh(device->block); dasd_generic_shutdown()
|
H A D | Makefile | 2 # S/390 block devices
|
H A D | dasd_fba.c | 128 struct dasd_block *block; dasd_fba_check_characteristics() local 147 block = dasd_alloc_block(); dasd_fba_check_characteristics() 148 if (IS_ERR(block)) { dasd_fba_check_characteristics() 150 "dasd block structure"); dasd_fba_check_characteristics() 153 return PTR_ERR(block); dasd_fba_check_characteristics() 155 device->block = block; dasd_fba_check_characteristics() 156 block->base = device; dasd_fba_check_characteristics() 164 device->block = NULL; dasd_fba_check_characteristics() 165 dasd_free_block(block); dasd_fba_check_characteristics() 193 static int dasd_fba_do_analysis(struct dasd_block *block) dasd_fba_do_analysis() argument 198 private = (struct dasd_fba_private *) block->base->private; dasd_fba_do_analysis() 201 DBF_DEV_EVENT(DBF_WARNING, block->base, "unknown blocksize %d", dasd_fba_do_analysis() 205 block->blocks = private->rdc_data.blk_bdsa; dasd_fba_do_analysis() 206 block->bp_block = private->rdc_data.blk_size; dasd_fba_do_analysis() 207 block->s2b_shift = 0; /* bits to shift 512 to get a block */ dasd_fba_do_analysis() 209 block->s2b_shift++; dasd_fba_do_analysis() 213 static int dasd_fba_fill_geometry(struct dasd_block *block, dasd_fba_fill_geometry() argument 216 if (dasd_check_blocksize(block->bp_block) != 0) dasd_fba_fill_geometry() 218 geo->cylinders = (block->blocks << block->s2b_shift) >> 10; dasd_fba_fill_geometry() 220 geo->sectors = 128 >> block->s2b_shift; dasd_fba_fill_geometry() 254 struct dasd_block *block, dasd_fba_build_cp() 270 private = (struct dasd_fba_private *) block->base->private; dasd_fba_build_cp() 277 blksize = block->bp_block; dasd_fba_build_cp() 278 /* Calculate record id of first and last block. */ dasd_fba_build_cp() 279 first_rec = blk_rq_pos(req) >> block->s2b_shift; dasd_fba_build_cp() 281 (blk_rq_pos(req) + blk_rq_sectors(req) - 1) >> block->s2b_shift; dasd_fba_build_cp() 289 count += bv.bv_len >> (block->s2b_shift + 9); rq_for_each_segment() 316 block->bp_block, blk_rq_pos(req), blk_rq_sectors(req)); 352 ccw->count = block->bp_block; rq_for_each_segment() 367 block->base->features & DASD_FEATURE_FAILFAST) 371 cqr->block = block; 392 private = (struct dasd_fba_private *) cqr->block->base->private; dasd_fba_free_cp() 393 blksize = cqr->block->bp_block; dasd_fba_free_cp() 581 * 24 bytes, the struct dasd_ccw_req has 136 bytes and each block can use 584 * locate record ccw for each block (stupid devices!) + 16 bytes of data. 253 dasd_fba_build_cp(struct dasd_device * memdev, struct dasd_block *block, struct request *req) dasd_fba_build_cp() argument
|
/linux-4.1.27/fs/squashfs/ |
H A D | file_cache.c | 23 int squashfs_readpage_block(struct page *page, u64 block, int bsize) squashfs_readpage_block() argument 27 block, bsize); squashfs_readpage_block() 31 ERROR("Unable to read page, block %llx, size %x\n", block, squashfs_readpage_block()
|
H A D | namei.c | 30 * decompressed block (<block, offset>). 35 * compressed metadata block, and therefore, can share the start block. 37 * header containing the shared start block value, and a sequence of directory 38 * entries, each of which share the shared start block. A new directory header 39 * is written once/if the inode start block changes. The directory 45 * in each metadata block. Directories are sorted in alphabetical order, 48 * location of the metadata block the filename is in has been found. 49 * The general idea of the index is ensure only one metadata block needs to be 70 * block containing it, and the directory index this represents. 130 * Return index (f_pos) of the looked up metadata block. Translate get_dir_index_using_name() 148 u64 block = squashfs_i(dir)->start + msblk->directory_table; squashfs_lookup() local 153 TRACE("Entered squashfs_lookup [%llx:%x]\n", block, offset); squashfs_lookup() 166 length = get_dir_index_using_name(dir->i_sb, &block, &offset, squashfs_lookup() 175 err = squashfs_read_metadata(dir->i_sb, &dirh, &block, squashfs_lookup() 191 err = squashfs_read_metadata(dir->i_sb, dire, &block, squashfs_lookup() 203 &block, &offset, size); squashfs_lookup() 239 ERROR("Unable to read directory block [%llx:%x]\n", squashfs_lookup()
|
H A D | inode.c | 28 * location of the compressed metadata block containing the inode, and the byte 29 * offset into that block where the inode is placed (<block, offset>). 116 u64 block = SQUASHFS_INODE_BLK(ino) + msblk->inode_table; squashfs_read_inode() local 127 err = squashfs_read_metadata(sb, sqshb_ino, &block, squashfs_read_inode() 136 block = SQUASHFS_INODE_BLK(ino) + msblk->inode_table; squashfs_read_inode() 147 err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset, squashfs_read_inode() 175 squashfs_i(inode)->block_list_start = block; squashfs_read_inode() 181 offset, squashfs_i(inode)->start, block, offset); squashfs_read_inode() 190 err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset, squashfs_read_inode() 222 squashfs_i(inode)->block_list_start = block; squashfs_read_inode() 228 offset, squashfs_i(inode)->start, block, offset); squashfs_read_inode() 234 err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset, squashfs_read_inode() 258 err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset, squashfs_read_inode() 271 squashfs_i(inode)->dir_idx_start = block; squashfs_read_inode() 286 err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset, squashfs_read_inode() 296 squashfs_i(inode)->start = block; squashfs_read_inode() 302 err = squashfs_read_metadata(sb, NULL, &block, squashfs_read_inode() 306 err = squashfs_read_metadata(sb, &xattr, &block, squashfs_read_inode() 315 block, offset); squashfs_read_inode() 323 err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset, squashfs_read_inode() 345 err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset, squashfs_read_inode() 368 err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset, squashfs_read_inode() 385 err = squashfs_read_metadata(sb, sqsh_ino, &block, &offset, squashfs_read_inode()
|
H A D | file.c | 27 * compressed fragment block (tail-end packed block). The compressed size 28 * of each datablock is stored in a block list contained within the 33 * block index to datablock location on disk. 36 * retaining a simple and space-efficient block list on disk. The cache 170 * Read the next n blocks from the block list, starting from 171 * metadata block <start_block, offset>. 177 long long block = 0; read_indexes() local 191 ERROR("read_indexes: reading block [%llx:%x]\n", read_indexes() 198 block += SQUASHFS_COMPRESSED_SIZE_BLOCK(size); read_indexes() 204 return block; read_indexes() 214 * can cache one index -> datablock/blocklist-block mapping. We wish 233 * on-disk locations of the datablock and block list metadata block 278 * If necessary grow cache slot by reading block list. Cache fill_meta_index() 335 static int read_blocklist(struct inode *inode, int index, u64 *block) read_blocklist() argument 341 int res = fill_meta_index(inode, index, &start, &offset, block); read_blocklist() 344 " 0x%x, block 0x%llx\n", res, index, start, offset, read_blocklist() 345 *block); read_blocklist() 354 * extra block indexes needed. read_blocklist() 360 *block += blks; read_blocklist() 364 * Read length of block specified by index. read_blocklist() 385 * many PAGE_CACHE_SIZE pages (default block size is 128 KiB) explicitly squashfs_copy_cache() 418 /* Read datablock stored packed inside a fragment (tail-end packed block) */ squashfs_readpage_fragment() 429 ERROR("Unable to read page, block %llx, size %x\n", squashfs_readpage_fragment() 462 TRACE("Entered squashfs_readpage, page index %lx, start block %llx\n", squashfs_readpage() 471 u64 block = 0; squashfs_readpage() local 472 int bsize = read_blocklist(inode, index, &block); squashfs_readpage() 479 res = squashfs_readpage_block(page, block, bsize); squashfs_readpage()
|
H A D | block.c | 21 * block.c 42 * Read the metadata block length, this is stored in the first two 43 * bytes of the metadata block. 82 * Read and decompress a metadata block or datablock. Length is non-zero 85 * the metadata block. A bit in the length field indicates if the block 87 * generated a larger block - this does occasionally happen with compression 130 * Metadata block. squashfs_read_data() 210 ERROR("squashfs_read_data failed to read block 0x%llx\n", squashfs_read_data()
|
H A D | file_direct.c | 23 static int squashfs_read_cache(struct page *target_page, u64 block, int bsize, 27 int squashfs_readpage_block(struct page *target_page, u64 block, int bsize) squashfs_readpage_block() argument 59 /* Try to grab all the pages covered by the Squashfs block */ squashfs_readpage_block() 85 res = squashfs_read_cache(target_page, block, bsize, pages, squashfs_readpage_block() 94 res = squashfs_read_data(inode->i_sb, block, bsize, NULL, actor); squashfs_readpage_block() 140 static int squashfs_read_cache(struct page *target_page, u64 block, int bsize, squashfs_read_cache() argument 145 block, bsize); squashfs_read_cache() 150 ERROR("Unable to read page, block %llx, size %x\n", block, squashfs_read_cache()
|
H A D | symlink.c | 52 u64 block = squashfs_i(inode)->start; squashfs_symlink_readpage() local 59 TRACE("Entered squashfs_symlink_readpage, page index %ld, start block " squashfs_symlink_readpage() 60 "%llx, offset %x\n", page->index, block, offset); squashfs_symlink_readpage() 66 bytes = squashfs_read_metadata(sb, NULL, &block, &offset, squashfs_symlink_readpage() 84 entry = squashfs_cache_get(sb, msblk->block_cache, block, 0); squashfs_symlink_readpage() 99 block = entry->next_index; squashfs_symlink_readpage()
|
H A D | cache.c | 62 * Look-up block in cache, and increment usage count. If not in cache, read 66 struct squashfs_cache *cache, u64 block, int length) squashfs_cache_get() 75 if (cache->entry[i].block == block) { squashfs_cache_get() 116 entry->block = block; squashfs_cache_get() 123 entry->length = squashfs_read_data(sb, block, length, squashfs_cache_get() 173 TRACE("Got %s %d, start block %lld, refcount %d, error %d\n", squashfs_cache_get() 174 cache->name, i, entry->block, entry->refcount, entry->error); squashfs_cache_get() 178 block); squashfs_cache_get() 195 * If there's any processes waiting for a block to become squashfs_cache_put() 270 entry->block = SQUASHFS_INVALID_BLK; squashfs_cache_init() 339 * Read length bytes from metadata position <block, offset> (block is the 340 * start of the compressed block on disk, and offset is the offset into 341 * the block once decompressed). Data is packed into consecutive blocks, 342 * and length bytes may require reading more than one block. 345 u64 *block, int *offset, int length) squashfs_read_metadata() 351 TRACE("Entered squashfs_read_metadata [%llx:%x]\n", *block, *offset); squashfs_read_metadata() 354 entry = squashfs_cache_get(sb, msblk->block_cache, *block, 0); squashfs_read_metadata() 370 *block = entry->next_index; squashfs_read_metadata() 416 void *squashfs_read_table(struct super_block *sb, u64 block, int length) squashfs_read_table() argument 442 res = squashfs_read_data(sb, block, length | squashfs_read_table() 65 squashfs_cache_get(struct super_block *sb, struct squashfs_cache *cache, u64 block, int length) squashfs_cache_get() argument 344 squashfs_read_metadata(struct super_block *sb, void *buffer, u64 *block, int *offset, int length) squashfs_read_metadata() argument
|
/linux-4.1.27/include/crypto/ |
H A D | md5.h | 13 u32 block[MD5_BLOCK_WORDS]; member in struct:md5_state
|
/linux-4.1.27/drivers/video/fbdev/core/ |
H A D | fbmon.c | 96 static int edid_is_serial_block(unsigned char *block) edid_is_serial_block() argument 98 if ((block[0] == 0x00) && (block[1] == 0x00) && edid_is_serial_block() 99 (block[2] == 0x00) && (block[3] == 0xff) && edid_is_serial_block() 100 (block[4] == 0x00)) edid_is_serial_block() 106 static int edid_is_ascii_block(unsigned char *block) edid_is_ascii_block() argument 108 if ((block[0] == 0x00) && (block[1] == 0x00) && edid_is_ascii_block() 109 (block[2] == 0x00) && (block[3] == 0xfe) && edid_is_ascii_block() 110 (block[4] == 0x00)) edid_is_ascii_block() 116 static int edid_is_limits_block(unsigned char *block) edid_is_limits_block() argument 118 if ((block[0] == 0x00) && (block[1] == 0x00) && edid_is_limits_block() 119 (block[2] == 0x00) && (block[3] == 0xfd) && edid_is_limits_block() 120 (block[4] == 0x00)) edid_is_limits_block() 126 static int edid_is_monitor_block(unsigned char *block) edid_is_monitor_block() argument 128 if ((block[0] == 0x00) && (block[1] == 0x00) && edid_is_monitor_block() 129 (block[2] == 0x00) && (block[3] == 0xfc) && edid_is_monitor_block() 130 (block[4] == 0x00)) edid_is_monitor_block() 136 static int edid_is_timing_block(unsigned char *block) edid_is_timing_block() argument 138 if ((block[0] != 0x00) || (block[1] != 0x00) || edid_is_timing_block() 139 (block[2] != 0x00) || (block[4] != 0x00)) edid_is_timing_block() 147 unsigned char *block = edid + ID_MANUFACTURER_NAME, manufacturer[4]; check_edid() local 152 manufacturer[0] = ((block[0] & 0x7c) >> 2) + '@'; check_edid() 153 manufacturer[1] = ((block[0] & 0x03) << 3) + check_edid() 154 ((block[1] & 0xe0) >> 5) + '@'; check_edid() 155 manufacturer[2] = (block[1] & 0x1f) + '@'; check_edid() 157 model = block[2] + (block[3] << 8); check_edid() 292 static void parse_vendor_block(unsigned char *block, struct fb_monspecs *specs) parse_vendor_block() argument 294 specs->manufacturer[0] = ((block[0] & 0x7c) >> 2) + '@'; parse_vendor_block() 295 specs->manufacturer[1] = ((block[0] & 0x03) << 3) + parse_vendor_block() 296 ((block[1] & 0xe0) >> 5) + '@'; parse_vendor_block() 297 specs->manufacturer[2] = (block[1] & 0x1f) + '@'; parse_vendor_block() 299 specs->model = block[2] + (block[3] << 8); parse_vendor_block() 300 specs->serial = block[4] + (block[5] << 8) + parse_vendor_block() 301 (block[6] << 16) + (block[7] << 24); parse_vendor_block() 302 specs->year = block[9] + 1990; parse_vendor_block() 303 specs->week = block[8]; parse_vendor_block() 326 static void get_chroma(unsigned char *block, struct fb_monspecs *specs) get_chroma() argument 332 tmp = ((block[5] & (3 << 6)) >> 6) | (block[0x7] << 2); get_chroma() 338 tmp = ((block[5] & (3 << 4)) >> 4) | (block[0x8] << 2); get_chroma() 344 tmp = ((block[5] & (3 << 2)) >> 2) | (block[0x9] << 2); get_chroma() 350 tmp = (block[5] & 3) | (block[0xa] << 2); get_chroma() 356 tmp = ((block[6] & (3 << 6)) >> 6) | (block[0xb] << 2); get_chroma() 362 tmp = ((block[6] & (3 << 4)) >> 4) | (block[0xc] << 2); get_chroma() 368 tmp = ((block[6] & (3 << 2)) >> 2) | (block[0xd] << 2); get_chroma() 374 tmp = (block[6] & 3) | (block[0xe] << 2); get_chroma() 409 static int get_est_timing(unsigned char *block, struct fb_videomode *mode) get_est_timing() argument 414 c = block[0]; get_est_timing() 451 c = block[1]; get_est_timing() 485 c = block[2]; get_est_timing() 494 static int get_std_timing(unsigned char *block, struct fb_videomode *mode, get_std_timing() argument 500 u32 std_2byte_code = block[0] << 8 | block[1]; get_std_timing() 514 xres = (block[0] + 31) * 8; get_std_timing() 518 ratio = (block[1] & 0xc0) >> 6; get_std_timing() 537 refresh = (block[1] & 0x3f) + 60; get_std_timing() 553 static int get_dst_timing(unsigned char *block, struct fb_videomode *mode, get_dst_timing() argument 558 for (j = 0; j < 6; j++, block += STD_TIMING_DESCRIPTION_SIZE) get_dst_timing() 559 num += get_std_timing(block, &mode[num], ver, rev, specs); get_dst_timing() 564 static void get_detailed_timing(unsigned char *block, get_detailed_timing() argument 619 unsigned char *block; fb_create_modedb() local 639 block = edid + DETAILED_TIMING_DESCRIPTIONS_START; fb_create_modedb() 640 for (i = 0; i < 4; i++, block+= DETAILED_TIMING_DESCRIPTION_SIZE) { fb_create_modedb() 641 if (!(block[0] == 0x00 && block[1] == 0x00)) { fb_create_modedb() 642 get_detailed_timing(block, &mode[num]); fb_create_modedb() 652 block = edid + ESTABLISHED_TIMING_1; fb_create_modedb() 653 num += get_est_timing(block, &mode[num]); fb_create_modedb() 656 block = edid + STD_TIMING_DESCRIPTIONS_START; fb_create_modedb() 657 for (i = 0; i < STD_TIMING; i++, block += STD_TIMING_DESCRIPTION_SIZE) fb_create_modedb() 658 num += get_std_timing(block, &mode[num], ver, rev, specs); fb_create_modedb() 660 block = edid + DETAILED_TIMING_DESCRIPTIONS_START; fb_create_modedb() 661 for (i = 0; i < 4; i++, block+= DETAILED_TIMING_DESCRIPTION_SIZE) { fb_create_modedb() 662 if (block[0] == 0x00 && block[1] == 0x00 && block[3] == 0xfa) fb_create_modedb() 663 num += get_dst_timing(block + 5, &mode[num], fb_create_modedb() 697 unsigned char *block; fb_get_monitor_limits() local 699 block = edid + DETAILED_TIMING_DESCRIPTIONS_START; fb_get_monitor_limits() 703 for (i = 0; i < 4; i++, block += DETAILED_TIMING_DESCRIPTION_SIZE) { fb_get_monitor_limits() 704 if (edid_is_limits_block(block)) { fb_get_monitor_limits() 777 unsigned char c, *block; get_monspecs() local 779 block = edid + EDID_STRUCT_DISPLAY; get_monspecs() 783 c = block[0] & 0x80; get_monspecs() 790 switch ((block[0] & 0x60) >> 5) { get_monspecs() 810 c = block[0] & 0x10; get_monspecs() 813 c = block[0] & 0x0f; get_monspecs() 836 specs->max_x = block[1]; get_monspecs() 837 specs->max_y = block[2]; get_monspecs() 849 c = block[3]; get_monspecs() 854 get_dpms_capabilities(block[4], specs); get_monspecs() 856 switch ((block[4] & 0x18) >> 3) { get_monspecs() 875 get_chroma(block, specs); get_monspecs() 878 c = block[4] & 0x7; get_monspecs() 896 unsigned char *block; fb_parse_edid() local 907 block = edid + DETAILED_TIMING_DESCRIPTIONS_START; fb_parse_edid() 909 for (i = 0; i < 4; i++, block += DETAILED_TIMING_DESCRIPTION_SIZE) { fb_parse_edid() 910 if (edid_is_timing_block(block)) { fb_parse_edid() 938 unsigned char *block; fb_edid_to_monspecs() local 963 block = edid + DETAILED_TIMING_DESCRIPTIONS_START; fb_edid_to_monspecs() 964 for (i = 0; i < 4; i++, block += DETAILED_TIMING_DESCRIPTION_SIZE) { fb_edid_to_monspecs() 965 if (edid_is_serial_block(block)) { fb_edid_to_monspecs() 966 copy_string(block, specs->serial_no); fb_edid_to_monspecs() 968 } else if (edid_is_ascii_block(block)) { fb_edid_to_monspecs() 969 copy_string(block, specs->ascii); fb_edid_to_monspecs() 971 } else if (edid_is_monitor_block(block)) { fb_edid_to_monspecs() 972 copy_string(block, specs->monitor); fb_edid_to_monspecs() 1002 * @edid: 128 byte array with an E-EDID block 1007 unsigned char *block; fb_edid_add_monspecs() local 1027 pr_debug("Data block %u of %u bytes\n", type, len); fb_edid_add_monspecs() 1045 block = edid + edid[2]; fb_edid_add_monspecs() 1050 i++, block += DETAILED_TIMING_DESCRIPTION_SIZE) fb_edid_add_monspecs() 1052 edt[num++] = block - edid; fb_edid_add_monspecs() 1578 * We need to ensure that the EDID block is only returned for
|
H A D | fb_notify.c | 21 * @nb: notifier block to callback on events 31 * @nb: notifier block to callback on events
|
/linux-4.1.27/sound/soc/intel/common/ |
H A D | sst-firmware.c | 118 struct sst_mem_block *block, *tmp; block_list_remove() local 121 /* disable each block */ list_for_each_entry() 122 list_for_each_entry(block, block_list, module_list) { list_for_each_entry() 124 if (block->ops && block->ops->disable) { list_for_each_entry() 125 err = block->ops->disable(block); list_for_each_entry() 128 "error: cant disable block %d:%d\n", list_for_each_entry() 129 block->type, block->index); list_for_each_entry() 133 /* mark each block as free */ list_for_each_entry_safe() 134 list_for_each_entry_safe(block, tmp, block_list, module_list) { list_for_each_entry_safe() 135 list_del(&block->module_list); list_for_each_entry_safe() 136 list_move(&block->list, &dsp->free_block_list); list_for_each_entry_safe() 137 dev_dbg(dsp->dev, "block freed %d:%d at offset 0x%x\n", list_for_each_entry_safe() 138 block->type, block->index, block->offset); list_for_each_entry_safe() 142 /* prepare the memory block to receive data from host - callers hold locks */ block_list_prepare() 146 struct sst_mem_block *block; block_list_prepare() local 149 /* enable each block so that's it'e ready for data */ list_for_each_entry() 150 list_for_each_entry(block, block_list, module_list) { list_for_each_entry() 152 if (block->ops && block->ops->enable && !block->users) { list_for_each_entry() 153 ret = block->ops->enable(block); list_for_each_entry() 156 "error: cant disable block %d:%d\n", list_for_each_entry() 157 block->type, block->index); list_for_each_entry() 165 list_for_each_entry(block, block_list, module_list) { list_for_each_entry() 166 if (block->ops && block->ops->disable) list_for_each_entry() 167 block->ops->disable(block); list_for_each_entry() 564 struct sst_mem_block *block; find_block() local 566 list_for_each_entry(block, &dsp->free_block_list, list) { find_block() 567 if (block->type == ba->type && block->offset == ba->offset) find_block() 568 return block; find_block() 574 /* Block allocator must be on block boundary */ block_alloc_contiguous() 579 struct sst_mem_block *block; block_alloc_contiguous() local 585 block = find_block(dsp, ba); block_alloc_contiguous() 586 if (!block) { block_alloc_contiguous() 594 list_move_tail(&block->list, &tmp); block_alloc_contiguous() 595 ba->offset += block->size; block_alloc_contiguous() 596 ba->size -= block->size; block_alloc_contiguous() 601 list_for_each_entry(block, &tmp, list) { block_alloc_contiguous() 603 if (block->offset < block_start) block_alloc_contiguous() 604 block_start = block->offset; block_alloc_contiguous() 606 list_add(&block->module_list, block_list); block_alloc_contiguous() 608 dev_dbg(dsp->dev, "block allocated %d:%d at offset 0x%x\n", block_alloc_contiguous() 609 block->type, block->index, block->offset); block_alloc_contiguous() 620 struct sst_mem_block *block, *tmp; block_alloc() local 627 list_for_each_entry_safe(block, tmp, &dsp->free_block_list, list) { block_alloc() 630 if (block->type != ba->type) block_alloc() 633 if (ba->size > block->size) block_alloc() 636 ba->offset = block->offset; block_alloc() 637 block->bytes_used = ba->size % block->size; block_alloc() 638 list_add(&block->module_list, block_list); block_alloc() 639 list_move(&block->list, &dsp->used_block_list); block_alloc() 640 dev_dbg(dsp->dev, "block allocated %d:%d at offset 0x%x\n", block_alloc() 641 block->type, block->index, block->offset); block_alloc() 646 list_for_each_entry_safe(block, tmp, &dsp->free_block_list, list) { block_alloc() 649 if (block->type != ba->type) block_alloc() 653 if (ba->size > block->size) { block_alloc() 655 /* align ba to block boundary */ block_alloc() 656 ba->offset = block->offset; block_alloc() 665 /* not enough free block space */ block_alloc() 674 dev_dbg(dsp->dev, "block request 0x%x bytes at offset 0x%x type %d\n", sst_alloc_blocks() 709 struct sst_mem_block *block, *tmp; block_alloc_fixed() local 719 list_for_each_entry_safe(block, tmp, block_list, module_list) { list_for_each_entry_safe() 722 if (block->type != ba->type) list_for_each_entry_safe() 725 block_end = block->offset + block->size; list_for_each_entry_safe() 727 /* find block that holds section */ list_for_each_entry_safe() 728 if (ba->offset >= block->offset && end <= block_end) list_for_each_entry_safe() 731 /* does block span more than 1 section */ list_for_each_entry_safe() 732 if (ba->offset >= block->offset && ba->offset < block_end) { list_for_each_entry_safe() 734 /* align ba to block boundary */ list_for_each_entry_safe() 747 list_for_each_entry_safe(block, tmp, &dsp->free_block_list, list) { 748 block_end = block->offset + block->size; 751 if (block->type != ba->type) 754 /* find block that holds section */ 755 if (ba->offset >= block->offset && end <= block_end) { 757 /* add block */ 758 list_move(&block->list, &dsp->used_block_list); 759 list_add(&block->module_list, block_list); 760 dev_dbg(dsp->dev, "block allocated %d:%d at offset 0x%x\n", 761 block->type, block->index, block->offset); 765 /* does block span more than 1 section */ 766 if (ba->offset >= block->offset && ba->offset < block_end) { 768 /* add block */ 769 list_move(&block->list, &dsp->used_block_list); 770 list_add(&block->module_list, block_list); 771 /* align ba to block boundary */ 799 dev_dbg(dsp->dev, "block request 0x%x bytes at offset 0x%x type %d\n", sst_module_alloc_blocks() 879 dev_dbg(dsp->dev, "persistent fixed block request 0x%x bytes type %d offset 0x%x\n", sst_module_runtime_alloc_blocks() 886 dev_dbg(dsp->dev, "persistent block request 0x%x bytes type %d\n", sst_module_runtime_alloc_blocks() 904 dev_err(dsp->dev, "error: runtime block prepare failed\n"); sst_module_runtime_alloc_blocks() 1021 /* register a DSP memory block for use with FW based modules */ sst_mem_block_register() 1026 struct sst_mem_block *block; sst_mem_block_register() local 1028 block = kzalloc(sizeof(*block), GFP_KERNEL); sst_mem_block_register() 1029 if (block == NULL) sst_mem_block_register() 1032 block->offset = offset; sst_mem_block_register() 1033 block->size = size; sst_mem_block_register() 1034 block->index = index; sst_mem_block_register() 1035 block->type = type; sst_mem_block_register() 1036 block->dsp = dsp; sst_mem_block_register() 1037 block->private = private; sst_mem_block_register() 1038 block->ops = ops; sst_mem_block_register() 1041 list_add(&block->list, &dsp->free_block_list); sst_mem_block_register() 1044 return block; sst_mem_block_register() 1051 struct sst_mem_block *block, *tmp; sst_mem_block_unregister_all() local 1056 list_for_each_entry_safe(block, tmp, &dsp->used_block_list, list) { sst_mem_block_unregister_all() 1057 list_del(&block->list); sst_mem_block_unregister_all() 1058 kfree(block); sst_mem_block_unregister_all() 1062 list_for_each_entry_safe(block, tmp, &dsp->free_block_list, list) { sst_mem_block_unregister_all() 1063 list_del(&block->list); sst_mem_block_unregister_all() 1064 kfree(block); sst_mem_block_unregister_all() 1107 dev_dbg(dsp->dev, "block request 0x%x bytes type %d at 0x%x\n", sst_block_alloc_scratch() 1116 dev_dbg(dsp->dev, "block request 0x%x bytes type %d\n", sst_block_alloc_scratch() 1130 dev_err(dsp->dev, "error: scratch block prepare failed\n"); sst_block_alloc_scratch() 1190 /* returns block address in DSP address space */ sst_dsp_get_offset()
|
/linux-4.1.27/fs/sysv/ |
H A D | balloc.c | 40 /* NOTE NOTE NOTE: nr is a block number _as_ _stored_ _on_ _disk_ */ 48 unsigned block = fs32_to_cpu(sbi, nr); sysv_free_block() local 58 if (block < sbi->s_firstdatazone || block >= sbi->s_nzones) { sysv_free_block() 59 printk("sysv_free_block: trying to free block not in datazone\n"); sysv_free_block() 71 /* If the free list head in super-block is full, it is copied sysv_free_block() 72 * into this block being freed, ditto if it's completely empty sysv_free_block() 76 block += sbi->s_block_base; sysv_free_block() 77 bh = sb_getblk(sb, block); sysv_free_block() 102 unsigned int block; sysv_new_block() local 116 block = fs32_to_cpu(sbi, nr); sysv_new_block() 120 if (block < sbi->s_firstdatazone || block >= sbi->s_nzones) { sysv_new_block() 121 printk("sysv_new_block: new block %d is not in data zone\n", sysv_new_block() 122 block); sysv_new_block() 126 if (count == 0) { /* the last block continues the free list */ sysv_new_block() 129 block += sbi->s_block_base; sysv_new_block() 130 if (!(bh = sb_bread(sb, block))) { sysv_new_block() 131 printk("sysv_new_block: cannot read free-list block\n"); sysv_new_block() 132 /* retry this same block next time */ sysv_new_block() 138 printk("sysv_new_block: free-list block with >flc_size entries\n"); sysv_new_block() 165 unsigned block; sysv_count_free_blocks() local 171 * lie and say it has no free block at all. sysv_count_free_blocks() 196 block = fs32_to_cpu(sbi, zone); sysv_count_free_blocks() 200 if (block < sbi->s_firstdatazone || block >= sbi->s_nzones) sysv_count_free_blocks() 202 block += sbi->s_block_base; sysv_count_free_blocks() 203 bh = sb_bread(sb, block); sysv_count_free_blocks() 218 printk("sysv_count_free_blocks: new block %d is not in data zone\n", sysv_count_free_blocks() 219 block); sysv_count_free_blocks() 222 printk("sysv_count_free_blocks: cannot read free-list block\n"); sysv_count_free_blocks() 225 printk("sysv_count_free_blocks: >flc_size entries in free-list block\n"); sysv_count_free_blocks() 232 printk("sysv_count_free_blocks: free block count was %d, " sysv_count_free_blocks()
|
H A D | itree.c | 22 static int block_to_path(struct inode *inode, long block, int offsets[DEPTH]) block_to_path() argument 31 if (block < 0) { block_to_path() 32 printk("sysv_block_map: block < 0\n"); block_to_path() 33 } else if (block < DIRECT) { block_to_path() 34 offsets[n++] = block; block_to_path() 35 } else if ( (block -= DIRECT) < indirect_blocks) { block_to_path() 37 offsets[n++] = block; block_to_path() 38 } else if ((block -= indirect_blocks) < double_blocks) { block_to_path() 40 offsets[n++] = block >> ptrs_bits; block_to_path() 41 offsets[n++] = block & (indirect_blocks - 1); block_to_path() 42 } else if (((block -= double_blocks) >> (ptrs_bits * 2)) < indirect_blocks) { block_to_path() 44 offsets[n++] = block >> (ptrs_bits * 2); block_to_path() 45 offsets[n++] = (block >> ptrs_bits) & (indirect_blocks - 1); block_to_path() 46 offsets[n++] = block & (indirect_blocks - 1); block_to_path() 102 int block = block_to_cpu(SYSV_SB(sb), p->key); get_branch() local 103 bh = sb_bread(sb, block); get_branch() 137 /* Allocate the next block */ alloc_branch() 142 * Get buffer_head for parent block, zero it out and set alloc_branch() 183 /* had we spliced it onto indirect block? */ splice_branch() 220 /* Simplest case - block found, no allocation needed */ get_block() 230 /* Next simple case - plain lookup or failed read of indirect block */ get_block() 242 * Indirect block might be removed by truncate while we were get_block() 304 * OK, we've found the last block that must survive. The rest of our find_shared() 344 int block; free_branches() local 349 block = block_to_cpu(SYSV_SB(sb), nr); free_branches() 350 bh = sb_bread(sb, block); free_branches() 490 static sector_t sysv_bmap(struct address_space *mapping, sector_t block) sysv_bmap() argument 492 return generic_block_bmap(mapping,block,get_block); sysv_bmap()
|
H A D | inode.c | 42 * If we are going to write out the super block, sysv_sync_fs() 184 unsigned int block; sysv_iget() local 219 for (block = 0; block < 10+1+1+1; block++) sysv_iget() 220 read3byte(sbi, &raw_inode->i_data[3*block], sysv_iget() 221 (u8 *)&si->i_data[block]); sysv_iget() 244 unsigned int ino, block; __sysv_write_inode() local 255 printk("unable to read i-node block\n"); __sysv_write_inode() 271 for (block = 0; block < 10+1+1+1; block++) __sysv_write_inode() 272 write3byte(sbi, (u8 *)&si->i_data[block], __sysv_write_inode() 273 &raw_inode->i_data[3*block]); __sysv_write_inode()
|
/linux-4.1.27/arch/x86/platform/intel-mid/device_libs/ |
H A D | platform_msic.c | 72 * msic_generic_platform_data - sets generic platform data for the block 73 * @info: pointer to the SFI device table entry for this block 74 * @block: MSIC block 79 void *msic_generic_platform_data(void *info, enum intel_msic_block block) msic_generic_platform_data() argument 83 BUG_ON(block < 0 || block >= INTEL_MSIC_BLOCK_LAST); msic_generic_platform_data() 84 msic_pdata.irq[block] = entry->irq; msic_generic_platform_data()
|
/linux-4.1.27/include/linux/ |
H A D | migrate_mode.h | 4 * MIGRATE_ASYNC means never block 8 * MIGRATE_SYNC will block when migrating pages
|
H A D | sysv_fs.h | 25 /* Xenix super-block data on disk */ 27 #define XENIX_NICFREE 100 /* number of free block list chunk entries */ 31 /* the start of the free block list: */ 33 sysv_zone_t s_free[XENIX_NICFREE]; /* first free block list chunk */ 38 char s_flock; /* lock during free block list manipulation */ 40 char s_fmod; /* super-block modified flag */ 42 __fs32 s_time __packed2__; /* time of last super block update */ 63 #define SYSV_NICFREE 50 /* number of free block list chunk entries */ 65 /* SystemV4 super-block data on disk */ 70 /* the start of the free block list: */ 73 sysv_zone_t s_free[SYSV_NICFREE]; /* first free block list chunk */ 79 char s_flock; /* lock during free block list manipulation */ 81 char s_fmod; /* super-block modified flag */ 83 __fs32 s_time; /* time of last super block update */ 97 /* SystemV2 super-block data on disk */ 101 /* the start of the free block list: */ 103 sysv_zone_t s_free[SYSV_NICFREE]; /* first free block list chunk */ 108 char s_flock; /* lock during free block list manipulation */ 110 char s_fmod; /* super-block modified flag */ 112 __fs32 s_time __packed2__; /* time of last super block update */ 125 /* V7 super-block data on disk */ 127 #define V7_NICFREE 50 /* number of free block list chunk entries */ 131 /* the start of the free block list: */ 133 sysv_zone_t s_free[V7_NICFREE]; /* first free block list chunk */ 138 char s_flock; /* lock during free block list manipulation */ 140 char s_fmod; /* super-block modified flag */ 142 __fs32 s_time __packed2__; /* time of last super block update */ 158 /* The disk addresses are three-byte (despite direct block addresses being 163 /* Coherent super-block data on disk */ 165 #define COH_NICFREE 64 /* number of free block list chunk entries */ 169 /* the start of the free block list: */ 171 sysv_zone_t s_free[COH_NICFREE] __packed2__; /* first free block list chunk */ 176 char s_flock; /* lock during free block list manipulation */ 178 char s_fmod; /* super-block modified flag */ 180 __fs32 s_time __packed2__; /* time of last super block update */
|
H A D | buffer_head.h | 54 * Historically, a buffer_head was used to map a single block 56 * filesystem and block layers. Nowadays the basic I/O unit 57 * is the bio, and buffer_heads are used for extracting block 67 sector_t b_blocknr; /* start block number */ 171 void unmap_underlying_metadata(struct block_device *bdev, sector_t block); 176 struct buffer_head *__find_get_block(struct block_device *bdev, sector_t block, 178 struct buffer_head *__getblk_gfp(struct block_device *bdev, sector_t block, 182 void __breadahead(struct block_device *, sector_t block, unsigned int size); 184 sector_t block, unsigned size, gfp_t gfp); 297 sb_bread(struct super_block *sb, sector_t block) sb_bread() argument 299 return __bread_gfp(sb->s_bdev, block, sb->s_blocksize, __GFP_MOVABLE); sb_bread() 303 sb_bread_unmovable(struct super_block *sb, sector_t block) sb_bread_unmovable() argument 305 return __bread_gfp(sb->s_bdev, block, sb->s_blocksize, 0); sb_bread_unmovable() 309 sb_breadahead(struct super_block *sb, sector_t block) sb_breadahead() argument 311 __breadahead(sb->s_bdev, block, sb->s_blocksize); sb_breadahead() 315 sb_getblk(struct super_block *sb, sector_t block) sb_getblk() argument 317 return __getblk_gfp(sb->s_bdev, block, sb->s_blocksize, __GFP_MOVABLE); sb_getblk() 322 sb_getblk_gfp(struct super_block *sb, sector_t block, gfp_t gfp) sb_getblk_gfp() argument 324 return __getblk_gfp(sb->s_bdev, block, sb->s_blocksize, gfp); sb_getblk_gfp() 328 sb_find_get_block(struct super_block *sb, sector_t block) sb_find_get_block() argument 330 return __find_get_block(sb->s_bdev, block, sb->s_blocksize); sb_find_get_block() 334 map_bh(struct buffer_head *bh, struct super_block *sb, sector_t block) map_bh() argument 338 bh->b_blocknr = block; map_bh() 362 sector_t block, getblk_unmovable() 365 return __getblk_gfp(bdev, block, size, 0); getblk_unmovable() 369 sector_t block, __getblk() 372 return __getblk_gfp(bdev, block, size, __GFP_MOVABLE); __getblk() 376 * __bread() - reads a specified block and returns the bh 378 * @block: number of block 381 * Reads a specified block, and returns buffer head that contains it. 383 * It returns NULL if the block was unreadable. 386 __bread(struct block_device *bdev, sector_t block, unsigned size) __bread() argument 388 return __bread_gfp(bdev, block, size, __GFP_MOVABLE); __bread() 361 getblk_unmovable(struct block_device *bdev, sector_t block, unsigned size) getblk_unmovable() argument 368 __getblk(struct block_device *bdev, sector_t block, unsigned size) __getblk() argument
|
H A D | f2fs_fs.h | 21 #define F2FS_BLKSIZE 4096 /* support only 4KB block */ 61 __le32 log_sectors_per_block; /* log2 # of sectors per block */ 62 __le32 log_blocksize; /* log2 block size in bytes */ 66 __le32 checksum_offset; /* checksum offset inside super block */ 75 __le32 segment0_blkaddr; /* start block address of segment 0 */ 76 __le32 cp_blkaddr; /* start block address of checkpoint */ 77 __le32 sit_blkaddr; /* start block address of SIT */ 78 __le32 nat_blkaddr; /* start block address of NAT */ 79 __le32 ssa_blkaddr; /* start block address of SSA */ 80 __le32 main_blkaddr; /* start block address of main area */ 104 __le64 checkpoint_ver; /* checkpoint block version number */ 119 __le32 cp_pack_start_sum; /* start block number of data summary */ 125 __le32 checksum_offset; /* checksum offset inside cp block */ 145 __le16 blk_addr; /* block index in current CP */ 148 __le32 check_sum; /* CRC32 for orphan inode block */ 156 __le32 blk; /* start block address of the extent */ 219 __le32 addr[ADDRS_PER_BLOCK]; /* array of data block address */ 223 __le32 nid[NIDS_PER_BLOCK]; /* array of data block address */ 240 __le32 next_blkaddr; /* next node page block address */ 261 __le32 block_addr; /* block address */ 281 * [9:0] : valid block count 304 * One summary block contains exactly 512 summary entries, which represents 313 * from node's page's beginning to get a data block address. 321 /* a summary entry for a 4KB-sized block in a segment */ 328 __le16 ofs_in_node; /* block index in parent node */ 333 /* summary block type, node or data, is stored to the summary_footer */ 381 /* 4KB-sized summary block structure */ 412 /* the number of dentry in a block */ 436 /* 4KB-sized directory entry block */ 438 /* validity bitmap for directory entries in each block */
|
H A D | dqblk_qtree.h | 11 * possible block size (1024) */ 31 unsigned int dqi_free_blk; /* First block in list of free blocks */ 32 unsigned int dqi_free_entry; /* First block with free entry */ 35 unsigned int dqi_usable_bs; /* Space usable in block for quota data */
|
H A D | rfkill.h | 46 * @poll: poll the rfkill block state(s) -- only assign this method 50 * value of those functions to make sure the software block is 52 * @query: query the rfkill block state(s) and call exactly one of the 56 * block. 140 * rfkill_set_hw_state - Set the internal rfkill hardware block state 142 * @state: the current hardware block state to set 154 * The function returns the combined block state (true if transmitter 156 * block state -- which they might not be able to. 161 * rfkill_set_sw_state - Set the internal rfkill software block state 163 * @state: the current software block state to set 177 * The function returns the combined block state (true if transmitter 183 * rfkill_init_sw_state - Initialize persistent software block state 185 * @state: the current software block state to set 187 * rfkill drivers that preserve their software block state over power off 199 * rfkill_set_states - Set the internal rfkill block states 201 * @sw: the current software block state to set 202 * @hw: the current hardware block state to set 210 * rfkill_blocked - query rfkill block
|
H A D | crc32.h | 20 * @crc1: crc32 of the first block 21 * @crc2: crc32 of the second block 22 * @len2: length of the second block 47 * @crc1: crc32c of the first block 48 * @crc2: crc32c of the second block 49 * @len2: length of the second block
|
H A D | nilfs2_fs.h | 61 * @i_bmap: block mapping 134 #define NILFS_MOUNT_BARRIER 0x1000 /* Use block barriers */ 143 * struct nilfs_super_block - structure of super block on disk 155 /*10*/ __le32 s_sum; /* Check sum of super block */ 161 /*20*/ __le64 s_dev_size; /* block device size in bytes */ 162 __le64 s_first_data_block; /* 1st seg disk block number */ 167 /*40*/ __le64 s_last_pseg; /* disk block addr pseg written last */ 201 __u32 s_reserved[186]; /* padding to the end of the block */ 259 * these files are written in super root block instead of ifile, and 266 * bytes offset of secondary super block 364 /* array of virtual block numbers */ 368 * struct nilfs_binfo_v - information for the block to which a virtual block number is assigned 369 * @bi_vblocknr: virtual block number 370 * @bi_blkoff: block offset 378 * struct nilfs_binfo_dat - information for the block which belongs to the DAT file 379 * @bi_blkoff: block offset 390 * union nilfs_binfo: block information 466 * struct nilfs_palloc_group_desc - block group descriptor 467 * @pg_nfrees: number of free entries in block group 475 * @de_blocknr: block number 502 * @cp_checkpoints_count: checkpoints count in a block 837 * struct nilfs_vinfo - virtual block number information 838 * @vi_vblocknr: virtual block number 841 * @vi_blocknr: disk block number 851 * struct nilfs_vdesc - descriptor of virtual block number 854 * @vd_vblocknr: virtual block number 856 * @vd_blocknr: disk block number 857 * @vd_offset: logical block offset inside a file 858 * @vd_flags: flags (data or node block) 873 * struct nilfs_bdesc - descriptor of disk block number 875 * @bd_oblocknr: disk block address (for skipping dead blocks) 876 * @bd_blocknr: disk block address 877 * @bd_offset: logical block offset inside a file
|
/linux-4.1.27/drivers/md/ |
H A D | dm-log-writes.c | 128 struct pending_block *block; member in struct:per_bio_data 158 DMERR("Error writing log block, error=%d", err); log_end_io() 173 * associated with the block. 176 struct pending_block *block) free_pending_block() 180 for (i = 0; i < block->vec_cnt; i++) { free_pending_block() 181 if (block->vecs[i].bv_page) free_pending_block() 182 __free_page(block->vecs[i].bv_page); free_pending_block() 184 kfree(block->data); free_pending_block() 185 kfree(block); free_pending_block() 227 DMERR("Couldn't add page to the log block"); write_metadata() 241 struct pending_block *block, sector_t sector) log_one_block() 248 entry.sector = cpu_to_le64(block->sector); log_one_block() 249 entry.nr_sectors = cpu_to_le64(block->nr_sectors); log_one_block() 250 entry.flags = cpu_to_le64(block->flags); log_one_block() 251 entry.data_len = cpu_to_le64(block->datalen); log_one_block() 252 if (write_metadata(lc, &entry, sizeof(entry), block->data, log_one_block() 253 block->datalen, sector)) { log_one_block() 254 free_pending_block(lc, block); log_one_block() 258 if (!block->vec_cnt) log_one_block() 262 bio = bio_alloc(GFP_KERNEL, block->vec_cnt); log_one_block() 275 for (i = 0; i < block->vec_cnt; i++) { log_one_block() 280 ret = bio_add_page(bio, block->vecs[i].bv_page, log_one_block() 281 block->vecs[i].bv_len, 0); log_one_block() 282 if (ret != block->vecs[i].bv_len) { log_one_block() 285 bio = bio_alloc(GFP_KERNEL, block->vec_cnt - i); log_one_block() 297 ret = bio_add_page(bio, block->vecs[i].bv_page, log_one_block() 298 block->vecs[i].bv_len, 0); log_one_block() 299 if (ret != block->vecs[i].bv_len) { log_one_block() 305 sector += block->vecs[i].bv_len >> SECTOR_SHIFT; log_one_block() 309 kfree(block->data); log_one_block() 310 kfree(block); log_one_block() 314 free_pending_block(lc, block); log_one_block() 349 struct pending_block *block = NULL; log_writes_kthread() local 354 block = list_first_entry(&lc->logging_blocks, log_writes_kthread() 356 list_del_init(&block->list); log_writes_kthread() 361 if (block->flags & LOG_DISCARD_FLAG) log_writes_kthread() 364 lc->next_sector += block->nr_sectors + 1; log_writes_kthread() 381 super = (block->flags & (LOG_FUA_FLAG | LOG_MARK_FLAG)); log_writes_kthread() 388 if (block) { log_writes_kthread() 390 ret = log_one_block(lc, block, sector); log_writes_kthread() 399 free_pending_block(lc, block); log_writes_kthread() 487 struct pending_block *block; log_mark() local 490 block = kzalloc(sizeof(struct pending_block), GFP_KERNEL); log_mark() 491 if (!block) { log_mark() 492 DMERR("Error allocating pending block"); log_mark() 496 block->data = kstrndup(data, maxsize, GFP_KERNEL); log_mark() 497 if (!block->data) { log_mark() 499 kfree(block); log_mark() 503 block->datalen = strlen(block->data); log_mark() 504 block->flags |= LOG_MARK_FLAG; log_mark() 506 list_add_tail(&block->list, &lc->logging_blocks); log_mark() 548 struct pending_block *block; log_writes_map() local 557 pb->block = NULL; log_writes_map() 575 * allocate the size of the pending block. log_writes_map() 582 block = kzalloc(alloc_size, GFP_NOIO); log_writes_map() 583 if (!block) { log_writes_map() 584 DMERR("Error allocating pending block"); log_writes_map() 590 INIT_LIST_HEAD(&block->list); log_writes_map() 591 pb->block = block; log_writes_map() 595 block->flags |= LOG_FLUSH_FLAG; log_writes_map() 597 block->flags |= LOG_FUA_FLAG; log_writes_map() 599 block->flags |= LOG_DISCARD_FLAG; log_writes_map() 601 block->sector = bio->bi_iter.bi_sector; log_writes_map() 602 block->nr_sectors = bio_sectors(bio); log_writes_map() 616 list_splice_init(&lc->unflushed_blocks, &block->list); log_writes_map() 637 free_pending_block(lc, block); bio_for_each_segment() 649 block->vecs[i].bv_page = page; bio_for_each_segment() 650 block->vecs[i].bv_len = bv.bv_len; bio_for_each_segment() 651 block->vec_cnt++; bio_for_each_segment() 658 list_splice_init(&lc->unflushed_blocks, &block->list); 671 if (bio_data_dir(bio) == WRITE && pb->block) { normal_end_io() 672 struct pending_block *block = pb->block; normal_end_io() local 676 if (block->flags & LOG_FLUSH_FLAG) { normal_end_io() 677 list_splice_tail_init(&block->list, &lc->logging_blocks); normal_end_io() 678 list_add_tail(&block->list, &lc->logging_blocks); normal_end_io() 680 } else if (block->flags & LOG_FUA_FLAG) { normal_end_io() 681 list_add_tail(&block->list, &lc->logging_blocks); normal_end_io() 684 list_add_tail(&block->list, &lc->unflushed_blocks); normal_end_io() 175 free_pending_block(struct log_writes_c *lc, struct pending_block *block) free_pending_block() argument 240 log_one_block(struct log_writes_c *lc, struct pending_block *block, sector_t sector) log_one_block() argument
|
H A D | dm-cache-policy.h | 10 #include "dm-cache-block-types.h" 28 * That block is in the cache. Remap to the cache and carry on. 31 * This block is on the origin device. Remap and carry on. 34 * This block is currently on the origin device, but the policy wants to 37 * - hold any further io to this origin block 38 * - copy the origin to the given cache block 40 * - remap the original block to the cache 43 * This block is currently on the origin device. The policy wants to 45 * cache block needs a writeback first. The core should: 47 * - hold any further io to this origin block 48 * - hold any further io to the origin block that's being written back 50 * - copy new block to cache 61 * In general policy methods should never block, except in the case of the 74 * lock the block being demoted. This doesn't need to occur during a 75 * writeback operation since the block remains in the cache. 105 * block. 116 * oblock - the origin block we're interested in. 119 * block. -EWOULDBLOCK returned if it can't and would. 126 * discarded_oblock - indicates whether the whole origin block is 129 * cache block if it wants.) 141 * Sometimes we want to see if a block is in the cache, without 144 * Must not block. 181 * Provide a dirty block to be written back by the core target. 185 * 0 and @cblock,@oblock: block to write back provided 197 * Because of where we sit in the block layer, we can be asked to 198 * map a lot of little bios that are all in the same block (no 245 * Policies may store a hint for each each cache block.
|
H A D | dm-bufio.h | 44 * Read a given block from disk. Returns pointer to data. Returns a 48 void *dm_bufio_read(struct dm_bufio_client *c, sector_t block, 55 void *dm_bufio_get(struct dm_bufio_client *c, sector_t block, 62 void *dm_bufio_new(struct dm_bufio_client *c, sector_t block, 71 sector_t block, unsigned n_blocks); 107 * block. dm_bufio_write_dirty_buffers is needed to commit the new block. 116 void dm_bufio_forget(struct dm_bufio_client *c, sector_t block);
|
H A D | dm-verity.c | 61 u8 *root_digest; /* digest of the root block */ 70 unsigned char hash_per_block_bits; /* log2(hashes in hash block) */ 75 int hash_failed; /* set to 1 if hash of any block failed */ 94 sector_t block; member in struct:dm_verity_io 115 sector_t block; member in struct:dm_verity_prefetch_work 136 * hash_verified is nonzero, hash of the block has been verified. 169 * Return hash position of a specified block at a specified tree level 172 * inside a hash block. The remaining bits denote location of the hash block. 174 static sector_t verity_position_at_level(struct dm_verity *v, sector_t block, verity_position_at_level() argument 177 return block >> (level * v->hash_per_block_bits); verity_position_at_level() 180 static void verity_hash_at_level(struct dm_verity *v, sector_t block, int level, verity_hash_at_level() argument 183 sector_t position = verity_position_at_level(v, block, level); verity_hash_at_level() 202 unsigned long long block) verity_handle_err() 228 DMERR("%s: %s block %llu is corrupted", v->data_dev->name, type_str, verity_handle_err() 229 block); verity_handle_err() 235 DM_VERITY_ENV_VAR_NAME, type, block); verity_handle_err() 250 * Verify hash of a metadata block pertaining to the specified data block 251 * ("block" argument) at a specified level ("level" argument). 254 * a lower tree level or for the data block (if we're at the lowest leve). 260 static int verity_verify_level(struct dm_verity_io *io, sector_t block, verity_verify_level() argument 271 verity_hash_at_level(v, block, level, &hash_block, &offset); verity_verify_level() 368 * the current block. If the hash block itself is verity_verify_io() 373 int r = verity_verify_level(io, io->block + b, 0, true); verity_verify_io() 383 int r = verity_verify_level(io, io->block + b, i, false); verity_verify_io() 443 io->block + b)) verity_verify_io() 500 verity_hash_at_level(v, pw->block, i, &hash_block_start, NULL); verity_prefetch_io() 501 verity_hash_at_level(v, pw->block + pw->n_blocks - 1, i, &hash_block_end, NULL); verity_prefetch_io() 537 pw->block = io->block; verity_submit_prefetch() 573 io->block = bio->bi_iter.bi_sector >> (v->data_dev_block_bits - SECTOR_SHIFT); verity_map() 723 * <data block size> 724 * <hash block size> 726 * <hash start block> 791 ti->error = "Invalid data device block size"; verity_ctr() 801 ti->error = "Invalid hash device block size"; verity_ctr() 201 verity_handle_err(struct dm_verity *v, enum verity_block_type type, unsigned long long block) verity_handle_err() argument
|
H A D | dm-thin-metadata.h | 10 #include "persistent-data/dm-block-manager.h" 136 dm_block_t block; member in struct:dm_thin_lookup_result 146 int dm_thin_find_block(struct dm_thin_device *td, dm_block_t block, 150 * Obtain an unused block. 155 * Insert or remove block. 157 int dm_thin_insert_block(struct dm_thin_device *td, dm_block_t block, 160 int dm_thin_remove_block(struct dm_thin_device *td, dm_block_t block); 197 * Flicks the underlying block manager into read only mode, so you know
|
/linux-4.1.27/arch/mips/include/asm/octeon/ |
H A D | cvmx-bootmem.h | 45 /* Allocate from end of block instead of beginning */ 51 /* First bytes of each free physical block of memory contain this structure, 76 /* Base address of named block */ 79 * Size actually allocated for named block (may differ from 83 /* name of named block */ 122 /* address of named memory block descriptors */ 149 * Allocate a block of memory from the free list that was passed 153 * @size: Size in bytes of block to allocate 156 * Returns pointer to block of memory, NULL on error 161 * Allocate a block of memory from the free list that was 167 * @size: Size in bytes of block to allocate 171 * Returns pointer to block of memory, NULL on error 177 * Allocate a block of memory from the free list that was 183 * @size: Size in bytes of block to allocate 187 * Returns pointer to block of memory, NULL on error 193 * Frees a previously allocated named bootmem block. 195 * @name: name of block to free 203 * Allocate a block of memory from the free list that was passed 205 * global named block table. (part of the cvmx_bootmem_descriptor_t structure) 208 * @size: Size in bytes of block to allocate 210 * @name: name of block - must be less than CVMX_BOOTMEM_NAME_LEN bytes 212 * Returns a pointer to block of memory, NULL on error 220 * Allocate a block of memory from the free list that was passed 222 * global named block table. (part of the cvmx_bootmem_descriptor_t structure) 225 * @size: Size in bytes of block to allocate 228 * @name: name of block - must be less than CVMX_BOOTMEM_NAME_LEN 231 * Returns a pointer to block of memory, NULL on error 239 * Allocate a block of memory from a specific range of the free list 241 * a name in the global named block table. (part of the 246 * @size: Size in bytes of block to allocate 250 * @name: name of block - must be less than CVMX_BOOTMEM_NAME_LEN bytes 252 * Returns a pointer to block of memory, NULL on error 261 * Finds a named bootmem block by name. 263 * @name: name of block to free 265 * Returns pointer to named block descriptor on success 271 * Allocates a block of physical memory from the free list, at 277 * @address_min: Minimum address that block can occupy. 282 * @alignment: Requested alignment of the block. If this alignment 292 * Returns physical address of block allocated, or -1 on failure 299 * Allocates a named block of physical memory from the free list, at 305 * @param min_addr Minimum address that block can occupy. 308 * @param alignment Requested alignment of the block. If this 315 * @param name name to assign to named block 318 * @return physical address of block allocated, or -1 on failure 326 * Finds a named memory block by name. 327 * Also used for finding an unused entry in the named block table. 329 * @name: Name of memory block to find. If NULL pointer given, then 334 * Returns Pointer to memory block descriptor, NULL if not found. 336 * block descriptors are available. 342 * Frees a named block. 344 * @name: name of block to free 353 * Frees a block to the bootmem allocator list. This must 355 * of the block that was allocated, or the list will become 358 * IMPORTANT: This is only intended to be used as part of named block 362 * @phy_addr: physical address of block 363 * @size: size of block in bytes.
|
/linux-4.1.27/drivers/mtd/onenand/ |
H A D | onenand_bbt.c | 27 * Check for a pattern at the given place. Used to search bad block 28 * tables and good / bad block identifiers. Same as check_pattern, but 47 * create_bbt - [GENERIC] Create a bad block table by scanning the device 50 * @param bd descriptor for the good/bad block search pattern 54 * Create a bad block table by scanning the device 55 * for the given good/bad block identify pattern 98 /* If it is a initial bad block, just ignore it */ create_bbt() 106 "initial bad block\n", i >> 1); create_bbt() 125 * onenand_memory_bbt - [GENERIC] create a memory based bad block table 127 * @param bd descriptor for the good/bad block search pattern 140 * onenand_isbad_bbt - [OneNAND Interface] Check if a block is bad 143 * @param allowbbt allow access to bad block table region 149 int block; onenand_isbad_bbt() local 152 /* Get block number * 2 */ onenand_isbad_bbt() 153 block = (int) (onenand_block(this, offs) << 1); onenand_isbad_bbt() 154 res = (bbm->bbt[block >> 3] >> (block & 0x06)) & 0x03; onenand_isbad_bbt() 156 pr_debug("onenand_isbad_bbt: bbt info for offs 0x%08x: (block %d) 0x%02x\n", onenand_isbad_bbt() 157 (unsigned int) offs, block >> 1, res); onenand_isbad_bbt() 169 * onenand_scan_bbt - [OneNAND Interface] scan, find, read and maybe create bad block table(s) 171 * @param bd descriptor for the good/bad block search pattern 173 * The function checks, if a bad block table(s) is/are already 175 * marked good / bad blocks and writes the bad block table(s) to 178 * The bad block table memory is allocated here. It is freed 189 /* Allocate memory (2bit per block) and clear the memory bad block table */ onenand_scan_bbt() 194 /* Set the bad block position */ onenand_scan_bbt() 203 /* Scan the device to build a memory based bad block table */ onenand_scan_bbt() 214 * Define some generic bad / good block scan pattern which are used 227 * onenand_default_bbt - [OneNAND Interface] Select a default bad block table for the device 230 * This function selects the default bad block table
|
/linux-4.1.27/fs/ext3/ |
H A D | balloc.c | 9 * Enhanced block allocation by Stephen Tweedie (sct@redhat.com), 1993 24 * blocks groups. Each group contains 1 bitmap block for blocks, 1 bitmap 25 * block for inodes, N blocks for the inode table and data blocks. 28 * super block. Each descriptor contains the number of the bitmap block and 29 * the free blocks count in the block. The descriptors are loaded in memory 37 * Calculate the block group number and offset, given a block number 53 * @sb: super block 54 * @block_group: given block group 55 * @bh: pointer to the buffer head to store the block 105 /* check whether block bitmap block number is set */ ext3_valid_block_bitmap() 109 /* bad block bitmap */ ext3_valid_block_bitmap() 112 /* check whether the inode bitmap block number is set */ ext3_valid_block_bitmap() 116 /* bad block bitmap */ ext3_valid_block_bitmap() 119 /* check whether the inode table block number is set */ ext3_valid_block_bitmap() 131 "Invalid block bitmap - " ext3_valid_block_bitmap() 132 "block_group = %d, block = %lu", ext3_valid_block_bitmap() 139 * @sb: super block 140 * @block_group: given block group 143 * bits for block/inode/inode tables are set in the bitmaps 162 "Cannot read block bitmap - " read_block_bitmap() 173 "Cannot read block bitmap - " read_block_bitmap() 197 * __rsv_window_dump() -- Dump the filesystem block allocation reservation map 202 * If verbose is turned on, it will print the whole block reservation 258 * @grp_goal: given goal block relative to the allocation block group 259 * @group: the current allocation block group 260 * @sb: filesystem super block 262 * Test if the given goal block (group relative) is within the file's 263 * own block reservation window range. 266 * grp_goal (given goal block) could be -1, which means no specific 267 * goal block. In this case, always return 1. 268 * If the goal block is within the reservation window, return 1; 292 * @goal: target allocation block 331 * ext3_rsv_window_add() -- Insert a window to the block reservation rb tree. 332 * @sb: super block 370 * @sb: super block 373 * Mark the block reservation window as not allocated, and unlink it 390 * returns 1 if the end block is EXT3_RESERVE_WINDOW_NOT_ALLOCATED. 394 /* a valid reservation end block could not be 0 */ rsv_is_empty() 407 * needs a new block. So, before every ext3_new_block(s) call, for 410 * Fail to do so will result in block reservation being turned off for that 415 * is open for write (needs block allocation). 435 * block reservation is off ext3_init_block_alloc_info() 452 * Discard(free) block reservation window on last file close, or truncate 458 * ext3_truncate(): when the block indirect map is about to change. 485 * @sb: super block 486 * @block: start physical block to free 491 ext3_fsblk_t block, unsigned long count, ext3_free_blocks_sb() 509 if (block < le32_to_cpu(es->s_first_data_block) || ext3_free_blocks_sb() 510 block + count < block || ext3_free_blocks_sb() 511 block + count > le32_to_cpu(es->s_blocks_count)) { ext3_free_blocks_sb() 514 "block = "E3FSBLK", count = %lu", block, count); ext3_free_blocks_sb() 518 ext3_debug ("freeing block(s) %lu-%lu\n", block, block + count - 1); ext3_free_blocks_sb() 522 block_group = (block - le32_to_cpu(es->s_first_data_block)) / ext3_free_blocks_sb() 524 bit = (block - le32_to_cpu(es->s_first_data_block)) % ext3_free_blocks_sb() 542 if (in_range (le32_to_cpu(desc->bg_block_bitmap), block, count) || ext3_free_blocks_sb() 543 in_range (le32_to_cpu(desc->bg_inode_bitmap), block, count) || ext3_free_blocks_sb() 544 in_range (block, le32_to_cpu(desc->bg_inode_table), ext3_free_blocks_sb() 546 in_range (block + count - 1, le32_to_cpu(desc->bg_inode_table), ext3_free_blocks_sb() 551 block, count); ext3_free_blocks_sb() 585 debug_bh = sb_find_get_block(sb, block + i); ext3_free_blocks_sb() 608 * revoking the queued write of a data block, which ext3_free_blocks_sb() 610 * cannot block due to truncate races. ext3_free_blocks_sb() 636 "bit already cleared for block "E3FSBLK, ext3_free_blocks_sb() 637 block + i); ext3_free_blocks_sb() 651 /* We dirtied the bitmap block */ ext3_free_blocks_sb() 652 BUFFER_TRACE(bitmap_bh, "dirtied bitmap block"); ext3_free_blocks_sb() 655 /* And the group descriptor block */ ext3_free_blocks_sb() 656 BUFFER_TRACE(gd_bh, "dirtied group descriptor block"); ext3_free_blocks_sb() 662 block += count; ext3_free_blocks_sb() 677 * @block: start physical block to free 681 ext3_fsblk_t block, unsigned long count) ext3_free_blocks() 686 trace_ext3_free_blocks(inode, block, count); ext3_free_blocks() 687 ext3_free_blocks_sb(handle, sb, block, count, &dquot_freed_blocks); ext3_free_blocks() 695 * @nr: given allocation block group 696 * @bh: bufferhead contains the bitmap of the given block group 704 * data would allow the old block to be overwritten before the 732 * @start: the starting block (group relative) of the search 733 * @bh: bufferhead contains the block group bitmap 734 * @maxblocks: the ending block (group relative) of the reservation 764 * @start: the starting block (group relative) to find next 765 * allocatable block in bitmap. 766 * @bh: bufferhead contains the block group bitmap 767 * @maxblocks: the ending block (group relative) for the search 769 * Find an allocatable block in a bitmap. We honor both the bitmap and 771 * appropriate allocation" algorithm of looking for a free block near 785 * block within the next XX blocks. find_next_usable_block() 822 * @lock: the spin lock for this block group 823 * @block: the free block (group relative) to allocate 824 * @bh: the buffer_head contains the block group bitmap 826 * We think we can allocate this block in this bitmap. Try to set the bit. 828 * block since we saw that is was not marked in b_committed_data. If it _was_ 833 claim_block(spinlock_t *lock, ext3_grpblk_t block, struct buffer_head *bh) claim_block() argument 838 if (ext3_set_bit_atomic(lock, block, bh->b_data)) claim_block() 841 if (jh->b_committed_data && ext3_test_bit(block,jh->b_committed_data)) { claim_block() 842 ext3_clear_bit_atomic(lock, block, bh->b_data); claim_block() 855 * @group: given allocation block group 856 * @bitmap_bh: bufferhead holds the block bitmap 857 * @grp_goal: given target block within the group 866 * if there is a reservation window, only try to allocate block(s) from the 868 * Otherwise, the allocation range starts from the give goal block, ends at 869 * the block group's last block. 871 * If we failed to allocate the desired block then we may end up crossing to a 930 * The block was allocated by another thread, or it was ext3_try_to_allocate() 971 * @sb: the super block 973 * @start_block: the first block we consider to start 977 * the maximum block number that our goal reservable space 978 * could start from. This is normally the last block in this 1084 * there, we check the bitmap for the first free block after 1085 * it. If there is no free block until the end of group, then the 1087 * block is inside the expected reservable space, if so, we 1089 * If the first free block is outside the reservable space, then 1090 * start from the first free block, we search for next available 1094 * It contains at least one free block, and it does not overlap with other 1104 * no grp_goal(grp_goal = -1), we start from the first block 1107 * @sb: the super block 1109 * @bitmap_bh: the block group block bitmap 1146 * Maybe we could shift the start block of the reservation alloc_new_reservation() 1147 * window to the first block of next group. alloc_new_reservation() 1172 * shift the search start to the window near the goal block alloc_new_reservation() 1198 * to make sure there is at least a free block inside this region. alloc_new_reservation() 1200 * searching the first free bit on the block bitmap and copy of alloc_new_reservation() 1202 * block. Search start from the start block of the reservable space alloc_new_reservation() 1212 * no free block left on the bitmap, no point alloc_new_reservation() 1224 * check if the first free block is within the alloc_new_reservation() 1235 * start from where the free block is, alloc_new_reservation() 1246 * @sb: super block 1289 * @group: given allocation block group 1290 * @bitmap_bh: bufferhead holds the block bitmap 1291 * @grp_goal: given target block within the group 1296 * This is the main function used to allocate a new block and its reservation 1299 * Each time when a new block allocation is need, first try to allocate from 1303 * reservation window for it starting from the goal first. Then do the block 1307 * again when somebody is looking for a free block (without 1333 BUFFER_TRACE(bitmap_bh, "get undo access for new block"); ext3_try_to_allocate_with_rsv() 1344 * or last attempt to allocate a block with reservation turned on failed ext3_try_to_allocate_with_rsv() 1352 * grp_goal is a group relative block number (if there is a goal) ext3_try_to_allocate_with_rsv() 1354 * first block is a filesystem wide block number ext3_try_to_allocate_with_rsv() 1355 * first block is the block number of the first block in this group ext3_try_to_allocate_with_rsv() 1361 * Basically we will allocate a new block from inode's reservation ext3_try_to_allocate_with_rsv() 1366 * b) last attempt to allocate a block from existing reservation ext3_try_to_allocate_with_rsv() 1415 "bitmap block"); ext3_try_to_allocate_with_rsv() 1431 * @sbi: in-core super block structure. 1433 * Check if filesystem has at least 1 free block available for allocation. 1452 * @sb: super block 1473 * ext3_new_blocks() -- core block(s) allocation function 1476 * @goal: given target block(filesystem wide) 1480 * ext3_new_blocks uses a goal block to assist allocation. It tries to 1481 * allocate block(s) from the block group contains the goal block first. If that 1482 * fails, it will try to allocate block(s) from other block groups without 1483 * any specific goal block. 1493 ext3_grpblk_t grp_target_blk; /* blockgroup relative goal block */ ext3_new_blocks() 1494 ext3_grpblk_t grp_alloc_blk; /* blockgroup-relative allocated block*/ ext3_new_blocks() 1495 ext3_fsblk_t ret_block; /* filesyetem-wide allocated block */ ext3_new_blocks() 1517 * Check quota for allocation of this block. ext3_new_blocks() 1531 * Allocate a block from reservation only when ext3_new_blocks() 1548 * First, test whether the goal block is free. ext3_new_blocks() 1620 * try to allocate block(s) from this group, without a goal(-1). ext3_new_blocks() 1635 * just do block allocation as without reservations. ext3_new_blocks() 1649 ext3_debug("using block group %d(%d)\n", ext3_new_blocks() 1666 "Allocating block in system zone - " ext3_new_blocks() 1682 /* Record bitmap buffer state in the newly allocated block */ ext3_new_blocks() 1698 printk("%s: block was unexpectedly set in " ext3_new_blocks() 1710 "block("E3FSBLK") >= blocks count(%d) - " ext3_new_blocks() 1721 ext3_debug("allocating block %lu. Goal hits %d of %d.\n", ext3_new_blocks() 1755 * Undo the block allocation ext3_new_blocks() 1775 * Adds up the number of free blocks from each block group. 1907 * @sb: super block for file system 1909 * @start: first group block to examine 1910 * @max: last group block to examine 1912 * @minblocks: minimum extent block count 1914 * ext3_trim_all_free walks through group's block bitmap searching for free 1915 * blocks. When the free block is found, it tries to allocate this block and 1916 * consequent free block to get the biggest free extent possible, until it 1917 * reaches any used block. Then issue a TRIM command on this extent and free 1918 * the extent in the block bitmap. This is done until whole group is scanned. 1934 * We will update one block bitmap, and one group descriptor ext3_trim_all_free() 1974 * block bitmap ext3_trim_all_free() 2016 "bit already cleared for block "E3FSBLK, ext3_trim_all_free() 2050 /* We dirtied the bitmap block */ ext3_trim_all_free() 2051 BUFFER_TRACE(bitmap_bh, "dirtied bitmap block"); ext3_trim_all_free() 2056 /* And the group descriptor block */ ext3_trim_all_free() 2057 BUFFER_TRACE(gdp_bh, "dirtied group descriptor block"); ext3_trim_all_free() 2120 /* end now represents the last block to discard in this group */ ext3_trim_fs() 2129 * For all the groups except the last one, last block will ext3_trim_fs() 2147 * that the first block to discard will be block #0. ext3_trim_fs() 490 ext3_free_blocks_sb(handle_t *handle, struct super_block *sb, ext3_fsblk_t block, unsigned long count, unsigned long *pdquot_freed_blocks) ext3_free_blocks_sb() argument 680 ext3_free_blocks(handle_t *handle, struct inode *inode, ext3_fsblk_t block, unsigned long count) ext3_free_blocks() argument
|
H A D | namei.h | 12 int block, int create, ext3_dir_bread() 17 bh = ext3_bread(handle, inode, block, create, err); ext3_dir_bread() 10 ext3_dir_bread(handle_t *handle, struct inode *inode, int block, int create, int *err) ext3_dir_bread() argument
|
H A D | resize.c | 62 "Cannot read last block ("E3FSBLK")", verify_group_input() 66 "Block bitmap not in group (block %u)", verify_group_input() 70 "Inode bitmap not in group (block %u)", verify_group_input() 182 * Set up the block and inode bitmaps, and the inode table for the new group. 198 ext3_fsblk_t block; setup_new_group_blocks() local 226 for (i = 0, bit = 1, block = start + 1; setup_new_group_blocks() 227 i < gdblocks; i++, block++, bit++) { setup_new_group_blocks() 230 ext3_debug("update backup group %#04lx (+%d)\n", block, bit); setup_new_group_blocks() 236 gdb = sb_getblk(sb, block); setup_new_group_blocks() 259 for (i = 0, bit = gdblocks + 1, block = start + bit; setup_new_group_blocks() 260 i < reserved_gdb; i++, block++, bit++) { setup_new_group_blocks() 263 ext3_debug("clear reserved block %#04lx (+%d)\n", block, bit); setup_new_group_blocks() 269 if (IS_ERR(gdb = bclean(handle, sb, block))) { setup_new_group_blocks() 281 ext3_debug("mark block bitmap %#04x (+%ld)\n", input->block_bitmap, setup_new_group_blocks() 289 for (i = 0, block = input->inode_table, bit = block - start; setup_new_group_blocks() 290 i < sbi->s_itb_per_group; i++, bit++, block++) { setup_new_group_blocks() 293 ext3_debug("clear inode block %#04lx (+%d)\n", block, bit); setup_new_group_blocks() 299 if (IS_ERR(it = bclean(handle, sb, block))) { setup_new_group_blocks() 382 * Check that all of the backup GDT blocks are held in the primary GDT block. 415 * Called when we need to bring a reserved group descriptor table block into 416 * use from the resize inode. The primary copy of the new GDT block currently 417 * is an indirect block (under the double indirect block in the resize inode). 419 * block, in group order. Even though we know all the block numbers we need, 422 * Don't need to update the block bitmaps because the blocks are still in use. 444 "EXT3-fs: ext3_add_new_gdb: adding group block %lu\n", add_new_gdb() 479 "new group %u GDT block "E3FSBLK" not reserved", add_new_gdb() 510 * Remove new GDT block from inode double-indirect block and clear out add_new_gdb() 511 * the new GDT block for use (which also "frees" the backup GDT blocks add_new_gdb() 572 * Each reserved backup GDT block will go into a different indirect block. 574 * so we know in advance what their block numbers are. We only get the 575 * double-indirect block to verify it is pointing to the primary reserved 576 * GDT blocks so we don't overwrite a data block by accident. The reserved 577 * backup GDT blocks are stored in their reserved primary GDT block. 609 /* Get each reserved primary GDT block and verify it holds backups */ reserve_backup_gdb() 613 "reserved block "E3FSBLK reserve_backup_gdb() 650 * the new group to its reserved primary GDT block. reserve_backup_gdb() 684 * important part is that the new block and inode counts are in the backup 770 /* Add group descriptor data to an existing or new group descriptor block. 775 * If we are on a GDT block boundary, we need to get the reserved GDT block. 842 * block. If we are adding a group past the last current GDT block, ext3_group_add() 843 * we will also modify the inode and the dindirect block. If we ext3_group_add() 868 * or remove reserved blocks for the first group in a new group block. ext3_group_add() 902 /* Update group descriptor block for new group */ ext3_group_add() 916 * We always allocate group-by-group, then block-by-block or ext3_group_add() 941 * while freeing data, as we can only allocate from a block ext3_group_add() 955 /* Update the reserved block counts only once the new group is ext3_group_add() 1061 "can't read last block, resize aborted"); ext3_group_extend() 1066 /* We will update the superblock, one block bitmap, and ext3_group_extend()
|
/linux-4.1.27/fs/bfs/ |
H A D | file.c | 6 * Make the file block allocation algorithm understand the size 7 * of the underlying block device. 56 dprintf("failed to move block %08lx -> %08lx\n", i, bfs_move_blocks() 63 static int bfs_get_block(struct inode *inode, sector_t block, bfs_get_block() argument 72 phys = bi->i_sblock + block; bfs_get_block() 76 create, (unsigned long)block, phys); bfs_get_block() 83 * If the file is not empty and the requested block is within the bfs_get_block() 87 dprintf("c=%d, b=%08lx, phys=%08lx (interim block granted)\n", bfs_get_block() 88 create, (unsigned long)block, phys); bfs_get_block() 101 * If the last data block for this file is the last allocated bfs_get_block() 102 * block, we can extend the file trivially, without moving it bfs_get_block() 107 create, (unsigned long)block, phys); bfs_get_block() 116 /* Ok, we have to move this entire file to the next free block. */ bfs_get_block() 118 if (phys + block >= info->si_blocks) { bfs_get_block() 135 create, (unsigned long)block, phys); bfs_get_block() 137 phys += block; bfs_get_block() 184 static sector_t bfs_bmap(struct address_space *mapping, sector_t block) bfs_bmap() argument 186 return generic_block_bmap(mapping, block, bfs_get_block); bfs_bmap()
|
H A D | dir.c | 35 int block; bfs_readdir() local 46 block = BFS_I(dir)->i_sblock + (ctx->pos >> BFS_BSIZE_BITS); bfs_readdir() 47 bh = sb_bread(dir->i_sb, block); bfs_readdir() 281 int block, sblock, eblock, off, pos; bfs_add_entry() local 293 for (block = sblock; block <= eblock; block++) { bfs_add_entry() 294 bh = sb_bread(dir->i_sb, block); bfs_add_entry() 300 pos = (block - sblock) * BFS_BSIZE + off; bfs_add_entry() 333 unsigned long block = 0, offset = 0; bfs_find_entry() local 341 while (block * BFS_BSIZE + offset < dir->i_size) { bfs_find_entry() 343 bh = sb_bread(dir->i_sb, BFS_I(dir)->i_sblock + block); bfs_find_entry() 345 block++; bfs_find_entry() 361 block++; bfs_find_entry()
|
/linux-4.1.27/fs/btrfs/ |
H A D | check-integrity.c | 26 * Code is added that examines all block write requests during 27 * runtime (including writes of the super block). Three rules 30 * 1. It is not allowed to write a disk block which is 31 * currently referenced by the super block (either directly 33 * 2. When a super block is written, it is verified that all 38 * referenced by the super block) or they have been 50 * block. 68 * the tree that the super block references to kernel messages 69 * each time after a super block was written: 77 * the integrity of (super)-block write requests, do not 148 unsigned int never_written:1; /* block was added because it was 177 * each block object can refer to and can be ref from multiple blocks. 179 * the block ref to plus the one from the block refered from. 184 * as a write operation to a block while that block is still referenced). 239 struct btrfsic_block *block; member in struct:btrfsic_stack_frame 305 struct btrfsic_block *block, 313 struct btrfsic_block *block, 324 struct btrfsic_block *block, 344 struct btrfsic_block *const block, 349 const struct btrfsic_block *block, 352 struct btrfsic_block *const block, 359 const struct btrfsic_block *block); 362 const struct btrfsic_block *block, 806 /* super block bytenr is always the unmapped device bytenr */ btrfsic_process_superblock_dev_mirror() 848 printk_in_rcu(KERN_INFO "New initial S-block (bdev %p, %s)" btrfsic_process_superblock_dev_mirror() 991 sf->block = first_block; btrfsic_process_metablock() 998 sf->block->generation = le64_to_cpu(sf->hdr->generation); btrfsic_process_metablock() 1070 sf->block, btrfsic_process_metablock() 1101 next_stack->block = sf->next_block; btrfsic_process_metablock() 1116 sf->block, btrfsic_process_metablock() 1171 sf->block, btrfsic_process_metablock() 1197 next_stack->block = sf->next_block; btrfsic_process_metablock() 1216 /* the one for the initial block is freed in the caller */ btrfsic_process_metablock() 1265 struct btrfsic_block *block, btrfsic_create_link_to_next_block() 1332 "Referenced block @%llu (%s/%llu/%d) found in hash table, %c, bytenr mismatch (!= stored %llu).\n", btrfsic_create_link_to_next_block() 1340 "Referenced block @%llu (%s/%llu/%d) found in hash table, %c.\n", btrfsic_create_link_to_next_block() 1369 l->block_ref_from = block; btrfsic_create_link_to_next_block() 1376 list_add(&l->node_ref_to, &block->ref_to_list); btrfsic_create_link_to_next_block() 1395 "btrfsic: read block @logical %llu failed!\n", btrfsic_create_link_to_next_block() 1413 struct btrfsic_block *block, btrfsic_handle_extent_data() 1537 "Referenced block" btrfsic_handle_extent_data() 1554 next_block, block, btrfsic_handle_extent_data() 1735 printk(KERN_INFO "%c-block @%llu (%s/%llu/%d)\n", btrfsic_dump_database() 1785 * Test whether the disk block contains a tree block (leaf or node) 1786 * (note that this test fails for the super block) 1826 struct btrfsic_block *block; btrfsic_process_written_block() local 1844 block = btrfsic_block_hashtable_lookup(bdev, dev_bytenr, btrfsic_process_written_block() 1846 if (NULL != block) { btrfsic_process_written_block() 1851 if (block->is_superblock) { btrfsic_process_written_block() 1867 btrfsic_dump_tree_sub(state, block, 0); btrfsic_process_written_block() 1871 if (!block->is_superblock) { btrfsic_process_written_block() 1887 if (block->logical_bytenr != bytenr && btrfsic_process_written_block() 1888 !(!block->is_metadata && btrfsic_process_written_block() 1889 block->logical_bytenr == 0)) btrfsic_process_written_block() 1891 "Written block @%llu (%s/%llu/%d) found in hash table, %c, bytenr mismatch (!= stored %llu).\n", btrfsic_process_written_block() 1894 block->mirror_num, btrfsic_process_written_block() 1896 block), btrfsic_process_written_block() 1897 block->logical_bytenr); btrfsic_process_written_block() 1900 "Written block @%llu (%s/%llu/%d) found in hash table, %c.\n", btrfsic_process_written_block() 1902 dev_bytenr, block->mirror_num, btrfsic_process_written_block() 1904 block)); btrfsic_process_written_block() 1906 block->logical_bytenr = bytenr; btrfsic_process_written_block() 1915 bytenr = block->logical_bytenr; btrfsic_process_written_block() 1918 "Written block @%llu (%s/%llu/%d)" btrfsic_process_written_block() 1921 block->mirror_num, btrfsic_process_written_block() 1922 btrfsic_get_block_type(state, block)); btrfsic_process_written_block() 1928 list_empty(&block->ref_to_list) ? ' ' : '!', btrfsic_process_written_block() 1929 list_empty(&block->ref_from_list) ? ' ' : '!'); btrfsic_process_written_block() 1930 if (btrfsic_is_block_ref_by_superblock(state, block, 0)) { btrfsic_process_written_block() 1931 printk(KERN_INFO "btrfs: attempt to overwrite %c-block" btrfsic_process_written_block() 1937 btrfsic_get_block_type(state, block), bytenr, btrfsic_process_written_block() 1938 dev_state->name, dev_bytenr, block->mirror_num, btrfsic_process_written_block() 1939 block->generation, btrfsic_process_written_block() 1940 btrfs_disk_key_objectid(&block->disk_key), btrfsic_process_written_block() 1941 block->disk_key.type, btrfsic_process_written_block() 1942 btrfs_disk_key_offset(&block->disk_key), btrfsic_process_written_block() 1949 if (!block->is_iodone && !block->never_written) { btrfsic_process_written_block() 1950 printk(KERN_INFO "btrfs: attempt to overwrite %c-block" btrfsic_process_written_block() 1953 btrfsic_get_block_type(state, block), bytenr, btrfsic_process_written_block() 1954 dev_state->name, dev_bytenr, block->mirror_num, btrfsic_process_written_block() 1955 block->generation, btrfsic_process_written_block() 1965 * Clear all references of this block. Do not free btrfsic_process_written_block() 1966 * the block itself even if is not referenced anymore btrfsic_process_written_block() 1971 &block->ref_to_list) { btrfsic_process_written_block() 1997 block->never_written = 0; btrfsic_process_written_block() 1998 block->iodone_w_error = 0; btrfsic_process_written_block() 2000 block->is_iodone = 0; btrfsic_process_written_block() 2003 block->orig_bio_bh_private = btrfsic_process_written_block() 2005 block->orig_bio_bh_end_io.bio = btrfsic_process_written_block() 2007 block->next_in_same_bio = NULL; btrfsic_process_written_block() 2008 bio->bi_private = block; btrfsic_process_written_block() 2017 block->orig_bio_bh_private = btrfsic_process_written_block() 2019 block->orig_bio_bh_end_io.bio = btrfsic_process_written_block() 2022 block->next_in_same_bio = chained_block; btrfsic_process_written_block() 2023 bio->bi_private = block; btrfsic_process_written_block() 2026 block->is_iodone = 0; btrfsic_process_written_block() 2027 block->orig_bio_bh_private = bh->b_private; btrfsic_process_written_block() 2028 block->orig_bio_bh_end_io.bh = bh->b_end_io; btrfsic_process_written_block() 2029 block->next_in_same_bio = NULL; btrfsic_process_written_block() 2030 bh->b_private = block; btrfsic_process_written_block() 2033 block->is_iodone = 1; btrfsic_process_written_block() 2034 block->orig_bio_bh_private = NULL; btrfsic_process_written_block() 2035 block->orig_bio_bh_end_io.bio = NULL; btrfsic_process_written_block() 2036 block->next_in_same_bio = NULL; btrfsic_process_written_block() 2040 block->flush_gen = dev_state->last_flush_gen + 1; btrfsic_process_written_block() 2041 block->submit_bio_bh_rw = submit_bio_bh_rw; btrfsic_process_written_block() 2043 block->logical_bytenr = bytenr; btrfsic_process_written_block() 2044 block->is_metadata = 1; btrfsic_process_written_block() 2045 if (block->is_superblock) { btrfsic_process_written_block() 2050 block, btrfsic_process_written_block() 2057 btrfsic_dump_tree_sub(state, block, 0); btrfsic_process_written_block() 2060 block->mirror_num = 0; /* unknown */ btrfsic_process_written_block() 2063 block, btrfsic_process_written_block() 2073 block->is_metadata = 0; btrfsic_process_written_block() 2074 block->mirror_num = 0; /* unknown */ btrfsic_process_written_block() 2075 block->generation = BTRFSIC_GENERATION_UNKNOWN; btrfsic_process_written_block() 2077 && list_empty(&block->ref_from_list)) { btrfsic_process_written_block() 2079 * disk block is overwritten with extent btrfsic_process_written_block() 2082 * chance and free the block's memory btrfsic_process_written_block() 2084 btrfsic_block_hashtable_remove(block); btrfsic_process_written_block() 2085 list_del(&block->all_blocks_node); btrfsic_process_written_block() 2086 btrfsic_block_free(block); btrfsic_process_written_block() 2091 /* block has not been found in hash table */ btrfsic_process_written_block() 2097 printk(KERN_INFO "Written block (%s/%llu/?)" btrfsic_process_written_block() 2101 /* ignore that written D block */ btrfsic_process_written_block() 2117 "Written block @%llu (%s/%llu/?)" btrfsic_process_written_block() 2130 block = btrfsic_block_alloc(); btrfsic_process_written_block() 2131 if (NULL == block) { btrfsic_process_written_block() 2136 block->dev_state = dev_state; btrfsic_process_written_block() 2137 block->dev_bytenr = dev_bytenr; btrfsic_process_written_block() 2138 block->logical_bytenr = bytenr; btrfsic_process_written_block() 2139 block->is_metadata = is_metadata; btrfsic_process_written_block() 2140 block->never_written = 0; btrfsic_process_written_block() 2141 block->iodone_w_error = 0; btrfsic_process_written_block() 2142 block->mirror_num = 0; /* unknown */ btrfsic_process_written_block() 2143 block->flush_gen = dev_state->last_flush_gen + 1; btrfsic_process_written_block() 2144 block->submit_bio_bh_rw = submit_bio_bh_rw; btrfsic_process_written_block() 2146 block->is_iodone = 0; btrfsic_process_written_block() 2149 block->orig_bio_bh_private = bio->bi_private; btrfsic_process_written_block() 2150 block->orig_bio_bh_end_io.bio = bio->bi_end_io; btrfsic_process_written_block() 2151 block->next_in_same_bio = NULL; btrfsic_process_written_block() 2152 bio->bi_private = block; btrfsic_process_written_block() 2161 block->orig_bio_bh_private = btrfsic_process_written_block() 2163 block->orig_bio_bh_end_io.bio = btrfsic_process_written_block() 2165 block->next_in_same_bio = chained_block; btrfsic_process_written_block() 2166 bio->bi_private = block; btrfsic_process_written_block() 2169 block->is_iodone = 0; btrfsic_process_written_block() 2170 block->orig_bio_bh_private = bh->b_private; btrfsic_process_written_block() 2171 block->orig_bio_bh_end_io.bh = bh->b_end_io; btrfsic_process_written_block() 2172 block->next_in_same_bio = NULL; btrfsic_process_written_block() 2173 bh->b_private = block; btrfsic_process_written_block() 2176 block->is_iodone = 1; btrfsic_process_written_block() 2177 block->orig_bio_bh_private = NULL; btrfsic_process_written_block() 2178 block->orig_bio_bh_end_io.bio = NULL; btrfsic_process_written_block() 2179 block->next_in_same_bio = NULL; btrfsic_process_written_block() 2183 "New written %c-block @%llu (%s/%llu/%d)\n", btrfsic_process_written_block() 2185 block->logical_bytenr, block->dev_state->name, btrfsic_process_written_block() 2186 block->dev_bytenr, block->mirror_num); btrfsic_process_written_block() 2187 list_add(&block->all_blocks_node, &state->all_blocks_list); btrfsic_process_written_block() 2188 btrfsic_block_hashtable_add(block, &state->block_hashtable); btrfsic_process_written_block() 2191 ret = btrfsic_process_metablock(state, block, btrfsic_process_written_block() 2212 struct btrfsic_block *block = (struct btrfsic_block *)bp->bi_private; btrfsic_bio_end_io() local 2221 BUG_ON(NULL == block); btrfsic_bio_end_io() 2222 bp->bi_private = block->orig_bio_bh_private; btrfsic_bio_end_io() 2223 bp->bi_end_io = block->orig_bio_bh_end_io.bio; btrfsic_bio_end_io() 2227 struct btrfsic_dev_state *const dev_state = block->dev_state; btrfsic_bio_end_io() 2234 btrfsic_get_block_type(dev_state->state, block), btrfsic_bio_end_io() 2235 block->logical_bytenr, dev_state->name, btrfsic_bio_end_io() 2236 block->dev_bytenr, block->mirror_num); btrfsic_bio_end_io() 2237 next_block = block->next_in_same_bio; btrfsic_bio_end_io() 2238 block->iodone_w_error = iodone_w_error; btrfsic_bio_end_io() 2239 if (block->submit_bio_bh_rw & REQ_FLUSH) { btrfsic_bio_end_io() 2248 if (block->submit_bio_bh_rw & REQ_FUA) btrfsic_bio_end_io() 2249 block->flush_gen = 0; /* FUA completed means block is btrfsic_bio_end_io() 2251 block->is_iodone = 1; /* for FLUSH, this releases the block */ btrfsic_bio_end_io() 2252 block = next_block; btrfsic_bio_end_io() 2253 } while (NULL != block); btrfsic_bio_end_io() 2260 struct btrfsic_block *block = (struct btrfsic_block *)bh->b_private; btrfsic_bh_end_io() local 2264 BUG_ON(NULL == block); btrfsic_bh_end_io() 2265 dev_state = block->dev_state; btrfsic_bh_end_io() 2270 btrfsic_get_block_type(dev_state->state, block), btrfsic_bh_end_io() 2271 block->logical_bytenr, block->dev_state->name, btrfsic_bh_end_io() 2272 block->dev_bytenr, block->mirror_num); btrfsic_bh_end_io() 2274 block->iodone_w_error = iodone_w_error; btrfsic_bh_end_io() 2275 if (block->submit_bio_bh_rw & REQ_FLUSH) { btrfsic_bh_end_io() 2283 if (block->submit_bio_bh_rw & REQ_FUA) btrfsic_bh_end_io() 2284 block->flush_gen = 0; /* FUA completed means block is on disk */ btrfsic_bh_end_io() 2286 bh->b_private = block->orig_bio_bh_private; btrfsic_bh_end_io() 2287 bh->b_end_io = block->orig_bio_bh_end_io.bh; btrfsic_bh_end_io() 2288 block->is_iodone = 1; /* for FLUSH, this releases the block */ btrfsic_bh_end_io() 2436 struct btrfsic_block *const block, btrfsic_check_all_ref_blocks() 2448 * block free operations, it just recognizes block btrfsic_check_all_ref_blocks() 2450 * information for a block until a block is btrfsic_check_all_ref_blocks() 2454 * by the most recent super block. btrfsic_check_all_ref_blocks() 2467 list_for_each(elem_ref_to, &block->ref_to_list) { btrfsic_check_all_ref_blocks() 2477 btrfsic_get_block_type(state, block), btrfsic_check_all_ref_blocks() 2478 block->logical_bytenr, block->dev_state->name, btrfsic_check_all_ref_blocks() 2479 block->dev_bytenr, block->mirror_num, btrfsic_check_all_ref_blocks() 2488 " which references block %c @%llu (%s/%llu/%d)" btrfsic_check_all_ref_blocks() 2498 " which references block %c @%llu (%s/%llu/%d)" btrfsic_check_all_ref_blocks() 2508 " which references block %c @%llu (%s/%llu/%d)" btrfsic_check_all_ref_blocks() 2523 " which references block %c @%llu (%s/%llu/%d)" btrfsic_check_all_ref_blocks() 2537 " which references block %c @%llu (%s/%llu/%d)" btrfsic_check_all_ref_blocks() 2539 " (block flush_gen=%llu," btrfsic_check_all_ref_blocks() 2545 l->block_ref_to->mirror_num, block->flush_gen, btrfsic_check_all_ref_blocks() 2561 const struct btrfsic_block *block, btrfsic_is_block_ref_by_superblock() 2579 list_for_each(elem_ref_from, &block->ref_from_list) { btrfsic_is_block_ref_by_superblock() 2589 btrfsic_get_block_type(state, block), btrfsic_is_block_ref_by_superblock() 2590 block->logical_bytenr, block->dev_state->name, btrfsic_is_block_ref_by_superblock() 2591 block->dev_bytenr, block->mirror_num, btrfsic_is_block_ref_by_superblock() 2649 const struct btrfsic_block *block) btrfsic_get_block_type() 2651 if (block->is_superblock && btrfsic_get_block_type() 2652 state->latest_superblock->dev_bytenr == block->dev_bytenr && btrfsic_get_block_type() 2653 state->latest_superblock->dev_state->bdev == block->dev_state->bdev) btrfsic_get_block_type() 2655 else if (block->is_superblock) btrfsic_get_block_type() 2657 else if (block->is_metadata) btrfsic_get_block_type() 2669 const struct btrfsic_block *block, btrfsic_dump_tree_sub() 2687 btrfsic_get_block_type(state, block), btrfsic_dump_tree_sub() 2688 block->logical_bytenr, block->dev_state->name, btrfsic_dump_tree_sub() 2689 block->dev_bytenr, block->mirror_num); btrfsic_dump_tree_sub() 2696 if (list_empty(&block->ref_to_list)) { btrfsic_dump_tree_sub() 2700 if (block->mirror_num > 1 && btrfsic_dump_tree_sub() 2707 list_for_each(elem_ref_to, &block->ref_to_list) { btrfsic_dump_tree_sub() 2790 struct btrfsic_block *block; btrfsic_block_lookup_or_add() local 2792 block = btrfsic_block_hashtable_lookup(block_ctx->dev->bdev, btrfsic_block_lookup_or_add() 2795 if (NULL == block) { btrfsic_block_lookup_or_add() 2798 block = btrfsic_block_alloc(); btrfsic_block_lookup_or_add() 2799 if (NULL == block) { btrfsic_block_lookup_or_add() 2807 btrfsic_block_free(block); btrfsic_block_lookup_or_add() 2810 block->dev_state = dev_state; btrfsic_block_lookup_or_add() 2811 block->dev_bytenr = block_ctx->dev_bytenr; btrfsic_block_lookup_or_add() 2812 block->logical_bytenr = block_ctx->start; btrfsic_block_lookup_or_add() 2813 block->is_metadata = is_metadata; btrfsic_block_lookup_or_add() 2814 block->is_iodone = is_iodone; btrfsic_block_lookup_or_add() 2815 block->never_written = never_written; btrfsic_block_lookup_or_add() 2816 block->mirror_num = mirror_num; btrfsic_block_lookup_or_add() 2819 "New %s%c-block @%llu (%s/%llu/%d)\n", btrfsic_block_lookup_or_add() 2821 btrfsic_get_block_type(state, block), btrfsic_block_lookup_or_add() 2822 block->logical_bytenr, dev_state->name, btrfsic_block_lookup_or_add() 2823 block->dev_bytenr, mirror_num); btrfsic_block_lookup_or_add() 2824 list_add(&block->all_blocks_node, &state->all_blocks_list); btrfsic_block_lookup_or_add() 2825 btrfsic_block_hashtable_add(block, &state->block_hashtable); btrfsic_block_lookup_or_add() 2833 return block; btrfsic_block_lookup_or_add() 2871 printk(KERN_INFO "btrfs: attempt to write M-block which contains logical bytenr that doesn't map to dev+physical bytenr of submit_bio," btrfsic_cmp_log_and_dev_bytenr() 2940 " but dummy block already in use" btrfsic_submit_bh() 2944 struct btrfsic_block *const block = btrfsic_submit_bh() local 2947 block->is_iodone = 0; btrfsic_submit_bh() 2948 block->never_written = 0; btrfsic_submit_bh() 2949 block->iodone_w_error = 0; btrfsic_submit_bh() 2950 block->flush_gen = dev_state->last_flush_gen + 1; btrfsic_submit_bh() 2951 block->submit_bio_bh_rw = rw; btrfsic_submit_bh() 2952 block->orig_bio_bh_private = bh->b_private; btrfsic_submit_bh() 2953 block->orig_bio_bh_end_io.bh = bh->b_end_io; btrfsic_submit_bh() 2954 block->next_in_same_bio = NULL; btrfsic_submit_bh() 2955 bh->b_private = block; btrfsic_submit_bh() 3038 " but dummy block already in use" __btrfsic_submit_bio() 3042 struct btrfsic_block *const block = __btrfsic_submit_bio() local 3045 block->is_iodone = 0; __btrfsic_submit_bio() 3046 block->never_written = 0; __btrfsic_submit_bio() 3047 block->iodone_w_error = 0; __btrfsic_submit_bio() 3048 block->flush_gen = dev_state->last_flush_gen + 1; __btrfsic_submit_bio() 3049 block->submit_bio_bh_rw = rw; __btrfsic_submit_bio() 3050 block->orig_bio_bh_private = bio->bi_private; __btrfsic_submit_bio() 3051 block->orig_bio_bh_end_io.bio = bio->bi_end_io; __btrfsic_submit_bio() 3052 block->next_in_same_bio = NULL; __btrfsic_submit_bio() 3053 bio->bi_private = block; __btrfsic_submit_bio() 3234 printk(KERN_INFO "btrfs: attempt to free %c-block" 1263 btrfsic_create_link_to_next_block( struct btrfsic_state *state, struct btrfsic_block *block, struct btrfsic_block_data_ctx *block_ctx, u64 next_bytenr, int limit_nesting, struct btrfsic_block_data_ctx *next_block_ctx, struct btrfsic_block **next_blockp, int force_iodone_flag, int *num_copiesp, int *mirror_nump, struct btrfs_disk_key *disk_key, u64 parent_generation) btrfsic_create_link_to_next_block() argument 1411 btrfsic_handle_extent_data( struct btrfsic_state *state, struct btrfsic_block *block, struct btrfsic_block_data_ctx *block_ctx, u32 item_offset, int force_iodone_flag) btrfsic_handle_extent_data() argument 2435 btrfsic_check_all_ref_blocks(struct btrfsic_state *state, struct btrfsic_block *const block, int recursion_level) btrfsic_check_all_ref_blocks() argument 2559 btrfsic_is_block_ref_by_superblock( const struct btrfsic_state *state, const struct btrfsic_block *block, int recursion_level) btrfsic_is_block_ref_by_superblock() argument 2648 btrfsic_get_block_type(const struct btrfsic_state *state, const struct btrfsic_block *block) btrfsic_get_block_type() argument 2668 btrfsic_dump_tree_sub(const struct btrfsic_state *state, const struct btrfsic_block *block, int indent_level) btrfsic_dump_tree_sub() argument
|
/linux-4.1.27/fs/freevxfs/ |
H A D | vxfs_subr.c | 90 * vxfs_bread - read buffer for a give inode,block tuple 92 * @block: logical block 95 * The vxfs_bread function reads block no @block of 102 vxfs_bread(struct inode *ip, int block) vxfs_bread() argument 107 pblock = vxfs_bmap1(ip, block); vxfs_bread() 114 * vxfs_get_block - locate buffer for given inode,block tuple 116 * @iblock: logical block 122 * block and device number to perform a lowlevel read/write on 165 * vxfs_bmap - perform logical to physical block mapping 167 * @block: logical block (relative to @mapping). 170 * Vxfs_bmap find out the corresponding phsical block to the 171 * @mapping, @block pair. 174 * Physical block number on success, else Zero. 180 vxfs_bmap(struct address_space *mapping, sector_t block) vxfs_bmap() argument 182 return generic_block_bmap(mapping, block, vxfs_getblk); vxfs_bmap()
|
H A D | vxfs_bmap.c | 31 * Veritas filesystem driver - filesystem to disk block mapping. 48 printk("block=%x ", typ->vt_block); vxfs_typdump() 56 * @iblock: logical block. 64 * The physical block number on success, else Zero. 113 * @indir: indirect block we start reading at 115 * @block: partially result from further searches 122 * The physical block number on success, else Zero. 128 vxfs_bmap_indir(struct inode *ip, long indir, int size, long block) vxfs_bmap_indir() argument 147 if (block < off) { vxfs_bmap_indir() 155 typ->vt_size, block - off); vxfs_bmap_indir() 160 if ((block - off) >= typ->vt_size) vxfs_bmap_indir() 162 pblock = (typ->vt_block + block - off); vxfs_bmap_indir() 170 printk(KERN_INFO "block: %Lu\tsize: %Ld\tdev: %d\n", vxfs_bmap_indir() 192 * @iblock: logical block 198 * The physical block number on success, else Zero. 233 printk(KERN_INFO "block: %Lu\tsize: %Ld\tdev: %d\n", vxfs_bmap_typed() 250 * @iblock: logical block 253 * vxfs_bmap1 perfoms a logical to physical block mapping 257 * The physical block number on success, else Zero.
|
H A D | vxfs_lookup.c | 116 u_long npages, page, nblocks, pblocks, block; vxfs_find_entry() local 134 for (block = 0; block <= nblocks && block <= pblocks; block++) { vxfs_find_entry() 139 baddr = kaddr + (block * bsize); vxfs_find_entry() 243 u_long page, npages, block, pblocks, nblocks, offset; vxfs_readdir() local 267 block = (u_long)(pos >> sbp->s_blocksize_bits) % pblocks; vxfs_readdir() 269 for (; page < npages; page++, block = 0) { vxfs_readdir() 278 for (; block <= nblocks && block <= pblocks; block++) { vxfs_readdir() 283 baddr = kaddr + (block * bsize); vxfs_readdir()
|
/linux-4.1.27/fs/omfs/ |
H A D | omfs.h | 28 /* convert a cluster number to a scaled block number */ clus_to_blk() 29 static inline sector_t clus_to_blk(struct omfs_sb_info *sbi, sector_t block) clus_to_blk() argument 31 return block << sbi->s_block_shift; clus_to_blk() 41 extern int omfs_allocate_block(struct super_block *sb, u64 block); 44 extern int omfs_clear_range(struct super_block *sb, u64 block, int count); 61 extern struct buffer_head *omfs_bread(struct super_block *sb, sector_t block); 64 extern int omfs_reserve_block(struct super_block *sb, sector_t block);
|
H A D | omfs_fs.h | 25 __be64 s_root_block; /* block number of omfs_root_block */ 28 __be32 s_blocksize; /* size of a block */ 34 __be64 h_self; /* FS block where this is located */ 49 __be64 r_root_dir; /* block # of root directory */ 50 __be64 r_bitmap; /* block # of free space bitmap */ 51 __be32 r_blocksize; /* size of a block */
|
H A D | file.c | 141 /* trivially grow current extent, if next block is not taken */ omfs_grow_extent() 157 /* TODO: add a continuation block here */ omfs_grow_extent() 188 * Scans across the directory table for a given file block number. 189 * If block not found, return 0. 192 sector_t block, int count, int *left) find_block() 200 if (block >= searched && find_block() 201 block < searched + numblocks) { find_block() 203 * found it at cluster + (block - searched) find_block() 204 * numblocks - (block - searched) is remainder find_block() 206 *left = numblocks - (block - searched); find_block() 209 block - searched; find_block() 217 static int omfs_get_block(struct inode *inode, sector_t block, omfs_get_block() argument 253 offset = find_block(inode, entry, block, extent_count, &remain); omfs_get_block() 333 static sector_t omfs_bmap(struct address_space *mapping, sector_t block) omfs_bmap() argument 335 return generic_block_bmap(mapping, block, omfs_get_block); omfs_bmap() 191 find_block(struct inode *inode, struct omfs_extent_entry *ent, sector_t block, int count, int *left) find_block() argument
|
H A D | dir.c | 21 * Finds the bucket for a given name and reads the containing block; 34 static struct buffer_head *omfs_scan_list(struct inode *dir, u64 block, omfs_scan_list() argument 43 while (block != ~0) { omfs_scan_list() 44 bh = omfs_bread(dir->i_sb, block); omfs_scan_list() 51 if (omfs_is_bad(OMFS_SB(dir->i_sb), &oi->i_head, block)) { omfs_scan_list() 59 *prev_block = block; omfs_scan_list() 60 block = be64_to_cpu(oi->i_sibling); omfs_scan_list() 72 u64 block, dummy; omfs_find_entry() local 78 block = be64_to_cpu(*((__be64 *) &bh->b_data[ofs])); omfs_find_entry() 81 return omfs_scan_list(dir, block, name, namelen, &dummy); omfs_find_entry() 118 u64 block; omfs_add_link() local 128 block = be64_to_cpu(*entry); omfs_add_link() 141 oi->i_sibling = cpu_to_be64(block); omfs_add_link() 165 u64 block, prev; omfs_delete_entry() local 175 block = be64_to_cpu(*entry); omfs_delete_entry() 177 bh2 = omfs_scan_list(dir, block, name, namelen, &prev); omfs_delete_entry() 315 /* sanity check block's self pointer */ omfs_is_bad()
|
/linux-4.1.27/fs/xfs/libxfs/ |
H A D | xfs_alloc_btree.h | 30 * Btree block header size depends on a superblock flag. 41 #define XFS_ALLOC_REC_ADDR(mp, block, index) \ 43 ((char *)(block) + \ 47 #define XFS_ALLOC_KEY_ADDR(mp, block, index) \ 49 ((char *)(block) + \ 53 #define XFS_ALLOC_PTR_ADDR(mp, block, index, maxrecs) \ 55 ((char *)(block) + \
|
H A D | xfs_ialloc_btree.h | 30 * Btree block header size depends on a superblock flag. 41 #define XFS_INOBT_REC_ADDR(mp, block, index) \ 43 ((char *)(block) + \ 47 #define XFS_INOBT_KEY_ADDR(mp, block, index) \ 49 ((char *)(block) + \ 53 #define XFS_INOBT_PTR_ADDR(mp, block, index, maxrecs) \ 55 ((char *)(block) + \
|
H A D | xfs_btree.c | 57 struct xfs_btree_block *block, /* btree long form block pointer */ xfs_btree_check_lblock() 58 int level, /* level of the btree block */ xfs_btree_check_lblock() 59 struct xfs_buf *bp) /* buffer for block, if any */ xfs_btree_check_lblock() 61 int lblock_ok = 1; /* block passes checks */ xfs_btree_check_lblock() 68 uuid_equal(&block->bb_u.l.bb_uuid, &mp->m_sb.sb_uuid) && xfs_btree_check_lblock() 69 block->bb_u.l.bb_blkno == cpu_to_be64( xfs_btree_check_lblock() 74 be32_to_cpu(block->bb_magic) == xfs_btree_magic(cur) && xfs_btree_check_lblock() 75 be16_to_cpu(block->bb_level) == level && xfs_btree_check_lblock() 76 be16_to_cpu(block->bb_numrecs) <= xfs_btree_check_lblock() 78 block->bb_u.l.bb_leftsib && xfs_btree_check_lblock() 79 (block->bb_u.l.bb_leftsib == cpu_to_be64(NULLFSBLOCK) || xfs_btree_check_lblock() 81 be64_to_cpu(block->bb_u.l.bb_leftsib))) && xfs_btree_check_lblock() 82 block->bb_u.l.bb_rightsib && xfs_btree_check_lblock() 83 (block->bb_u.l.bb_rightsib == cpu_to_be64(NULLFSBLOCK) || xfs_btree_check_lblock() 85 be64_to_cpu(block->bb_u.l.bb_rightsib))); xfs_btree_check_lblock() 101 struct xfs_btree_block *block, /* btree short form block pointer */ xfs_btree_check_sblock() 102 int level, /* level of the btree block */ xfs_btree_check_sblock() 103 struct xfs_buf *bp) /* buffer containing block */ xfs_btree_check_sblock() 109 int sblock_ok = 1; /* block passes checks */ xfs_btree_check_sblock() 118 uuid_equal(&block->bb_u.s.bb_uuid, &mp->m_sb.sb_uuid) && xfs_btree_check_sblock() 119 block->bb_u.s.bb_blkno == cpu_to_be64( xfs_btree_check_sblock() 124 be32_to_cpu(block->bb_magic) == xfs_btree_magic(cur) && xfs_btree_check_sblock() 125 be16_to_cpu(block->bb_level) == level && xfs_btree_check_sblock() 126 be16_to_cpu(block->bb_numrecs) <= xfs_btree_check_sblock() 128 (block->bb_u.s.bb_leftsib == cpu_to_be32(NULLAGBLOCK) || xfs_btree_check_sblock() 129 be32_to_cpu(block->bb_u.s.bb_leftsib) < agflen) && xfs_btree_check_sblock() 130 block->bb_u.s.bb_leftsib && xfs_btree_check_sblock() 131 (block->bb_u.s.bb_rightsib == cpu_to_be32(NULLAGBLOCK) || xfs_btree_check_sblock() 132 be32_to_cpu(block->bb_u.s.bb_rightsib) < agflen) && xfs_btree_check_sblock() 133 block->bb_u.s.bb_rightsib; xfs_btree_check_sblock() 147 * Debug routine: check that block header is ok. 152 struct xfs_btree_block *block, /* generic btree block pointer */ xfs_btree_check_block() 153 int level, /* level of the btree block */ xfs_btree_check_block() 154 struct xfs_buf *bp) /* buffer containing block, if any */ xfs_btree_check_block() 157 return xfs_btree_check_lblock(cur, block, level, bp); xfs_btree_check_block() 159 return xfs_btree_check_sblock(cur, block, level, bp); xfs_btree_check_block() 168 xfs_fsblock_t bno, /* btree block disk address */ xfs_btree_check_lptr() 169 int level) /* btree block level */ xfs_btree_check_lptr() 185 xfs_agblock_t bno, /* btree block disk address */ xfs_btree_check_sptr() 186 int level) /* btree block level */ xfs_btree_check_sptr() 199 * Check that block ptr is ok. 204 union xfs_btree_ptr *ptr, /* btree block disk address */ xfs_btree_check_ptr() 206 int level) /* btree block level */ xfs_btree_check_ptr() 219 * Calculate CRC on the whole btree block and stuff it into the 230 struct xfs_btree_block *block = XFS_BUF_TO_BLOCK(bp); xfs_btree_lblock_calc_crc() local 236 block->bb_u.l.bb_lsn = cpu_to_be64(bip->bli_item.li_lsn); xfs_btree_lblock_calc_crc() 251 * Calculate CRC on the whole btree block and stuff it into the 262 struct xfs_btree_block *block = XFS_BUF_TO_BLOCK(bp); xfs_btree_sblock_calc_crc() local 268 block->bb_u.s.bb_lsn = cpu_to_be64(bip->bli_item.li_lsn); xfs_btree_sblock_calc_crc() 329 xfs_buf_t *bp; /* btree block's buffer pointer */ xfs_btree_dup_cursor() 331 int i; /* level number of btree block */ xfs_btree_dup_cursor() 374 * XFS btree block layout and addressing: 379 * the values. A non-leaf block also starts with the same header, and 392 * and comes in different versions for short (32bit) and long (64bit) block 394 * and opaque to the btree core. The block pointers are simple disk endian 398 * into a btree block (xfs_btree_*_offset) or return a pointer to the given 400 * inside the btree block is done using indices starting at one, not zero! 404 * Return size of the btree block header for this btree instance. 419 * Return size of btree block pointers for this btree instance. 428 * Calculate offset of the n-th record in a btree block. 440 * Calculate offset of the n-th key in a btree block. 452 * Calculate offset of the n-th block pointer in a btree block. 466 * Return a pointer to the n-th record in the btree block. 472 struct xfs_btree_block *block) xfs_btree_rec_addr() 475 ((char *)block + xfs_btree_rec_offset(cur, n)); xfs_btree_rec_addr() 479 * Return a pointer to the n-th key in the btree block. 485 struct xfs_btree_block *block) xfs_btree_key_addr() 488 ((char *)block + xfs_btree_key_offset(cur, n)); xfs_btree_key_addr() 492 * Return a pointer to the n-th block pointer in the btree block. 498 struct xfs_btree_block *block) xfs_btree_ptr_addr() 500 int level = xfs_btree_get_level(block); xfs_btree_ptr_addr() 502 ASSERT(block->bb_level != 0); xfs_btree_ptr_addr() 505 ((char *)block + xfs_btree_ptr_offset(cur, n, level)); xfs_btree_ptr_addr() 509 * Get the root block which is stored in the inode. 525 * Retrieve the block pointer from the cursor at the given level. 528 STATIC struct xfs_btree_block * /* generic btree block pointer */ xfs_btree_get_block() 532 struct xfs_buf **bpp) /* buffer containing the block */ xfs_btree_get_block() 545 * Get a buffer for the block, return it with no data read. 552 xfs_fsblock_t fsbno, /* file system block number */ xfs_btree_get_bufl() 555 xfs_daddr_t d; /* real disk block address */ xfs_btree_get_bufl() 563 * Get a buffer for the block, return it with no data read. 571 xfs_agblock_t agbno, /* allocation group block number */ xfs_btree_get_bufs() 574 xfs_daddr_t d; /* real disk block address */ xfs_btree_get_bufs() 583 * Check for the cursor referring to the last block at the given level. 585 int /* 1=is last block, 0=not last block */ xfs_btree_islastblock() 590 struct xfs_btree_block *block; /* generic btree block pointer */ xfs_btree_islastblock() local 591 xfs_buf_t *bp; /* buffer containing block */ xfs_btree_islastblock() 593 block = xfs_btree_get_block(cur, level, &bp); xfs_btree_islastblock() 594 xfs_btree_check_block(cur, block, level, bp); xfs_btree_islastblock() 596 return block->bb_u.l.bb_rightsib == cpu_to_be64(NULLFSBLOCK); xfs_btree_islastblock() 598 return block->bb_u.s.bb_rightsib == cpu_to_be32(NULLAGBLOCK); xfs_btree_islastblock() 610 struct xfs_btree_block *block; /* generic btree block pointer */ xfs_btree_firstrec() local 611 xfs_buf_t *bp; /* buffer containing block */ xfs_btree_firstrec() 614 * Get the block pointer for this level. xfs_btree_firstrec() 616 block = xfs_btree_get_block(cur, level, &bp); xfs_btree_firstrec() 617 xfs_btree_check_block(cur, block, level, bp); xfs_btree_firstrec() 621 if (!block->bb_numrecs) xfs_btree_firstrec() 631 * Change the cursor to point to the last record in the current block 639 struct xfs_btree_block *block; /* generic btree block pointer */ xfs_btree_lastrec() local 640 xfs_buf_t *bp; /* buffer containing block */ xfs_btree_lastrec() 643 * Get the block pointer for this level. xfs_btree_lastrec() 645 block = xfs_btree_get_block(cur, level, &bp); xfs_btree_lastrec() 646 xfs_btree_check_block(cur, block, level, bp); xfs_btree_lastrec() 650 if (!block->bb_numrecs) xfs_btree_lastrec() 655 cur->bc_ptrs[level] = be16_to_cpu(block->bb_numrecs); xfs_btree_lastrec() 696 * Get a buffer for the block, return it read in. 703 xfs_fsblock_t fsbno, /* file system block number */ xfs_btree_read_bufl() 710 xfs_daddr_t d; /* real disk block address */ xfs_btree_read_bufl() 726 * Read-ahead the block, don't wait for it, don't return a buffer. 733 xfs_fsblock_t fsbno, /* file system block number */ xfs_btree_reada_bufl() 745 * Read-ahead the block, don't wait for it, don't return a buffer. 753 xfs_agblock_t agbno, /* allocation group block number */ xfs_btree_reada_bufs() 769 struct xfs_btree_block *block) xfs_btree_readahead_lblock() 772 xfs_fsblock_t left = be64_to_cpu(block->bb_u.l.bb_leftsib); xfs_btree_readahead_lblock() 773 xfs_fsblock_t right = be64_to_cpu(block->bb_u.l.bb_rightsib); xfs_btree_readahead_lblock() 794 struct xfs_btree_block *block) xfs_btree_readahead_sblock() 797 xfs_agblock_t left = be32_to_cpu(block->bb_u.s.bb_leftsib); xfs_btree_readahead_sblock() 798 xfs_agblock_t right = be32_to_cpu(block->bb_u.s.bb_rightsib); xfs_btree_readahead_sblock() 826 struct xfs_btree_block *block; xfs_btree_readahead() local 840 block = XFS_BUF_TO_BLOCK(cur->bc_bufs[lev]); xfs_btree_readahead() 843 return xfs_btree_readahead_lblock(cur, lr, block); xfs_btree_readahead() 844 return xfs_btree_readahead_sblock(cur, lr, block); xfs_btree_readahead() 892 struct xfs_btree_block *b; /* btree block */ xfs_btree_setbuf() 941 struct xfs_btree_block *block, xfs_btree_get_sibling() 949 ptr->l = block->bb_u.l.bb_rightsib; xfs_btree_get_sibling() 951 ptr->l = block->bb_u.l.bb_leftsib; xfs_btree_get_sibling() 954 ptr->s = block->bb_u.s.bb_rightsib; xfs_btree_get_sibling() 956 ptr->s = block->bb_u.s.bb_leftsib; xfs_btree_get_sibling() 963 struct xfs_btree_block *block, xfs_btree_set_sibling() 971 block->bb_u.l.bb_rightsib = ptr->l; xfs_btree_set_sibling() 973 block->bb_u.l.bb_leftsib = ptr->l; xfs_btree_set_sibling() 976 block->bb_u.s.bb_rightsib = ptr->s; xfs_btree_set_sibling() 978 block->bb_u.s.bb_leftsib = ptr->s; xfs_btree_set_sibling() 1069 struct xfs_btree_block *block, xfs_btree_is_lastrec() 1079 xfs_btree_get_sibling(cur, block, &ptr, XFS_BB_RIGHTSIB); xfs_btree_is_lastrec() 1127 struct xfs_btree_block **block, xfs_btree_get_buf_block() 1144 *block = XFS_BUF_TO_BLOCK(*bpp); xfs_btree_get_buf_block() 1150 * the block pointer within the buffer. 1157 struct xfs_btree_block **block, xfs_btree_read_buf_block() 1175 *block = XFS_BUF_TO_BLOCK(*bpp); xfs_btree_read_buf_block() 1180 * Copy keys from one btree block to another. 1194 * Copy records from one btree block to another. 1208 * Copy block pointers from one btree block to another. 1222 * Shift keys one index left/right inside a single btree block. 1241 * Shift records one index left/right inside a single btree block. 1260 * Shift block pointers one index left/right inside a single btree block. 1279 * Log key values from the btree block. 1305 * Log record values from the btree block. 1326 * Log block pointer fields from a btree block (nonleaf). 1331 struct xfs_buf *bp, /* buffer containing btree block */ xfs_btree_log_ptrs() 1339 struct xfs_btree_block *block = XFS_BUF_TO_BLOCK(bp); xfs_btree_log_ptrs() local 1340 int level = xfs_btree_get_level(block); xfs_btree_log_ptrs() 1355 * Log fields from a btree block header. 1360 struct xfs_buf *bp, /* buffer containing btree block */ xfs_btree_log_block() 1402 * block but instead recreate it during log xfs_btree_log_block() 1437 struct xfs_btree_block *block; xfs_btree_increment() local 1451 /* Get a pointer to the btree block. */ xfs_btree_increment() 1452 block = xfs_btree_get_block(cur, level, &bp); xfs_btree_increment() 1455 error = xfs_btree_check_block(cur, block, level, bp); xfs_btree_increment() 1460 /* We're done if we remain in the block after the increment. */ xfs_btree_increment() 1461 if (++cur->bc_ptrs[level] <= xfs_btree_get_numrecs(block)) xfs_btree_increment() 1465 xfs_btree_get_sibling(cur, block, &ptr, XFS_BB_RIGHTSIB); xfs_btree_increment() 1473 * Stop when we don't go off the right edge of a block. xfs_btree_increment() 1476 block = xfs_btree_get_block(cur, lev, &bp); xfs_btree_increment() 1479 error = xfs_btree_check_block(cur, block, lev, bp); xfs_btree_increment() 1484 if (++cur->bc_ptrs[lev] <= xfs_btree_get_numrecs(block)) xfs_btree_increment() 1487 /* Read-ahead the right block for the next loop. */ xfs_btree_increment() 1508 for (block = xfs_btree_get_block(cur, lev, &bp); lev > level; ) { xfs_btree_increment() 1511 ptrp = xfs_btree_ptr_addr(cur, cur->bc_ptrs[lev], block); xfs_btree_increment() 1513 error = xfs_btree_read_buf_block(cur, ptrp, 0, &block, &bp); xfs_btree_increment() 1545 struct xfs_btree_block *block; xfs_btree_decrement() local 1559 /* We're done if we remain in the block after the decrement. */ xfs_btree_decrement() 1563 /* Get a pointer to the btree block. */ xfs_btree_decrement() 1564 block = xfs_btree_get_block(cur, level, &bp); xfs_btree_decrement() 1567 error = xfs_btree_check_block(cur, block, level, bp); xfs_btree_decrement() 1573 xfs_btree_get_sibling(cur, block, &ptr, XFS_BB_LEFTSIB); xfs_btree_decrement() 1581 * Stop when we don't go off the left edge of a block. xfs_btree_decrement() 1586 /* Read-ahead the left block for the next loop. */ xfs_btree_decrement() 1607 for (block = xfs_btree_get_block(cur, lev, &bp); lev > level; ) { xfs_btree_decrement() 1610 ptrp = xfs_btree_ptr_addr(cur, cur->bc_ptrs[lev], block); xfs_btree_decrement() 1612 error = xfs_btree_read_buf_block(cur, ptrp, 0, &block, &bp); xfs_btree_decrement() 1616 cur->bc_ptrs[lev] = xfs_btree_get_numrecs(block); xfs_btree_decrement() 1637 union xfs_btree_ptr *pp, /* ptr to btree block */ xfs_btree_lookup_get_block() 1638 struct xfs_btree_block **blkp) /* return btree block */ xfs_btree_lookup_get_block() 1640 struct xfs_buf *bp; /* buffer pointer for btree block */ xfs_btree_lookup_get_block() 1643 /* special case the root block if in an inode */ xfs_btree_lookup_get_block() 1680 struct xfs_btree_block *block, xfs_lookup_get_search_key() 1685 xfs_btree_rec_addr(cur, keyno, block)); xfs_lookup_get_search_key() 1689 return xfs_btree_key_addr(cur, keyno, block); xfs_lookup_get_search_key() 1702 struct xfs_btree_block *block; /* current btree block */ xfs_btree_lookup() local 1707 union xfs_btree_ptr *pp; /* ptr to btree block */ xfs_btree_lookup() 1708 union xfs_btree_ptr ptr; /* ptr to btree block */ xfs_btree_lookup() 1715 block = NULL; xfs_btree_lookup() 1725 * on the lookup record, then follow the corresponding block xfs_btree_lookup() 1729 /* Get the block we need to do the lookup on. */ xfs_btree_lookup() 1730 error = xfs_btree_lookup_get_block(cur, level, pp, &block); xfs_btree_lookup() 1737 * know we need to use the first entry in this block. xfs_btree_lookup() 1741 /* Otherwise search this block. Do a binary search. */ xfs_btree_lookup() 1748 high = xfs_btree_get_numrecs(block); xfs_btree_lookup() 1759 /* Binary search the block. */ xfs_btree_lookup() 1771 keyno, block, &key); xfs_btree_lookup() 1791 * by getting the block number and filling in the cursor. xfs_btree_lookup() 1800 pp = xfs_btree_ptr_addr(cur, keyno, block); xfs_btree_lookup() 1815 * If ge search and we went off the end of the block, but it's xfs_btree_lookup() 1816 * not the last block, we're in the wrong block. xfs_btree_lookup() 1818 xfs_btree_get_sibling(cur, block, &ptr, XFS_BB_RIGHTSIB); xfs_btree_lookup() 1820 keyno > xfs_btree_get_numrecs(block) && xfs_btree_lookup() 1838 if (keyno == 0 || keyno > xfs_btree_get_numrecs(block)) xfs_btree_lookup() 1861 struct xfs_btree_block *block; xfs_btree_updkey() local 1875 * at the first entry in the block. xfs_btree_updkey() 1881 block = xfs_btree_get_block(cur, level, &bp); xfs_btree_updkey() 1883 error = xfs_btree_check_block(cur, block, level, bp); xfs_btree_updkey() 1890 kp = xfs_btree_key_addr(cur, ptr, block); xfs_btree_updkey() 1909 struct xfs_btree_block *block; xfs_btree_update() local 1918 /* Pick up the current block. */ xfs_btree_update() 1919 block = xfs_btree_get_block(cur, 0, &bp); xfs_btree_update() 1922 error = xfs_btree_check_block(cur, block, 0, bp); xfs_btree_update() 1928 rp = xfs_btree_rec_addr(cur, ptr, block); xfs_btree_update() 1938 if (xfs_btree_is_lastrec(cur, block, 0)) { xfs_btree_update() 1939 cur->bc_ops->update_lastrec(cur, block, rec, xfs_btree_update() 1973 struct xfs_btree_block *left; /* left btree block */ xfs_btree_lshift() 1976 struct xfs_btree_block *right; /* right btree block */ xfs_btree_lshift() 1991 /* Set up variables for this block as "right". */ xfs_btree_lshift() 2036 * If non-leaf, copy a key and a ptr to the left block. xfs_btree_lshift() 2037 * Log the changes to the left block. xfs_btree_lshift() 2114 * If it's the first record in the block, we'll need a key xfs_btree_lshift() 2156 struct xfs_btree_block *left; /* left btree block */ xfs_btree_rshift() 2158 struct xfs_btree_block *right; /* right btree block */ xfs_btree_rshift() 2160 union xfs_btree_ptr rptr; /* right block pointer */ xfs_btree_rshift() 2174 /* Set up variables for this block as "left". */ xfs_btree_rshift() 2210 * Make a hole at the start of the right neighbor block, then xfs_btree_rshift() 2211 * copy the last left block entry to the hole. xfs_btree_rshift() 2282 * block on the right. xfs_btree_rshift() 2320 * Split cur/level block in half. 2321 * Return new block number and the key to its first 2333 union xfs_btree_ptr lptr; /* left sibling block ptr */ __xfs_btree_split() 2335 struct xfs_btree_block *left; /* left btree block */ __xfs_btree_split() 2336 union xfs_btree_ptr rptr; /* right sibling block ptr */ __xfs_btree_split() 2338 struct xfs_btree_block *right; /* right btree block */ __xfs_btree_split() 2341 struct xfs_btree_block *rrblock; /* right-right btree block */ __xfs_btree_split() 2355 /* Set up left block (current one). */ __xfs_btree_split() 2366 /* Allocate the new block. If we can't do it, we're toast. Give up. */ __xfs_btree_split() 2374 /* Set up the new block as "right". */ __xfs_btree_split() 2379 /* Fill in the btree header for the new right block. */ __xfs_btree_split() 2383 * Split the entries between the old and the new block evenly. __xfs_btree_split() 2385 * each new block will have the same number of entries. __xfs_btree_split() 2396 * Copy btree block entries from the left block over to the __xfs_btree_split() 2397 * new block, the right. Update the right block and log the __xfs_btree_split() 2426 /* Grab the keys to the entries moved to the right block */ __xfs_btree_split() 2445 * Find the left block number by looking in the buffer. __xfs_btree_split() 2461 * If there's a block to the new block's right, make that block __xfs_btree_split() 2473 * If the cursor is really in the right block, move it there. __xfs_btree_split() 2483 * the right block, no matter where this cursor was. __xfs_btree_split() 2533 * temporarily to ensure that we don't block waiting for memory reclaim xfs_btree_split_worker() 2585 * Copy the old inode root contents into a real block and make the 2595 struct xfs_btree_block *block; /* btree block */ xfs_btree_new_iroot() local 2596 struct xfs_btree_block *cblock; /* child btree block */ xfs_btree_new_iroot() 2600 union xfs_btree_ptr *pp; /* pointer to block addr */ xfs_btree_new_iroot() 2601 union xfs_btree_ptr nptr; /* new block addr */ xfs_btree_new_iroot() 2615 block = xfs_btree_get_iroot(cur); xfs_btree_new_iroot() 2616 pp = xfs_btree_ptr_addr(cur, 1, block); xfs_btree_new_iroot() 2618 /* Allocate the new block. If we can't do it, we're toast. Give up. */ xfs_btree_new_iroot() 2628 /* Copy the root into a real block. */ xfs_btree_new_iroot() 2637 memcpy(cblock, block, xfs_btree_block_len(cur)); xfs_btree_new_iroot() 2645 be16_add_cpu(&block->bb_level, 1); xfs_btree_new_iroot() 2646 xfs_btree_set_numrecs(block, 1); xfs_btree_new_iroot() 2650 kp = xfs_btree_key_addr(cur, 1, block); xfs_btree_new_iroot() 2696 * Allocate a new root block, fill it in. 2703 struct xfs_btree_block *block; /* one half of the old root block */ xfs_btree_new_root() local 2704 struct xfs_buf *bp; /* buffer containing block */ xfs_btree_new_root() 2707 struct xfs_btree_block *left; /* left btree block */ xfs_btree_new_root() 2709 struct xfs_btree_block *new; /* new (root) btree block */ xfs_btree_new_root() 2712 struct xfs_btree_block *right; /* right btree block */ xfs_btree_new_root() 2722 /* Allocate the new block. If we can't do it, we're toast. Give up. */ xfs_btree_new_root() 2730 /* Set up the new block. */ xfs_btree_new_root() 2740 * and the new block generated when it was split. We don't know which xfs_btree_new_root() 2744 block = xfs_btree_get_block(cur, cur->bc_nlevels - 1, &bp); xfs_btree_new_root() 2747 error = xfs_btree_check_block(cur, block, cur->bc_nlevels - 1, bp); xfs_btree_new_root() 2752 xfs_btree_get_sibling(cur, block, &rptr, XFS_BB_RIGHTSIB); xfs_btree_new_root() 2754 /* Our block is left, pick up the right block. */ xfs_btree_new_root() 2757 left = block; xfs_btree_new_root() 2764 /* Our block is right, pick up the left block. */ xfs_btree_new_root() 2767 right = block; xfs_btree_new_root() 2775 /* Fill in the new block's btree header and log it. */ xfs_btree_new_root() 2826 int numrecs,/* # of recs in block */ xfs_btree_make_block_unfull() 2842 /* A root block that can be made bigger. */ xfs_btree_make_block_unfull() 2845 /* A root block that needs replacing */ xfs_btree_make_block_unfull() 2874 * Next, try splitting the current block in half. xfs_btree_make_block_unfull() 2877 * could be in a different block now. xfs_btree_make_block_unfull() 2897 union xfs_btree_ptr *ptrp, /* i/o: block number inserted */ xfs_btree_insrec() 2902 struct xfs_btree_block *block; /* btree block */ xfs_btree_insrec() local 2903 struct xfs_buf *bp; /* buffer for block */ xfs_btree_insrec() 2905 union xfs_btree_ptr nptr; /* new block ptr */ xfs_btree_insrec() 2923 * root level, allocate a new root block and we're done. xfs_btree_insrec() 2949 /* Get pointers to the btree buffer and block. */ xfs_btree_insrec() 2950 block = xfs_btree_get_block(cur, level, &bp); xfs_btree_insrec() 2951 numrecs = xfs_btree_get_numrecs(block); xfs_btree_insrec() 2954 error = xfs_btree_check_block(cur, block, level, bp); xfs_btree_insrec() 2962 xfs_btree_rec_addr(cur, ptr, block))); xfs_btree_insrec() 2965 xfs_btree_key_addr(cur, ptr, block))); xfs_btree_insrec() 2971 * If the block is full, we can't insert the new entry until we xfs_btree_insrec() 2972 * make the block un-full. xfs_btree_insrec() 2983 * The current block may have changed if the block was xfs_btree_insrec() 2986 block = xfs_btree_get_block(cur, level, &bp); xfs_btree_insrec() 2987 numrecs = xfs_btree_get_numrecs(block); xfs_btree_insrec() 2990 error = xfs_btree_check_block(cur, block, level, bp); xfs_btree_insrec() 2996 * At this point we know there's room for our new entry in the block xfs_btree_insrec() 3006 kp = xfs_btree_key_addr(cur, ptr, block); xfs_btree_insrec() 3007 pp = xfs_btree_ptr_addr(cur, ptr, block); xfs_btree_insrec() 3030 xfs_btree_set_numrecs(block, numrecs); xfs_btree_insrec() 3036 xfs_btree_key_addr(cur, ptr + 1, block))); xfs_btree_insrec() 3043 rp = xfs_btree_rec_addr(cur, ptr, block); xfs_btree_insrec() 3049 xfs_btree_set_numrecs(block, ++numrecs); xfs_btree_insrec() 3054 xfs_btree_rec_addr(cur, ptr + 1, block))); xfs_btree_insrec() 3062 /* If we inserted at the start of a block, update the parents' keys. */ xfs_btree_insrec() 3073 if (xfs_btree_is_lastrec(cur, block, level)) { xfs_btree_insrec() 3074 cur->bc_ops->update_lastrec(cur, block, recp, xfs_btree_insrec() 3079 * Return the new block number, if any. xfs_btree_insrec() 3112 union xfs_btree_ptr nptr; /* new block number (split result) */ xfs_btree_insert() 3126 * Stop when we don't get a split block, that must mean that xfs_btree_insert() 3173 * Try to merge a non-leaf block back into the inode root. 3176 * killing the old root block. But because we can't just delete the 3177 * inode we have to copy the single block it was pointing to into the 3187 struct xfs_btree_block *block; xfs_btree_kill_iroot() local 3208 * Don't deal with the root block needs to be a leaf case. xfs_btree_kill_iroot() 3218 block = xfs_btree_get_iroot(cur); xfs_btree_kill_iroot() 3219 if (xfs_btree_get_numrecs(block) != 1) xfs_btree_kill_iroot() 3236 xfs_btree_get_sibling(cur, block, &ptr, XFS_BB_LEFTSIB); xfs_btree_kill_iroot() 3238 xfs_btree_get_sibling(cur, block, &ptr, XFS_BB_RIGHTSIB); xfs_btree_kill_iroot() 3246 block = ifp->if_broot; xfs_btree_kill_iroot() 3249 be16_add_cpu(&block->bb_numrecs, index); xfs_btree_kill_iroot() 3250 ASSERT(block->bb_numrecs == cblock->bb_numrecs); xfs_btree_kill_iroot() 3252 kp = xfs_btree_key_addr(cur, 1, block); xfs_btree_kill_iroot() 3256 pp = xfs_btree_ptr_addr(cur, 1, block); xfs_btree_kill_iroot() 3275 be16_add_cpu(&block->bb_level, -1); xfs_btree_kill_iroot() 3344 * Remove the record from its block then rebalance the tree. 3353 struct xfs_btree_block *block; /* btree block */ xfs_btree_delrec() local 3354 union xfs_btree_ptr cptr; /* current block ptr */ xfs_btree_delrec() 3355 struct xfs_buf *bp; /* buffer for block */ xfs_btree_delrec() 3360 union xfs_btree_ptr lptr; /* left sibling block ptr */ xfs_btree_delrec() 3362 struct xfs_btree_block *left; /* left btree block */ xfs_btree_delrec() 3365 union xfs_btree_ptr rptr; /* right sibling block ptr */ xfs_btree_delrec() 3367 struct xfs_btree_block *right; /* right btree block */ xfs_btree_delrec() 3368 struct xfs_btree_block *rrblock; /* right-right btree block */ xfs_btree_delrec() 3387 /* Get the buffer & block containing the record or key/ptr. */ xfs_btree_delrec() 3388 block = xfs_btree_get_block(cur, level, &bp); xfs_btree_delrec() 3389 numrecs = xfs_btree_get_numrecs(block); xfs_btree_delrec() 3392 error = xfs_btree_check_block(cur, block, level, bp); xfs_btree_delrec() 3397 /* Fail if we're off the end of the block. */ xfs_btree_delrec() 3413 lkp = xfs_btree_key_addr(cur, ptr + 1, block); xfs_btree_delrec() 3414 lpp = xfs_btree_ptr_addr(cur, ptr + 1, block); xfs_btree_delrec() 3432 * If it's the first record in the block, we'll need to pass a xfs_btree_delrec() 3436 keyp = xfs_btree_key_addr(cur, 1, block); xfs_btree_delrec() 3441 xfs_btree_rec_addr(cur, ptr + 1, block), xfs_btree_delrec() 3447 * If it's the first record in the block, we'll need a key xfs_btree_delrec() 3452 xfs_btree_rec_addr(cur, 1, block)); xfs_btree_delrec() 3458 * Decrement and log the number of entries in the block. xfs_btree_delrec() 3460 xfs_btree_set_numrecs(block, --numrecs); xfs_btree_delrec() 3467 if (xfs_btree_is_lastrec(cur, block, level)) { xfs_btree_delrec() 3468 cur->bc_ops->update_lastrec(cur, block, NULL, xfs_btree_delrec() 3473 * We're at the root level. First, shrink the root block in-memory. xfs_btree_delrec() 3501 * pp is still set to the first pointer in the block. xfs_btree_delrec() 3504 pp = xfs_btree_ptr_addr(cur, 1, block); xfs_btree_delrec() 3518 * If we deleted the leftmost entry in the block, update the xfs_btree_delrec() 3528 * If the number of records remaining in the block is at least xfs_btree_delrec() 3543 xfs_btree_get_sibling(cur, block, &rptr, XFS_BB_RIGHTSIB); xfs_btree_delrec() 3544 xfs_btree_get_sibling(cur, block, &lptr, XFS_BB_LEFTSIB); xfs_btree_delrec() 3581 * Move the temp cursor to the last entry in the next block. xfs_btree_delrec() 3595 /* Grab a pointer to the block. */ xfs_btree_delrec() 3602 /* Grab the current block number, for future use. */ xfs_btree_delrec() 3606 * If right block is full enough so that removing one entry xfs_btree_delrec() 3616 ASSERT(xfs_btree_get_numrecs(block) >= xfs_btree_delrec() 3632 * to our block again (last record). xfs_btree_delrec() 3653 * previous block. xfs_btree_delrec() 3664 /* Grab a pointer to the block. */ xfs_btree_delrec() 3671 /* Grab the current block number, for future use. */ xfs_btree_delrec() 3675 * If left block is full enough so that removing one entry xfs_btree_delrec() 3685 ASSERT(xfs_btree_get_numrecs(block) >= xfs_btree_delrec() 3712 lrecs + xfs_btree_get_numrecs(block) <= xfs_btree_delrec() 3715 * Set "right" to be the starting block, xfs_btree_delrec() 3719 right = block; xfs_btree_delrec() 3726 * If that won't work, see if we can join with the right neighbor block. xfs_btree_delrec() 3729 rrecs + xfs_btree_get_numrecs(block) <= xfs_btree_delrec() 3732 * Set "left" to be the starting block, xfs_btree_delrec() 3736 left = block; xfs_btree_delrec() 3799 * Fix up the number of records and right block pointer in the xfs_btree_delrec() 3800 * surviving block, and log it. xfs_btree_delrec() 3807 /* If there is a right sibling, point it to the remaining block. */ xfs_btree_delrec() 3817 /* Free the deleted block. */ xfs_btree_delrec() 3825 * cursor to the left block, and fix up the index. xfs_btree_delrec() 3920 struct xfs_btree_block *block; /* btree block */ xfs_btree_get_rec() local 3928 block = xfs_btree_get_block(cur, 0, &bp); xfs_btree_get_rec() 3931 error = xfs_btree_check_block(cur, block, 0, bp); xfs_btree_get_rec() 3939 if (ptr > xfs_btree_get_numrecs(block) || ptr <= 0) { xfs_btree_get_rec() 3947 *recp = xfs_btree_rec_addr(cur, ptr, block); xfs_btree_get_rec() 3965 * as the amount of CPU work we have to do before moving to the next block is 3968 * For each btree block that we load, modify the owner appropriately, set the 3983 struct xfs_btree_block *block; xfs_btree_block_change_owner() local 3991 block = xfs_btree_get_block(cur, level, &bp); xfs_btree_block_change_owner() 3993 block->bb_u.l.bb_owner = cpu_to_be64(new_owner); xfs_btree_block_change_owner() 3995 block->bb_u.s.bb_owner = cpu_to_be32(new_owner); xfs_btree_block_change_owner() 3998 * If the block is a root block hosted in an inode, we might not have a xfs_btree_block_change_owner() 4001 * block is formatted into the on-disk inode fork. We still change it, xfs_btree_block_change_owner() 4016 /* now read rh sibling block for next iteration */ xfs_btree_block_change_owner() 4017 xfs_btree_get_sibling(cur, block, &rptr, XFS_BB_RIGHTSIB); xfs_btree_block_change_owner() 4021 return xfs_btree_lookup_get_block(cur, level, &rptr, &block); xfs_btree_block_change_owner() 4032 struct xfs_btree_block *block = NULL; xfs_btree_change_owner() local 4039 /* grab the left hand block */ xfs_btree_change_owner() 4040 error = xfs_btree_lookup_get_block(cur, level, &lptr, &block); xfs_btree_change_owner() 4044 /* readahead the left most block for the next level down */ xfs_btree_change_owner() 4048 ptr = xfs_btree_ptr_addr(cur, 1, block); xfs_btree_change_owner() 55 xfs_btree_check_lblock( struct xfs_btree_cur *cur, struct xfs_btree_block *block, int level, struct xfs_buf *bp) xfs_btree_check_lblock() argument 99 xfs_btree_check_sblock( struct xfs_btree_cur *cur, struct xfs_btree_block *block, int level, struct xfs_buf *bp) xfs_btree_check_sblock() argument 150 xfs_btree_check_block( struct xfs_btree_cur *cur, struct xfs_btree_block *block, int level, struct xfs_buf *bp) xfs_btree_check_block() argument 469 xfs_btree_rec_addr( struct xfs_btree_cur *cur, int n, struct xfs_btree_block *block) xfs_btree_rec_addr() argument 482 xfs_btree_key_addr( struct xfs_btree_cur *cur, int n, struct xfs_btree_block *block) xfs_btree_key_addr() argument 495 xfs_btree_ptr_addr( struct xfs_btree_cur *cur, int n, struct xfs_btree_block *block) xfs_btree_ptr_addr() argument 766 xfs_btree_readahead_lblock( struct xfs_btree_cur *cur, int lr, struct xfs_btree_block *block) xfs_btree_readahead_lblock() argument 791 xfs_btree_readahead_sblock( struct xfs_btree_cur *cur, int lr, struct xfs_btree_block *block) xfs_btree_readahead_sblock() argument 939 xfs_btree_get_sibling( struct xfs_btree_cur *cur, struct xfs_btree_block *block, union xfs_btree_ptr *ptr, int lr) xfs_btree_get_sibling() argument 961 xfs_btree_set_sibling( struct xfs_btree_cur *cur, struct xfs_btree_block *block, union xfs_btree_ptr *ptr, int lr) xfs_btree_set_sibling() argument 1067 xfs_btree_is_lastrec( struct xfs_btree_cur *cur, struct xfs_btree_block *block, int level) xfs_btree_is_lastrec() argument 1123 xfs_btree_get_buf_block( struct xfs_btree_cur *cur, union xfs_btree_ptr *ptr, int flags, struct xfs_btree_block **block, struct xfs_buf **bpp) xfs_btree_get_buf_block() argument 1153 xfs_btree_read_buf_block( struct xfs_btree_cur *cur, union xfs_btree_ptr *ptr, int flags, struct xfs_btree_block **block, struct xfs_buf **bpp) xfs_btree_read_buf_block() argument 1676 xfs_lookup_get_search_key( struct xfs_btree_cur *cur, int level, int keyno, struct xfs_btree_block *block, union xfs_btree_key *kp) xfs_lookup_get_search_key() argument
|
H A D | xfs_rtbitmap.c | 45 * Get a buffer for the bitmap or summary file block specified. 52 xfs_rtblock_t block, /* block number in bitmap or summary */ xfs_rtbuf_get() 54 xfs_buf_t **bpp) /* output: buffer for the block */ xfs_rtbuf_get() 56 xfs_buf_t *bp; /* block buffer, result */ xfs_rtbuf_get() 64 error = xfs_bmapi_read(ip, block, 1, &map, &nmap, XFS_DATA_FORK); xfs_rtbuf_get() 79 * Searching backward from start to limit, find the first block whose 86 xfs_rtblock_t start, /* starting block to look at */ xfs_rtfind_back() 87 xfs_rtblock_t limit, /* last block to look at */ xfs_rtfind_back() 88 xfs_rtblock_t *rtblock) /* out: start block found */ xfs_rtfind_back() 92 xfs_rtblock_t block; /* bitmap block number */ xfs_rtfind_back() local 93 xfs_buf_t *bp; /* buf for the block */ xfs_rtfind_back() 105 * Compute and read in starting bitmap block for starting block. xfs_rtfind_back() 107 block = XFS_BITTOBLOCK(mp, start); xfs_rtfind_back() 108 error = xfs_rtbuf_get(mp, tp, block, 0, &bp); xfs_rtfind_back() 152 * Go on to previous block if that's where the previous word is xfs_rtfind_back() 157 * If done with this block, get the previous one. xfs_rtfind_back() 160 error = xfs_rtbuf_get(mp, tp, --block, 0, &bp); xfs_rtfind_back() 198 * Go on to previous block if that's where the previous word is xfs_rtfind_back() 203 * If done with this block, get the previous one. xfs_rtfind_back() 206 error = xfs_rtbuf_get(mp, tp, --block, 0, &bp); xfs_rtfind_back() 254 * Searching forward from start to limit, find the first block whose 261 xfs_rtblock_t start, /* starting block to look at */ xfs_rtfind_forw() 262 xfs_rtblock_t limit, /* last block to look at */ xfs_rtfind_forw() 263 xfs_rtblock_t *rtblock) /* out: start block found */ xfs_rtfind_forw() 267 xfs_rtblock_t block; /* bitmap block number */ xfs_rtfind_forw() local 268 xfs_buf_t *bp; /* buf for the block */ xfs_rtfind_forw() 280 * Compute and read in starting bitmap block for starting block. xfs_rtfind_forw() 282 block = XFS_BITTOBLOCK(mp, start); xfs_rtfind_forw() 283 error = xfs_rtbuf_get(mp, tp, block, 0, &bp); xfs_rtfind_forw() 326 * Go on to next block if that's where the next word is xfs_rtfind_forw() 331 * If done with this block, get the previous one. xfs_rtfind_forw() 334 error = xfs_rtbuf_get(mp, tp, ++block, 0, &bp); xfs_rtfind_forw() 371 * Go on to next block if that's where the next word is xfs_rtfind_forw() 376 * If done with this block, get the next one. xfs_rtfind_forw() 379 error = xfs_rtbuf_get(mp, tp, ++block, 0, &bp); xfs_rtfind_forw() 425 * bitmap block combination. 426 * Keeps track of a current summary block, so we don't keep reading 437 xfs_rtblock_t bbno, /* bitmap block number */ xfs_rtmodify_summary_int() 439 xfs_buf_t **rbpp, /* in/out: summary block buffer */ xfs_rtmodify_summary_int() 440 xfs_fsblock_t *rsb, /* in/out: summary block number */ xfs_rtmodify_summary_int() 441 xfs_suminfo_t *sum) /* out: summary info for this block */ xfs_rtmodify_summary_int() 443 xfs_buf_t *bp; /* buffer for the summary block */ xfs_rtmodify_summary_int() 454 * Compute the block number in the summary file. xfs_rtmodify_summary_int() 458 * If we have an old buffer, and the block number matches, use that. xfs_rtmodify_summary_int() 476 * Remember this buffer and block for the next call. xfs_rtmodify_summary_int() 501 xfs_rtblock_t bbno, /* bitmap block number */ xfs_rtmodify_summary() 503 xfs_buf_t **rbpp, /* in/out: summary block buffer */ xfs_rtmodify_summary() 504 xfs_fsblock_t *rsb) /* in/out: summary block number */ xfs_rtmodify_summary() 518 xfs_rtblock_t start, /* starting block to modify */ xfs_rtmodify_range() 524 xfs_rtblock_t block; /* bitmap block number */ xfs_rtmodify_range() local 525 xfs_buf_t *bp; /* buf for the block */ xfs_rtmodify_range() 535 * Compute starting bitmap block number. xfs_rtmodify_range() 537 block = XFS_BITTOBLOCK(mp, start); xfs_rtmodify_range() 539 * Read the bitmap block, and point to its data. xfs_rtmodify_range() 541 error = xfs_rtbuf_get(mp, tp, block, 0, &bp); xfs_rtmodify_range() 575 * Go on to the next block if that's where the next word is xfs_rtmodify_range() 580 * Log the changed part of this block. xfs_rtmodify_range() 586 error = xfs_rtbuf_get(mp, tp, ++block, 0, &bp); xfs_rtmodify_range() 615 * Go on to the next block if that's where the next word is xfs_rtmodify_range() 620 * Log the changed part of this block. xfs_rtmodify_range() 626 error = xfs_rtbuf_get(mp, tp, ++block, 0, &bp); xfs_rtmodify_range() 675 xfs_rtblock_t start, /* starting block to free */ xfs_rtfree_range() 677 xfs_buf_t **rbpp, /* in/out: summary block buffer */ xfs_rtfree_range() 678 xfs_fsblock_t *rsb) /* in/out: summary block number */ xfs_rtfree_range() 682 xfs_rtblock_t postblock; /* first block freed > end */ xfs_rtfree_range() 683 xfs_rtblock_t preblock; /* first block freed < start */ xfs_rtfree_range() 703 * Find the next allocated block (end of allocated extent). xfs_rtfree_range() 751 xfs_rtblock_t start, /* starting block number of extent */ xfs_rtcheck_range() 754 xfs_rtblock_t *new, /* out: first block not matching */ xfs_rtcheck_range() 759 xfs_rtblock_t block; /* bitmap block number */ xfs_rtcheck_range() local 760 xfs_buf_t *bp; /* buf for the block */ xfs_rtcheck_range() 770 * Compute starting bitmap block number xfs_rtcheck_range() 772 block = XFS_BITTOBLOCK(mp, start); xfs_rtcheck_range() 774 * Read the bitmap block. xfs_rtcheck_range() 776 error = xfs_rtbuf_get(mp, tp, block, 0, &bp); xfs_rtcheck_range() 819 * Go on to next block if that's where the next word is xfs_rtcheck_range() 824 * If done with this block, get the next one. xfs_rtcheck_range() 827 error = xfs_rtbuf_get(mp, tp, ++block, 0, &bp); xfs_rtcheck_range() 865 * Go on to next block if that's where the next word is xfs_rtcheck_range() 870 * If done with this block, get the next one. xfs_rtcheck_range() 873 error = xfs_rtbuf_get(mp, tp, ++block, 0, &bp); xfs_rtcheck_range() 921 * Check that the given extent (block range) is allocated already. 927 xfs_rtblock_t bno, /* starting block number of extent */ xfs_rtcheck_alloc_range() 945 * realtime extents, as is the block number. 950 xfs_rtblock_t bno, /* starting block number to free */ xfs_rtfree_extent() 955 xfs_fsblock_t sb; /* summary file block number */ xfs_rtfree_extent() 956 xfs_buf_t *sumbp = NULL; /* summary file block buffer */ xfs_rtfree_extent() 49 xfs_rtbuf_get( xfs_mount_t *mp, xfs_trans_t *tp, xfs_rtblock_t block, int issum, xfs_buf_t **bpp) xfs_rtbuf_get() argument
|
H A D | xfs_bmap_btree.h | 36 * Btree block header size depends on a superblock flag. 42 #define XFS_BMBT_REC_ADDR(mp, block, index) \ 44 ((char *)(block) + \ 48 #define XFS_BMBT_KEY_ADDR(mp, block, index) \ 50 ((char *)(block) + \ 54 #define XFS_BMBT_PTR_ADDR(mp, block, index, maxrecs) \ 56 ((char *)(block) + \ 61 #define XFS_BMDR_REC_ADDR(block, index) \ 63 ((char *)(block) + \ 67 #define XFS_BMDR_KEY_ADDR(block, index) \ 69 ((char *)(block) + \ 73 #define XFS_BMDR_PTR_ADDR(block, index, maxrecs) \ 75 ((char *)(block) + \ 81 * These are to be used when we know the size of the block and
|
H A D | xfs_btree.h | 42 xfs_bmdr_key_t bmbr; /* bmbt root block */ 49 xfs_bmdr_rec_t bmbr; /* bmbt root block */ 131 /* block allocation / freeing */ 140 struct xfs_btree_block *block, 144 /* records in block/level */ 240 * Convert from buffer to btree block header. 246 * Check that block header is ok. 251 struct xfs_btree_block *block, /* generic btree block pointer */ 252 int level, /* level of the btree block */ 253 struct xfs_buf *bp); /* buffer containing block, if any */ 261 xfs_fsblock_t ptr, /* btree block disk address */ 262 int level); /* btree block level */ 282 * Get a buffer for the block, return it with no data read. 289 xfs_fsblock_t fsbno, /* file system block number */ 293 * Get a buffer for the block, return it with no data read. 301 xfs_agblock_t agbno, /* allocation group block number */ 305 * Check for the cursor referring to the last block at the given level. 307 int /* 1=is last block, 0=not last block */ 325 * Get a buffer for the block, return it read in. 332 xfs_fsblock_t fsbno, /* file system block number */ 339 * Read-ahead the block, don't wait for it, don't return a buffer. 345 xfs_fsblock_t fsbno, /* file system block number */ 350 * Read-ahead the block, don't wait for it, don't return a buffer. 357 xfs_agblock_t agbno, /* allocation group block number */ 362 * Initialise a new btree block header 400 * btree block CRC helpers 416 static inline int xfs_btree_get_numrecs(struct xfs_btree_block *block) xfs_btree_get_numrecs() argument 418 return be16_to_cpu(block->bb_numrecs); xfs_btree_get_numrecs() 421 static inline void xfs_btree_set_numrecs(struct xfs_btree_block *block, xfs_btree_set_numrecs() argument 424 block->bb_numrecs = cpu_to_be16(numrecs); xfs_btree_set_numrecs() 427 static inline int xfs_btree_get_level(struct xfs_btree_block *block) xfs_btree_get_level() argument 429 return be16_to_cpu(block->bb_level); xfs_btree_get_level() 454 * b = btree block buffer (xfs_buf_t)
|
H A D | xfs_dir2_block.c | 328 * Add an entry to a block directory. 334 xfs_dir2_data_hdr_t *hdr; /* block header */ xfs_dir2_block_addname() 335 xfs_dir2_leaf_entry_t *blp; /* block leaf entries */ xfs_dir2_block_addname() 336 struct xfs_buf *bp; /* buffer for block */ xfs_dir2_block_addname() 337 xfs_dir2_block_tail_t *btp; /* block tail */ xfs_dir2_block_addname() 339 xfs_dir2_data_entry_t *dep; /* block data entry */ xfs_dir2_block_addname() 341 xfs_dir2_data_unused_t *dup; /* block unused entry */ xfs_dir2_block_addname() 363 /* Read the (one and only) directory block into bp. */ xfs_dir2_block_addname() 371 * Set up pointers to parts of the block. xfs_dir2_block_addname() 565 * Log leaf entries from the block. 570 struct xfs_buf *bp, /* block buffer */ xfs_dir2_block_log_leaf() 585 * Log the block tail. 590 struct xfs_buf *bp) /* block buffer */ xfs_dir2_block_log_tail() 601 * Look up an entry in the block. This is the external routine, 608 xfs_dir2_data_hdr_t *hdr; /* block header */ xfs_dir2_block_lookup() 609 xfs_dir2_leaf_entry_t *blp; /* block leaf entries */ xfs_dir2_block_lookup() 610 struct xfs_buf *bp; /* block buffer */ xfs_dir2_block_lookup() 611 xfs_dir2_block_tail_t *btp; /* block tail */ xfs_dir2_block_lookup() 612 xfs_dir2_data_entry_t *dep; /* block data entry */ xfs_dir2_block_lookup() 637 * Fill in inode number, CI name if appropriate, release the block. xfs_dir2_block_lookup() 647 * Internal block lookup routine. 652 struct xfs_buf **bpp, /* returned block buffer */ xfs_dir2_block_lookup_int() 656 xfs_dir2_data_hdr_t *hdr; /* block header */ xfs_dir2_block_lookup_int() 657 xfs_dir2_leaf_entry_t *blp; /* block leaf entries */ xfs_dir2_block_lookup_int() 658 struct xfs_buf *bp; /* block buffer */ xfs_dir2_block_lookup_int() 659 xfs_dir2_block_tail_t *btp; /* block tail */ xfs_dir2_block_lookup_int() 660 xfs_dir2_data_entry_t *dep; /* block data entry */ xfs_dir2_block_lookup_int() 751 * Remove an entry from a block format directory. 752 * If that makes the block small enough to fit in shortform, transform it. 758 xfs_dir2_data_hdr_t *hdr; /* block header */ xfs_dir2_block_removename() 759 xfs_dir2_leaf_entry_t *blp; /* block leaf pointer */ xfs_dir2_block_removename() 760 struct xfs_buf *bp; /* block buffer */ xfs_dir2_block_removename() 761 xfs_dir2_block_tail_t *btp; /* block tail */ xfs_dir2_block_removename() 762 xfs_dir2_data_entry_t *dep; /* block data entry */ xfs_dir2_block_removename() 764 int ent; /* block leaf entry index */ xfs_dir2_block_removename() 766 int needlog; /* need to log block header */ xfs_dir2_block_removename() 775 * Look up the entry in the block. Gets the buffer and entry index. xfs_dir2_block_removename() 800 * Fix up the block tail. xfs_dir2_block_removename() 831 * Replace an entry in a V2 block directory. 838 xfs_dir2_data_hdr_t *hdr; /* block header */ xfs_dir2_block_replace() 839 xfs_dir2_leaf_entry_t *blp; /* block leaf entries */ xfs_dir2_block_replace() 840 struct xfs_buf *bp; /* block buffer */ xfs_dir2_block_replace() 841 xfs_dir2_block_tail_t *btp; /* block tail */ xfs_dir2_block_replace() 842 xfs_dir2_data_entry_t *dep; /* block data entry */ xfs_dir2_block_replace() 878 * Qsort comparison routine for the block leaf entries. 895 * Convert a V2 leaf directory to a V2 block directory if possible. 904 xfs_dir2_data_hdr_t *hdr; /* block header */ xfs_dir2_leaf_to_block() 905 xfs_dir2_block_tail_t *btp; /* block tail */ xfs_dir2_leaf_to_block() 919 int to; /* block/leaf to index */ xfs_dir2_leaf_to_block() 957 * Read the data block if we don't already have it, give up if it fails. xfs_dir2_leaf_to_block() 969 * Size of the "leaf" area in the block. xfs_dir2_leaf_to_block() 986 * Start converting it to block form. xfs_dir2_leaf_to_block() 993 * Use up the space at the end of the block (blp/btp). xfs_dir2_leaf_to_block() 998 * Initialize the block tail. xfs_dir2_leaf_to_block() 1005 * Initialize the block leaf area. We compact out stale entries. xfs_dir2_leaf_to_block() 1016 * Scan the bestfree if we need it and log the data block header. xfs_dir2_leaf_to_block() 1023 * Pitch the old leaf block. xfs_dir2_leaf_to_block() 1030 * Now see if the resulting block can be shrunken to shortform. xfs_dir2_leaf_to_block() 1040 * Convert the shortform directory to block form. 1046 xfs_dir2_db_t blkno; /* dir-relative block # (0) */ xfs_dir2_sf_to_block() 1047 xfs_dir2_data_hdr_t *hdr; /* block header */ xfs_dir2_sf_to_block() 1048 xfs_dir2_leaf_entry_t *blp; /* block leaf entries */ xfs_dir2_sf_to_block() 1049 struct xfs_buf *bp; /* block buffer */ xfs_dir2_sf_to_block() 1050 xfs_dir2_block_tail_t *btp; /* block tail pointer */ xfs_dir2_sf_to_block() 1059 int needlog; /* need to log block header */ xfs_dir2_sf_to_block() 1060 int needscan; /* need to scan block freespc */ xfs_dir2_sf_to_block() 1062 int offset; /* target block offset */ xfs_dir2_sf_to_block() 1105 * Add block 0 to the inode. xfs_dir2_sf_to_block() 1113 * Initialize the data block, then convert it to block format. xfs_dir2_sf_to_block() 1124 * Compute size of block "tail" area. xfs_dir2_sf_to_block()
|
H A D | xfs_alloc_btree.c | 79 /* Allocate the new block from the freelist. If we can't, give up. */ xfs_allocbt_alloc_block() 132 struct xfs_btree_block *block, xfs_allocbt_update_lastrec() 148 * If this is the last leaf block and it's the last record, xfs_allocbt_update_lastrec() 151 if (ptr != xfs_btree_get_numrecs(block)) xfs_allocbt_update_lastrec() 162 numrecs = xfs_btree_get_numrecs(block); xfs_allocbt_update_lastrec() 170 rrp = XFS_ALLOC_REC_ADDR(cur->bc_mp, block, numrecs); xfs_allocbt_update_lastrec() 277 struct xfs_btree_block *block = XFS_BUF_TO_BLOCK(bp); xfs_allocbt_verify() local 293 level = be16_to_cpu(block->bb_level); xfs_allocbt_verify() 294 switch (block->bb_magic) { xfs_allocbt_verify() 298 if (!uuid_equal(&block->bb_u.s.bb_uuid, &mp->m_sb.sb_uuid)) xfs_allocbt_verify() 300 if (block->bb_u.s.bb_blkno != cpu_to_be64(bp->b_bn)) xfs_allocbt_verify() 303 be32_to_cpu(block->bb_u.s.bb_owner) != pag->pag_agno) xfs_allocbt_verify() 316 if (!uuid_equal(&block->bb_u.s.bb_uuid, &mp->m_sb.sb_uuid)) xfs_allocbt_verify() 318 if (block->bb_u.s.bb_blkno != cpu_to_be64(bp->b_bn)) xfs_allocbt_verify() 321 be32_to_cpu(block->bb_u.s.bb_owner) != pag->pag_agno) xfs_allocbt_verify() 336 if (be16_to_cpu(block->bb_numrecs) > mp->m_alloc_mxr[level != 0]) xfs_allocbt_verify() 340 if (!block->bb_u.s.bb_leftsib || xfs_allocbt_verify() 341 (be32_to_cpu(block->bb_u.s.bb_leftsib) >= mp->m_sb.sb_agblocks && xfs_allocbt_verify() 342 block->bb_u.s.bb_leftsib != cpu_to_be32(NULLAGBLOCK))) xfs_allocbt_verify() 344 if (!block->bb_u.s.bb_rightsib || xfs_allocbt_verify() 345 (be32_to_cpu(block->bb_u.s.bb_rightsib) >= mp->m_sb.sb_agblocks && xfs_allocbt_verify() 346 block->bb_u.s.bb_rightsib != cpu_to_be32(NULLAGBLOCK))) xfs_allocbt_verify() 490 * Calculate number of records in an alloc btree block. 130 xfs_allocbt_update_lastrec( struct xfs_btree_cur *cur, struct xfs_btree_block *block, union xfs_btree_rec *rec, int ptr, int reason) xfs_allocbt_update_lastrec() argument
|
H A D | xfs_dir2_node.c | 52 * Check internal consistency of a leafn block. 216 * Initialize the new block to be empty, and remember xfs_dir3_free_get_buf() 238 * Log entries from a freespace block. 261 * Log header from a freespace block. 281 * We need to change the magic number of the leaf block, and copy 282 * the freespace table out of the leaf block into its own block. 292 xfs_dir2_db_t fdb; /* freespace block number */ xfs_dir2_leaf_to_node() 309 * Add a freespace block to the directory. xfs_dir2_leaf_to_node() 316 * Get the buffer for the new freespace block. xfs_dir2_leaf_to_node() 330 * Copy freespace entries from the leaf block to the new block. xfs_dir2_leaf_to_node() 342 * Now initialize the freespace block header. xfs_dir2_leaf_to_node() 369 * Add a leaf entry to a leaf block in a node-form directory. 405 * the block, if there are no stale entries it won't fit. xfs_dir2_leafn_add() 504 * Look up a leaf entry for space to add a name in a node-format leaf block. 505 * The extrablk in state is a freespace block. 515 xfs_dir2_db_t curdb = -1; /* current data block number */ xfs_dir2_leafn_lookup_for_addname() 516 xfs_dir2_db_t curfdb = -1; /* current free block number */ xfs_dir2_leafn_lookup_for_addname() 520 xfs_dir2_free_t *free = NULL; /* free block structure */ xfs_dir2_leafn_lookup_for_addname() 526 xfs_dir2_db_t newdb; /* new data block number */ xfs_dir2_leafn_lookup_for_addname() 527 xfs_dir2_db_t newfdb; /* new free block number */ xfs_dir2_leafn_lookup_for_addname() 550 /* If so, it's a free block buffer, get the block number. */ xfs_dir2_leafn_lookup_for_addname() 570 * Pull the data block number from the entry. xfs_dir2_leafn_lookup_for_addname() 576 * We want to use a data block with an entry of equal xfs_dir2_leafn_lookup_for_addname() 579 * If this block isn't the data block we already have xfs_dir2_leafn_lookup_for_addname() 587 * Convert the data block to the free block xfs_dir2_leafn_lookup_for_addname() 636 /* Giving back a free block. */ xfs_dir2_leafn_lookup_for_addname() 659 * Look up a leaf entry in a node-format leaf block. 660 * The extrablk in state a data block. 670 xfs_dir2_db_t curdb = -1; /* current data block number */ xfs_dir2_leafn_lookup_for_entry() 671 xfs_dir2_data_entry_t *dep; /* data block entry */ xfs_dir2_leafn_lookup_for_entry() 678 xfs_dir2_db_t newdb; /* new data block number */ xfs_dir2_leafn_lookup_for_entry() 717 * Pull the data block number from the entry. xfs_dir2_leafn_lookup_for_entry() 725 * If it's a different data block, go get it. xfs_dir2_leafn_lookup_for_entry() 729 * If we had a block before that we aren't saving xfs_dir2_leafn_lookup_for_entry() 736 * If needing the block that is saved with a CI match, xfs_dir2_leafn_lookup_for_entry() 737 * use it otherwise read in the new data block. xfs_dir2_leafn_lookup_for_entry() 763 * match, store the block & inode number and continue looking. xfs_dir2_leafn_lookup_for_entry() 767 /* If there is a CI match block, drop it */ xfs_dir2_leafn_lookup_for_entry() 790 /* Giving back last used data block. */ xfs_dir2_leafn_lookup_for_entry() 799 /* If the curbp is not the CI match block, drop it */ xfs_dir2_leafn_lookup_for_entry() 811 * Look up a leaf entry in a node-format leaf block. 812 * If this is an addname then the extrablk in state is a freespace block, 813 * otherwise it's a data block. 938 * This is actually only called when the second block is new, 946 xfs_da_state_blk_t *blk1, /* first btree block */ xfs_dir2_leafn_rebalance() 947 xfs_da_state_blk_t *blk2) /* second btree block */ xfs_dir2_leafn_rebalance() 968 * If the block order is wrong, swap the arguments. xfs_dir2_leafn_rebalance() 971 xfs_da_state_blk_t *tmp; /* temp for block swap */ xfs_dir2_leafn_rebalance() 1083 * Data block is not empty, just set the free entry to the new xfs_dir3_data_block_free() 1118 * If there are no useful entries left in the block, get rid of the xfs_dir3_data_block_free() 1119 * block if we can. xfs_dir3_data_block_free() 1133 * else will eventually get rid of this block. xfs_dir3_data_block_free() 1146 * and updates the free block if necessary. 1153 xfs_da_state_blk_t *dblk, /* data block */ xfs_dir2_leafn_remove() 1154 int *rval) /* resulting block needs join */ xfs_dir2_leafn_remove() 1156 xfs_dir2_data_hdr_t *hdr; /* data block header */ xfs_dir2_leafn_remove() 1157 xfs_dir2_db_t db; /* data block number */ xfs_dir2_leafn_remove() 1158 struct xfs_buf *dbp; /* data block buffer */ xfs_dir2_leafn_remove() 1159 xfs_dir2_data_entry_t *dep; /* data block entry */ xfs_dir2_leafn_remove() 1164 int off; /* data block entry offset */ xfs_dir2_leafn_remove() 1186 * Extract the data block and offset from the entry. xfs_dir2_leafn_remove() 1195 * Log the leaf block changes. xfs_dir2_leafn_remove() 1206 * in the data block in case it changes. xfs_dir2_leafn_remove() 1217 * Rescan the data block freespaces for bestfree. xfs_dir2_leafn_remove() 1218 * Log the data block header if needed. xfs_dir2_leafn_remove() 1226 * If the longest data block freespace changes, need to update xfs_dir2_leafn_remove() 1232 xfs_dir2_db_t fdb; /* freeblock block number */ xfs_dir2_leafn_remove() 1237 * Convert the data block number to a free block, xfs_dir2_leafn_remove() 1238 * read in the free block. xfs_dir2_leafn_remove() 1262 * If the data block is now empty we can get rid of it xfs_dir2_leafn_remove() 1268 * Try to punch out the data block. xfs_dir2_leafn_remove() 1278 * will eventually get rid of the empty block. xfs_dir2_leafn_remove() 1284 * If we got rid of the data block, we can eliminate that entry xfs_dir2_leafn_remove() 1285 * in the free block. xfs_dir2_leafn_remove() 1295 * Return indication of whether this leaf block is empty enough xfs_dir2_leafn_remove() 1305 * Split the leaf entries in the old block into old and new blocks. 1310 xfs_da_state_blk_t *oldblk, /* original block */ xfs_dir2_leafn_split() 1311 xfs_da_state_blk_t *newblk) /* newly created block */ xfs_dir2_leafn_split() 1314 xfs_dablk_t blkno; /* new leaf block number */ xfs_dir2_leafn_split() 1329 * Initialize the new leaf block. xfs_dir2_leafn_split() 1340 * block into the leaves. xfs_dir2_leafn_split() 1348 * Insert the new entry in the correct block. xfs_dir2_leafn_split() 1355 * Update last hashval in each block since we added the name. xfs_dir2_leafn_split() 1365 * Check a leaf block and its neighbors to see if the block should be 1366 * collapsed into one or the other neighbor. Always keep the block 1367 * with the smaller block number. 1368 * If the current block is over 50% full, don't try to join it, return 0. 1369 * If the block is empty, fill in the state structure and return 2. 1378 xfs_da_state_blk_t *blk; /* leaf block */ xfs_dir2_leafn_toosmall() 1379 xfs_dablk_t blkno; /* leaf block number */ xfs_dir2_leafn_toosmall() 1384 int forward; /* sibling block direction */ xfs_dir2_leafn_toosmall() 1393 * Check for the degenerate case of the block being over 50% full. xfs_dir2_leafn_toosmall() 1413 * Check for the degenerate case of the block being empty. xfs_dir2_leafn_toosmall() 1414 * If the block is empty, we'll simply delete it, no need to xfs_dir2_leafn_toosmall() 1415 * coalesce it with a sibling block. We choose (arbitrarily) xfs_dir2_leafn_toosmall() 1416 * to merge with the forward block unless it is NULL. xfs_dir2_leafn_toosmall() 1420 * Make altpath point to the block we want to keep and xfs_dir2_leafn_toosmall() 1421 * path point to the block we want to drop (this one). xfs_dir2_leafn_toosmall() 1433 * Examine each sibling block to see if we can coalesce with xfs_dir2_leafn_toosmall() 1435 * whether to merge with the forward or the backward block. xfs_dir2_leafn_toosmall() 1447 * Read the sibling leaf block. xfs_dir2_leafn_toosmall() 1475 * Didn't like either block, give up. xfs_dir2_leafn_toosmall() 1483 * Make altpath point to the block we want to keep (the lower xfs_dir2_leafn_toosmall() 1484 * numbered block) and path point to the block we want to drop. xfs_dir2_leafn_toosmall() 1507 xfs_da_state_blk_t *drop_blk, /* dead block */ xfs_dir2_leafn_unbalance() 1508 xfs_da_state_blk_t *save_blk) /* surviving block */ xfs_dir2_leafn_unbalance() 1570 xfs_da_state_blk_t *blk; /* leaf block for insert */ xfs_dir2_node_addname() 1594 * Add the data entry to a data block. xfs_dir2_node_addname() 1616 * It didn't work, we need to split the leaf block. xfs_dir2_node_addname() 1623 * Split the leaf block and insert the new entry. xfs_dir2_node_addname() 1635 * We may enter with a freespace block that the lookup found. 1640 xfs_da_state_blk_t *fblk) /* optional freespace block */ xfs_dir2_node_addname_int() 1642 xfs_dir2_data_hdr_t *hdr; /* data block header */ xfs_dir2_node_addname_int() 1643 xfs_dir2_db_t dbno; /* data block number */ xfs_dir2_node_addname_int() 1644 struct xfs_buf *dbp; /* data block buffer */ xfs_dir2_node_addname_int() 1649 xfs_dir2_db_t fbno; /* freespace block number */ xfs_dir2_node_addname_int() 1652 xfs_dir2_free_t *free=NULL; /* freespace block structure */ xfs_dir2_node_addname_int() 1653 xfs_dir2_db_t ifbno; /* initial freespace block no */ xfs_dir2_node_addname_int() 1654 xfs_dir2_db_t lastfbno=0; /* highest freespace block no */ xfs_dir2_node_addname_int() 1671 * If we came in with a freespace block that means that lookup xfs_dir2_node_addname_int() 1673 * block for that data entry. xfs_dir2_node_addname_int() 1678 * Remember initial freespace block number. xfs_dir2_node_addname_int() 1687 * This means the free entry showed that the data block had xfs_dir2_node_addname_int() 1689 * Use that data block. xfs_dir2_node_addname_int() 1698 * The data block looked at didn't have enough room. xfs_dir2_node_addname_int() 1706 * Didn't come in with a freespace block, so no data block. xfs_dir2_node_addname_int() 1714 * If we don't have a data block yet, we're going to scan the xfs_dir2_node_addname_int() 1716 * highest freespace block number is. xfs_dir2_node_addname_int() 1719 xfs_fileoff_t fo; /* freespace block number */ xfs_dir2_node_addname_int() 1727 * While we haven't identified a data block, search the freeblock xfs_dir2_node_addname_int() 1728 * data for a good data block. If we find a null freeblock entry, xfs_dir2_node_addname_int() 1738 * us a freespace block to start with. xfs_dir2_node_addname_int() 1754 * Read the block. There can be holes in the xfs_dir2_node_addname_int() 1788 * Drop the block. xfs_dir2_node_addname_int() 1798 * If we don't have a data block, we need to allocate one and make xfs_dir2_node_addname_int() 1809 * Allocate and initialize the new data block. xfs_dir2_node_addname_int() 1818 * If (somehow) we have a freespace block, get rid of it. xfs_dir2_node_addname_int() 1826 * Get the freespace block corresponding to the data block xfs_dir2_node_addname_int() 1837 * If there wasn't a freespace block, the read will xfs_dir2_node_addname_int() 1848 "%s: dir ino %llu needed freesp block %lld for\n" xfs_dir2_node_addname_int() 1849 " data block %lld, got %lld ifbno %llu lastfbno %d", xfs_dir2_node_addname_int() 1871 * Get a buffer for the new block. xfs_dir2_node_addname_int() 1894 * Set the freespace block index from the data block number. xfs_dir2_node_addname_int() 1899 * freespace block, extend that table. xfs_dir2_node_addname_int() 1910 * If this entry was for an empty data block xfs_dir2_node_addname_int() 1929 * We had a data block so we don't have to make a new one. xfs_dir2_node_addname_int() 1939 * Read the data block in. xfs_dir2_node_addname_int() 1975 * Rescan the block for bestfree if needed. xfs_dir2_node_addname_int() 1980 * Log the data block header if needed. xfs_dir2_node_addname_int() 1998 * Return the data block and offset in args, then drop the data block. xfs_dir2_node_addname_int() 2043 * Release the btree blocks and leaf block. xfs_dir2_node_lookup() 2050 * Release the data block if we have it. xfs_dir2_node_lookup() 2067 struct xfs_da_state_blk *blk; /* leaf block */ xfs_dir2_node_removename() 2097 * Extrablk refers to the data block. xfs_dir2_node_removename() 2129 xfs_da_state_blk_t *blk; /* leaf block */ xfs_dir2_node_replace() 2130 xfs_dir2_data_hdr_t *hdr; /* data block header */ xfs_dir2_node_replace() 2199 * Didn't find it, and we're holding a data block. Drop it. xfs_dir2_node_replace() 2217 * Trim off a trailing empty freespace block. 2223 xfs_fileoff_t fo, /* free block number */ xfs_dir2_node_trim_free() 2236 * Read the freespace block. xfs_dir2_node_trim_free() 2259 * Blow the block away. xfs_dir2_node_trim_free() 2267 * pieces. This is the last block of an extent. xfs_dir2_node_trim_free()
|
H A D | xfs_da_format.h | 26 * level in the Btree, and to identify which type of block this is. 34 __be32 forw; /* previous block in list */ 35 __be32 back; /* following block in list */ 36 __be16 magic; /* validity check on block */ 60 __be32 crc; /* CRC of block */ 61 __be64 blkno; /* first block of the buffer */ 64 __be64 owner; /* inode that owns the block */ 74 * all match in the block, not just the first match found. 79 struct xfs_da_blkinfo info; /* block type, links, etc. */ 85 struct xfs_da3_blkinfo info; /* block type, links, etc. */ 95 __be32 before; /* Btree block before this key */ 126 * - single block - data with embedded leaf at the end 127 * - multiple data blocks, single leaf+freeindex block 134 #define XFS_DIR2_BLOCK_MAGIC 0x58443242 /* XD2B: single block dirs */ 142 * is in the block header and dirent formats. In many cases the v3 structures 160 * - a larger block header for CRC and identification purposes and so the 166 #define XFS_DIR3_BLOCK_MAGIC 0x58444233 /* XDB3: single block dirs */ 188 * Byte offset in data block and shortform entry. 195 * Normalized offset (in a data block) of the entry, really xfs_dir2_data_off_t. 196 * Only need 16 bits, this is the byte offset into the single block form. 213 * Directory block number (logical dirblk in file) 292 * Data block structures. 294 * A pure data block looks like the following drawing on disk: 311 * most structures are also used for the combined data/freespace "block" 329 * Describe a free area in the data block. 351 * directory block structures. This will be used in several structures. 357 __be32 crc; /* CRC of block */ 358 __be64 blkno; /* first block of the buffer */ 361 __be64 owner; /* inode that owns the block */ 373 * Active entry in a data block. 392 * Unused entry in a data block. 415 * Leaf block structures. 417 * A pure leaf block looks like the following drawing on disk: 436 * The xfs_dir2_data_off_t members (bests) and tail are at the end of the block 446 * Offset of the leaf/node space. First block in this space 453 * Leaf block header. 477 * Leaf block entry. 485 * Leaf block tail. 492 * Leaf block. 507 * Get address of the bests array in the single-leaf block. 516 * Free space block defintions for the node format. 533 xfs_dir2_free_hdr_t hdr; /* block header */ 555 * In core version of the free block header, abstracted away from on-disk format 568 * Single block format. 570 * The single block format looks like the following drawing on disk: 599 * Pointer to the leaf entries embedded in a data block (1-block format) 615 * internal links in the Btree are logical block offsets into the file. 622 * still don't have enough space, then we have to split the block. The 627 * takes the first-in-the-block key match found, so we should only have 649 typedef struct xfs_attr_leaf_hdr { /* constant-structure header block */ 650 xfs_da_blkinfo_t info; /* block type, links, etc. */ 674 __be32 valueblk; /* block number of value bytes */ 681 xfs_attr_leaf_hdr_t hdr; /* constant-structure header block */ 684 * The rest of the block contains the following structures after the 717 * The rest of the block contains the following structures after the 750 * Special value to represent fs block size in the leaf header firstused field. 751 * Only used when block size overflows the 2-bytes available on disk. 852 * Remote attribute block format definition 854 * There is one of these headers per filesystem block in a remote attribute.
|
H A D | xfs_dir2.h | 187 * Directory offset/block conversion functions. 189 * DB blocks here are logical directory block numbers, not filesystem blocks. 211 * Convert byte in space to (DB) block 220 * Convert dataptr to a block number 229 * Convert byte in space to offset in a block 238 * Convert dataptr to a byte offset in a block 247 * Convert block and offset to byte in space 257 * Convert block (DB) to block (dablk) 266 * Convert byte in space to (DA) block 275 * Convert block and offset to dataptr 285 * Convert block (dablk) to block (DB) 294 * Convert block (dablk) to byte offset in space 303 * Directory tail pointer accessor functions. Based on block geometry.
|
H A D | xfs_alloc.h | 36 #define XFS_ALLOCTYPE_START_BNO 0x10 /* near this block else anywhere */ 37 #define XFS_ALLOCTYPE_NEAR_BNO 0x20 /* in this a.g. and near this block */ 38 #define XFS_ALLOCTYPE_THIS_BNO 0x40 /* at exactly this block */ 65 * block in a certain AG is allocated but there is no additional 66 * block for the additional bmap btree block due to a split of the 104 xfs_fsblock_t fsbno; /* file system block number */ 106 xfs_agblock_t agbno; /* allocation group-relative block # */ 122 xfs_fsblock_t firstblock; /* io first block allocated */ 146 * Get a block from the freelist. 147 * Returns with the buffer for the block gotten. 153 xfs_agblock_t *bnop, /* block address retrieved from freelist */ 176 * Put the block on the freelist for the allocation group. 182 struct xfs_buf *agflbp,/* buffer for a.g. free block array */ 183 xfs_agblock_t bno, /* block being freed */ 210 xfs_fsblock_t bno, /* starting block number of extent */ 216 xfs_agblock_t bno, /* starting block of extent */ 223 xfs_agblock_t bno, /* starting block of extent */ 230 xfs_agblock_t *bno, /* output: starting block of extent */
|
H A D | xfs_trans_resv.c | 72 * on-disk format. In memory, the buffer contains a normal btree block header so 123 * the free inode btree: max depth * block size 124 * the allocation btrees: 2 trees * (max depth - 1) * block size 125 * the free inode btree entry: block size 151 * These are based on the size of the file system block because that is what 172 * the inode's bmap btree: max depth * block size 174 * the superblock free block counter: sector size 175 * the allocation btrees: 2 exts * 2 trees * (2 * max depth - 1) * block size 179 * the super block free block counter: sector size 180 * the allocation btrees: 2 exts * 2 trees * (2 * max depth - 1) * block size 201 * the inode's bmap btree: (max depth + 1) * block size 205 * the super block to reflect the freed blocks: sector size 207 * 4 exts * 2 trees * (2 * max depth - 1) * block size 209 * the allocation btrees: 2 trees * (max depth - 1) * block size 232 * the two directory btrees: 2 * (max depth + v2) * dir block size 233 * the two directory bmap btrees: 2 * max depth * block size 238 * the superblock for the free block count: sector size 239 * the allocation btrees: 3 exts * 2 trees * (2 * max depth - 1) * block size 271 * the directory btree could split: (max depth + v2) * dir block size 276 * the superblock for the free block count: sector size 277 * the allocation btrees: 2 trees * (2 * max depth - 1) * block size 309 * the directory btree could join: (max depth + v2) * dir block size 314 * the superblock for the free block count: sector size 315 * the allocation btrees: 2 exts * 2 trees * (2 * max depth - 1) * block size 341 * the inode btree entry: block size 343 * the directory btree: (max depth + v2) * dir block size 344 * the directory inode's bmap btree: (max depth + v2) * block size 364 * the allocation btrees: 2 trees * (max depth - 1) * block size 392 * the allocation btrees: 2 trees * (max depth - 1) * block size 466 * the super block free inode counter: sector size 468 * the inode btree entry: block size 471 * the allocation btrees: 2 trees * (max depth - 1) * block size 528 * allocation btrees for 1 block alloc: 2 * (2 * maxdepth - 1) * blocksize 545 * one bitmap/summary block: blocksize 561 * one bitmap block: blocksize 599 * agf block and superblock (for block allocation) 600 * the new block (directory sized) 601 * bmap blocks for the new directory block 621 * the inode's bmap btree: max depth * block size 625 * the super block to reflect the freed blocks: sector size 627 * 4 exts * 2 trees * (2 * max depth - 1) * block size 663 * Setting an attribute at runtime, transaction space unit per block. 665 * the inode bmap btree could join or split: max depth * block size 668 * one block so that the caller could figure out the total space according 684 * the attribute btree could join: max depth * block size 685 * the inode bmap btree could join or split: max depth * block size 689 * the superblock for the free block count: sector size 690 * the allocation btrees: 2 exts * 2 trees * (2 * max depth - 1) * block size 732 * the unit of quota allocation: one system block size 768 * Syncing the incore super block changes to disk. 769 * the super block to reflect the changes: sector size
|
H A D | xfs_dir2_leaf.c | 48 * Check the internal consistency of a leaf1 block. 289 * Initialize a new leaf block, leaf1 or leafn magic accepted. 367 * Convert a block form directory to a leaf form directory. 372 struct xfs_buf *dbp) /* input block's buffer */ xfs_dir2_block_to_leaf() 375 xfs_dablk_t blkno; /* leaf block's bno */ xfs_dir2_block_to_leaf() 376 xfs_dir2_data_hdr_t *hdr; /* block header */ xfs_dir2_block_to_leaf() 377 xfs_dir2_leaf_entry_t *blp; /* block's leaf entries */ xfs_dir2_block_to_leaf() 378 xfs_dir2_block_tail_t *btp; /* block's tail */ xfs_dir2_block_to_leaf() 381 struct xfs_buf *lbp; /* leaf block's buffer */ xfs_dir2_block_to_leaf() 382 xfs_dir2_db_t ldb; /* leaf block's bno */ xfs_dir2_block_to_leaf() 385 int needlog; /* need to log block header */ xfs_dir2_block_to_leaf() 397 * Add the leaf block to the inode. xfs_dir2_block_to_leaf() 399 * Since that's empty now, we'll get the root (block 0 in range). xfs_dir2_block_to_leaf() 407 * Initialize the leaf block, get a buffer for it. xfs_dir2_block_to_leaf() 439 * Make the space formerly occupied by the leaf entries and block xfs_dir2_block_to_leaf() 448 * Fix up the block header, make it a data block. xfs_dir2_block_to_leaf() 607 xfs_dir2_data_hdr_t *hdr; /* data block header */ xfs_dir2_leaf_addname() 608 struct xfs_buf *dbp; /* data block buffer */ xfs_dir2_leaf_addname() 609 xfs_dir2_data_entry_t *dep; /* data block entry */ xfs_dir2_leaf_addname() 613 int grown; /* allocated new data block */ xfs_dir2_leaf_addname() 625 int needbytes; /* leaf block bytes needed */ xfs_dir2_leaf_addname() 630 xfs_dir2_db_t use_block; /* data block number */ xfs_dir2_leaf_addname() 660 * and space in their block for the new entry. xfs_dir2_leaf_addname() 662 * in a data block, improving the lookup of those entries. xfs_dir2_leaf_addname() 678 * Didn't find a block yet, linear search all the data blocks. xfs_dir2_leaf_addname() 683 * Remember a block we see that's missing. xfs_dir2_leaf_addname() 695 * How many bytes do we need in the leaf block? xfs_dir2_leaf_addname() 704 * Now kill use_block if it refers to a missing block, so we xfs_dir2_leaf_addname() 748 * a new data block. xfs_dir2_leaf_addname() 781 * If there was no data block space found, we need to allocate xfs_dir2_leaf_addname() 786 * Add the new data block. xfs_dir2_leaf_addname() 794 * Initialize the block. xfs_dir2_leaf_addname() 801 * If we're adding a new data block on the end we need to xfs_dir2_leaf_addname() 814 * If we're filling in a previously empty block just log it. xfs_dir2_leaf_addname() 824 * Already had space in some data block. xfs_dir2_leaf_addname() 839 * Point to the biggest freespace in our data block. xfs_dir2_leaf_addname() 867 * Need to log the data block's header. xfs_dir2_leaf_addname() 1049 * Log the bests entries indicated from a leaf1 block. 1075 * Log the leaf entries indicated from a leaf1 or leafn block. 1103 * Log the header of the leaf1 or leafn block. 1123 * Log the tail of the leaf1 block. 1152 struct xfs_buf *dbp; /* data block buffer */ xfs_dir2_leaf_lookup() 1153 xfs_dir2_data_entry_t *dep; /* data block entry */ xfs_dir2_leaf_lookup() 1166 * Look up name in the leaf block, returning both buffers and index. xfs_dir2_leaf_lookup() 1199 * Look up name/hash in the leaf block. 1208 int *indexp, /* out: index in leaf block */ xfs_dir2_leaf_lookup_int() 1211 xfs_dir2_db_t curdb = -1; /* current data block number */ xfs_dir2_leaf_lookup_int() 1216 int index; /* index in leaf block */ xfs_dir2_leaf_lookup_int() 1221 xfs_dir2_db_t newdb; /* new data block number */ xfs_dir2_leaf_lookup_int() 1223 xfs_dir2_db_t cidb = -1; /* case match data block no. */ xfs_dir2_leaf_lookup_int() 1259 * Get the new data block number. xfs_dir2_leaf_lookup_int() 1264 * If it's not the same as the old data block number, xfs_dir2_leaf_lookup_int() 1306 * appropriate data block if required and return it. xfs_dir2_leaf_lookup_int() 1340 __be16 *bestsp; /* leaf block best freespace */ xfs_dir2_leaf_removename() 1341 xfs_dir2_data_hdr_t *hdr; /* data block header */ xfs_dir2_leaf_removename() 1342 xfs_dir2_db_t db; /* data block number */ xfs_dir2_leaf_removename() 1343 struct xfs_buf *dbp; /* data block buffer */ xfs_dir2_leaf_removename() 1347 xfs_dir2_db_t i; /* temporary data block # */ xfs_dir2_leaf_removename() 1404 * Scan the freespace in the data block again if necessary, xfs_dir2_leaf_removename() 1405 * log the data block header if necessary. xfs_dir2_leaf_removename() 1412 * If the longest freespace in the data block has changed, xfs_dir2_leaf_removename() 1421 * If the data block is now empty then get rid of the data block. xfs_dir2_leaf_removename() 1429 * allocation of a bmap btree block to do so. xfs_dir2_leaf_removename() 1431 * empty block in place. xfs_dir2_leaf_removename() 1440 * If this is the last data block then compact the xfs_dir2_leaf_removename() 1465 * If the data block was not the first one, drop it. xfs_dir2_leaf_removename() 1472 * See if we can convert to block form. xfs_dir2_leaf_removename() 1484 struct xfs_buf *dbp; /* data block buffer */ xfs_dir2_leaf_replace() 1485 xfs_dir2_data_entry_t *dep; /* data block entry */ xfs_dir2_leaf_replace() 1530 * Return index in the leaf block (lbp) which is either the first 1585 * Trim off a trailing data block. We know it's empty since the leaf 1592 xfs_dir2_db_t db) /* data block number */ xfs_dir2_leaf_trim_data() 1595 struct xfs_buf *dbp; /* data block buffer */ xfs_dir2_leaf_trim_data() 1605 * Read the offending data block. We need its buffer. xfs_dir2_leaf_trim_data() 1629 * Get rid of the data block. xfs_dir2_leaf_trim_data() 1669 * The root of the node form dir needs to already be a LEAFN block. 1679 struct xfs_buf *fbp; /* buffer for freespace block */ xfs_dir2_node_to_leaf() 1682 struct xfs_buf *lbp; /* buffer for leaf block */ xfs_dir2_node_to_leaf() 1727 * Now find the block just before the freespace block. xfs_dir2_node_to_leaf() 1733 * If it's not the single leaf block, give up. xfs_dir2_node_to_leaf() 1745 * Read the freespace block. xfs_dir2_node_to_leaf() 1777 * Set up the leaf tail from the freespace block. xfs_dir2_node_to_leaf() 1795 * Get rid of the freespace block. xfs_dir2_node_to_leaf() 1804 * isolated block. xfs_dir2_node_to_leaf() 1812 * down to a block form directory. xfs_dir2_node_to_leaf()
|
/linux-4.1.27/drivers/md/persistent-data/ |
H A D | dm-array.c | 35 * block location into the header (paranoia about ssds remapping areas by 92 * Returns a pointer to a value within an array block. 94 * index - The index into _this_ specific block. 108 * in an array block. 120 * Increment every value in an array block. 131 * Decrement every value in an array block. 142 * Each array block can hold this many values. 150 * Allocate a new array block. The caller will need to unlock block. 154 struct dm_block **block, struct array_block **ab) alloc_ablock() 158 r = dm_tm_new_block(info->btree_info.tm, &array_validator, block); alloc_ablock() 162 (*ab) = dm_block_data(*block); alloc_ablock() 171 * Pad an array block out with a particular value. Every instance will 195 * Remove some entries from the back of an array block. Every value 217 * Read locks a block, and coerces it to an array block. The caller must 218 * unlock 'block' when finished. 221 struct dm_block **block, struct array_block **ab) get_ablock() 225 r = dm_tm_read_lock(info->btree_info.tm, b, &array_validator, block); get_ablock() 229 *ab = dm_block_data(*block); get_ablock() 234 * Unlocks an array block. 236 static int unlock_ablock(struct dm_array_info *info, struct dm_block *block) unlock_ablock() argument 238 return dm_tm_unlock(info->btree_info.tm, block); unlock_ablock() 248 * Looks up an array block in the btree, and then read locks it. 254 unsigned index, struct dm_block **block, lookup_ablock() 265 return get_ablock(info, le64_to_cpu(block_le), block, ab); lookup_ablock() 269 * Insert an array block into the btree. The block is _not_ unlocked. 272 struct dm_block *block, dm_block_t *root) insert_ablock() 274 __le64 block_le = cpu_to_le64(dm_block_location(block)); insert_ablock() 281 * Looks up an array block in the btree. Then shadows it, and updates the 283 * for both the current root block, and the new one. 286 unsigned index, struct dm_block **block, shadow_ablock() 306 &array_validator, block, &inc); shadow_ablock() 310 *ab = dm_block_data(*block); shadow_ablock() 320 if (dm_block_location(*block) != b) { shadow_ablock() 323 * block, but it is still referenced by the btree. We shadow_ablock() 328 r = insert_ablock(info, index, *block, root); shadow_ablock() 335 * Allocate an new array block, and fill it with some values. 343 struct dm_block *block; insert_new_ablock() local 346 r = alloc_ablock(info, size_of_block, max_entries, &block, &ab); insert_new_ablock() 351 r = insert_ablock(info, block_index, block, root); insert_new_ablock() 352 unlock_ablock(info, block); insert_new_ablock() 387 * Metadata block size. Used to calculate the nr entries in an 388 * array block. 393 * Maximum nr entries in an array block. 405 * Number of entries in the final block. 0 iff only full blocks in 418 * in block are decremented as a side effect of the btree remove. 420 * begin_index - the index of the first array block to remove. 421 * end_index - the one-past-the-end value. ie. this block is not removed. 455 struct dm_block *block; shrink() local 473 * Trim the new tail block shrink() 477 resize->new_nr_full_blocks, &block, &ab); shrink() 482 unlock_ablock(resize->info, block); shrink() 494 struct dm_block *block; grow_extend_tail_block() local 498 resize->old_nr_full_blocks, &block, &ab); grow_extend_tail_block() 503 unlock_ablock(resize->info, block); grow_extend_tail_block() 577 struct dm_block *block; block_dec() local 586 DMERR_LIMIT("couldn't get reference count for block %llu", block_dec() 596 r = get_ablock(info, b, &block, &ab); block_dec() 598 DMERR_LIMIT("couldn't get array block %llu", block_dec() 604 unlock_ablock(info, block); block_dec() 694 struct dm_block *block; dm_array_get_value() local 702 r = lookup_ablock(info, root, index / max_entries, &block, &ab); dm_array_get_value() 713 unlock_ablock(info, block); dm_array_get_value() 722 struct dm_block *block; array_set_value() local 733 r = shadow_ablock(info, &root, index / max_entries, &block, &ab); array_set_value() 755 unlock_ablock(info, block); array_set_value() 785 struct dm_block *block; walk_ablock() local 789 r = get_ablock(wi->info, le64_to_cpu(block_le), &block, &ab); walk_ablock() 803 unlock_ablock(wi->info, block); walk_ablock() 152 alloc_ablock(struct dm_array_info *info, size_t size_of_block, uint32_t max_entries, struct dm_block **block, struct array_block **ab) alloc_ablock() argument 220 get_ablock(struct dm_array_info *info, dm_block_t b, struct dm_block **block, struct array_block **ab) get_ablock() argument 253 lookup_ablock(struct dm_array_info *info, dm_block_t root, unsigned index, struct dm_block **block, struct array_block **ab) lookup_ablock() argument 271 insert_ablock(struct dm_array_info *info, uint64_t index, struct dm_block *block, dm_block_t *root) insert_ablock() argument 285 shadow_ablock(struct dm_array_info *info, dm_block_t *root, unsigned index, struct dm_block **block, struct array_block **ab) shadow_ablock() argument
|
H A D | Makefile | 5 dm-block-manager.o \
|
H A D | dm-persistent-data-internal.h | 10 #include "dm-block-manager.h"
|
H A D | dm-transaction-manager.h | 10 #include "dm-block-manager.h" 21 * Clients should not fiddle with the block manager directly. 31 * Methods that return void yet may block should not be called on a clone 54 * These methods are the only way to get hold of a writeable block. 63 * Zeroes the new block and returns with write lock held. 70 * dm_tm_shadow_block() allocates a new block and copies the data from @orig 71 * to it. It then decrements the reference count on original block. Use 72 * this to update the contents of a block in a data structure, don't 73 * confuse this with a clone - you shouldn't access the orig block after 79 * adjust reference counts for children. (Data in the block may refer to 90 * Read access. You can lock any block you want. If there's a write lock 91 * on it outstanding then it'll block. 100 * Functions for altering the reference count of a block directly.
|
H A D | dm-space-map-disk.h | 10 #include "dm-block-manager.h"
|
H A D | dm-block-manager.h | 27 * @name should be a unique identifier for the block manager, no longer 64 * block lock. 68 * dm_bm_lock() locks a block and returns through @result a pointer to 69 * memory that holds a copy of that block. If you have write-locked the 70 * block then any changes you make to memory pointed to by @result will be 82 * The *_try_lock variants return -EWOULDBLOCK if the block isn't 91 * overwrite the block completely. It saves a disk read.
|
/linux-4.1.27/drivers/mtd/nand/ |
H A D | nand_bbt.c | 5 * Bad block table support for the NAND driver 15 * When nand_scan_bbt is called, then it tries to find the bad block table 19 * Once a new bad block is discovered then the "factory" information is updated 26 * If the tables are not versioned, then we "or" the bad block information. 29 * good / bad blocks and the bad block tables are created. 34 * The auto generated bad block table is located in the last good blocks 43 * The table uses 2 bits per block 44 * 11b: block is good 45 * 00b: block is factory marked bad 46 * 01b, 10b: block is marked bad due to wear 48 * The memory bad block table uses the following scheme: 49 * 00b: block is good 50 * 01b: block is marked bad due to wear 51 * 10b: block is reserved (to protect the bbt area) 52 * 11b: block is factory marked bad 54 * Multichip devices like DOC store the bad block info per floor. 57 * - bbts start at a page boundary, if autolocated on a block boundary 58 * - the space necessary for a bbt in FLASH does not exceed a block boundary 84 static inline uint8_t bbt_get_entry(struct nand_chip *chip, int block) bbt_get_entry() argument 86 uint8_t entry = chip->bbt[block >> BBT_ENTRY_SHIFT]; bbt_get_entry() 87 entry >>= (block & BBT_ENTRY_MASK) * 2; bbt_get_entry() 91 static inline void bbt_mark_entry(struct nand_chip *chip, int block, bbt_mark_entry() argument 94 uint8_t msk = (mark & BBT_ENTRY_MASK) << ((block & BBT_ENTRY_MASK) * 2); bbt_mark_entry() 95 chip->bbt[block >> BBT_ENTRY_SHIFT] |= msk; bbt_mark_entry() 112 * Check for a pattern at the given place. Used to search bad block tables and 113 * good / bad block identifiers. 132 * Check for a pattern at the given place. Used to search bad block tables and 133 * good / bad block identifiers. Same as check_pattern, but no optional empty 164 * read_bbt - [GENERIC] Read the bad block table starting from page 170 * @offs: block number offset in the table 172 * Read the bad block table starting from page. 225 pr_info("nand_read_bbt: reserved block at 0x%012llx\n", read_bbt() 237 pr_info("nand_read_bbt: bad block at 0x%012llx\n", read_bbt() 257 * read_abs_bbt - [GENERIC] Read the bad block table starting at a given page 260 * @td: descriptor for the bad block table 264 * Read the bad block table for all chips starting at a given page. We assume 382 * read_abs_bbts - [GENERIC] Read the bad block table(s) for all chips starting at a given page 385 * @td: descriptor for the bad block table 386 * @md: descriptor for the bad block table mirror 388 * Read the bad block table(s) for all chips starting at a given page. We 401 pr_info("Bad block table at page %d, version 0x%02X\n", read_abs_bbts() 410 pr_info("Bad block table at page %d, version 0x%02X\n", read_abs_bbts() 415 /* Scan a given block partially */ scan_block_fast() 447 * create_bbt - [GENERIC] Create a bad block table by scanning the device 450 * @bd: descriptor for the good/bad block search pattern 454 * Create a bad block table by scanning the device for the given good/bad block 513 * search_bbt - [GENERIC] scan the device for a specific bad block table 516 * @td: descriptor for the bad block table 518 * Read the bad block table by searching for a given ident pattern. Search is 520 * downwards. The search starts always at the start of a block. If the option 522 * the bad block information of this chip. This is necessary to provide support 525 * The bbt ident pattern resides in the oob area of the first page in a block. 531 int startblock, block, dir; search_bbt() local 560 for (block = 0; block < td->maxblocks; block++) { search_bbt() 562 int actblock = startblock + dir * block; search_bbt() 581 pr_warn("Bad block table not found for chip %d\n", i); search_bbt() 583 pr_info("Bad block table found at page %d, version 0x%02X\n", search_bbt() 590 * search_read_bbts - [GENERIC] scan the device for bad block table(s) 593 * @td: descriptor for the bad block table 594 * @md: descriptor for the bad block table mirror 596 * Search and read the bad block table(s). 611 * write_bbt - [GENERIC] (Re)write the bad block table 614 * @td: descriptor for the bad block table 615 * @md: descriptor for the bad block table mirror 618 * (Re)write the bad block table. 642 /* Write bad block table per chip rather than per device? */ write_bbt() 670 * Automatic placement of the bad block table. Search direction write_bbt() 682 int block = startblock + dir * i; write_bbt() local 683 /* Check, if the block is bad */ write_bbt() 684 switch (bbt_get_entry(this, block)) { write_bbt() 689 page = block << write_bbt() 691 /* Check, if the block is used by the mirror table */ write_bbt() 695 pr_err("No space left to write bad block table\n"); write_bbt() 720 /* Must we save the block contents? */ write_bbt() 722 /* Make it block aligned */ write_bbt() 728 pr_info("nand_bbt: error reading block for writing the bad block table\n"); write_bbt() 731 pr_warn("nand_bbt: ECC error while reading block for writing bad block table\n"); write_bbt() 802 pr_info("Bad block table written to 0x%012llx, version 0x%02X\n", write_bbt() 811 pr_warn("nand_bbt: error while writing bad block table %d\n", res); write_bbt() 816 * nand_memory_bbt - [GENERIC] create a memory based bad block table 818 * @bd: descriptor for the good/bad block search pattern 834 * @bd: descriptor for the good/bad block search pattern 895 /* Create the bad block table by scanning the device? */ check_create() 941 /* Write the bad block table to the device? */ check_create() 948 /* Write the mirror bad block table to the device? */ check_create() 959 * mark_bbt_regions - [GENERIC] mark the bad block table regions 961 * @td: bad block table descriptor 963 * The bad block table regions are marked as "bad" to prevent accidental 969 int i, j, chips, block, nrblocks, update; mark_bbt_region() local 986 block = td->pages[i] >> (this->bbt_erase_shift - this->page_shift); mark_bbt_region() 987 oldval = bbt_get_entry(this, block); mark_bbt_region() 988 bbt_mark_entry(this, block, BBT_BLOCK_RESERVED); mark_bbt_region() 991 nand_update_bbt(mtd, (loff_t)block << mark_bbt_region() 997 block = ((i + 1) * nrblocks) - td->maxblocks; mark_bbt_region() 999 block = i * nrblocks; mark_bbt_region() 1001 oldval = bbt_get_entry(this, block); mark_bbt_region() 1002 bbt_mark_entry(this, block, BBT_BLOCK_RESERVED); mark_bbt_region() 1005 block++; mark_bbt_region() 1013 nand_update_bbt(mtd, (loff_t)(block - 1) << mark_bbt_region() 1019 * verify_bbt_descr - verify the bad block description 1023 * This functions performs a few sanity checks on the bad block description 1067 * nand_scan_bbt - [NAND Interface] scan, find, read and maybe create bad block table(s) 1069 * @bd: descriptor for the good/bad block search pattern 1071 * The function checks, if a bad block table(s) is/are already available. If 1073 * the bad block table(s) to the selected place. 1075 * The bad block table memory is allocated here. It must be freed by calling 1088 * Allocate memory (2bit per block) and clear the memory bad block nand_scan_bbt() 1097 * memory based bad block table. nand_scan_bbt() 1124 /* Search the bad block table using a pattern in oob */ nand_scan_bbt() 1140 * nand_update_bbt - update bad block table(s) 1142 * @offs: the offset of the newly marked block 1144 * The function updates the bad block table(s). 1178 /* Write the bad block table to the device? */ nand_update_bbt() 1184 /* Write the mirror bad block table to the device? */ nand_update_bbt() 1195 * Define some generic bad / good block scan pattern which are used 1258 pr_warn("Bad block pattern already allocated; not replacing\n"); nand_create_badblock_pattern() 1274 * nand_default_bbt - [NAND Interface] Select a default bad block table for the device 1277 * This function selects the default bad block table support for the device and 1285 /* Is a flash based bad block table requested? */ nand_default_bbt() 1312 * nand_isreserved_bbt - [NAND Interface] Check if a block is reserved 1319 int block; nand_isreserved_bbt() local 1321 block = (int)(offs >> this->bbt_erase_shift); nand_isreserved_bbt() 1322 return bbt_get_entry(this, block) == BBT_BLOCK_RESERVED; nand_isreserved_bbt() 1326 * nand_isbad_bbt - [NAND Interface] Check if a block is bad 1329 * @allowbbt: allow access to bad block table region 1334 int block, res; nand_isbad_bbt() local 1336 block = (int)(offs >> this->bbt_erase_shift); nand_isbad_bbt() 1337 res = bbt_get_entry(this, block); nand_isbad_bbt() 1339 pr_debug("nand_isbad_bbt(): bbt info for offs 0x%08x: (block %d) 0x%02x\n", nand_isbad_bbt() 1340 (unsigned int)offs, block, res); nand_isbad_bbt() 1354 * nand_markbad_bbt - [NAND Interface] Mark a block bad in the BBT 1356 * @offs: offset of the bad block 1361 int block, ret = 0; nand_markbad_bbt() local 1363 block = (int)(offs >> this->bbt_erase_shift); nand_markbad_bbt() 1365 /* Mark bad block in memory */ nand_markbad_bbt() 1366 bbt_mark_entry(this, block, BBT_BLOCK_WORN); nand_markbad_bbt() 1368 /* Update flash-based bad block table */ nand_markbad_bbt()
|
/linux-4.1.27/fs/ext2/ |
H A D | balloc.c | 9 * Enhanced block allocation by Stephen Tweedie (sct@redhat.com), 1993 27 * blocks groups. Each group contains 1 bitmap block for blocks, 1 bitmap 28 * block for inodes, N blocks for the inode table and data blocks. 31 * super block. Each descriptor contains the number of the bitmap block and 32 * the free blocks count in the block. The descriptors are loaded in memory 85 /* check whether block bitmap block number is set */ ext2_valid_block_bitmap() 89 /* bad block bitmap */ ext2_valid_block_bitmap() 92 /* check whether the inode bitmap block number is set */ ext2_valid_block_bitmap() 96 /* bad block bitmap */ ext2_valid_block_bitmap() 99 /* check whether the inode table block number is set */ ext2_valid_block_bitmap() 111 "Invalid block bitmap - " ext2_valid_block_bitmap() 112 "block_group = %d, block = %lu", ext2_valid_block_bitmap() 119 * bits for block/inode/inode tables are set in the bitmaps 137 "Cannot read block bitmap - " read_block_bitmap() 148 "Cannot read block bitmap - " read_block_bitmap() 189 * __rsv_window_dump() -- Dump the filesystem block allocation reservation map 194 * If verbose is turned on, it will print the whole block reservation 250 * @grp_goal: given goal block relative to the allocation block group 251 * @group: the current allocation block group 252 * @sb: filesystem super block 254 * Test if the given goal block (group relative) is within the file's 255 * own block reservation window range. 258 * grp_goal (given goal block) could be -1, which means no specific 259 * goal block. In this case, always return 1. 260 * If the goal block is within the reservation window, return 1; 284 * @goal: target allocation block 323 * ext2_rsv_window_add() -- Insert a window to the block reservation rb tree. 324 * @sb: super block 361 * @sb: super block 364 * Mark the block reservation window as not allocated, and unlink it 381 * returns 1 if the end block is EXT2_RESERVE_WINDOW_NOT_ALLOCATED. 385 /* a valid reservation end block could not be 0 */ rsv_is_empty() 398 * needs a new block. So, before every ext2_new_block(s) call, for 401 * Fail to do so will result in block reservation being turned off for that 406 * is open for write (needs block allocation). 426 * block reservation is off ext2_init_block_alloc_info() 443 * Discard(free) block reservation window on last file close, or truncate 449 * ext2_truncate(): when the block indirect map is about to change. 473 * @block: start physical block to free 476 void ext2_free_blocks (struct inode * inode, unsigned long block, ext2_free_blocks() argument 491 if (block < le32_to_cpu(es->s_first_data_block) || ext2_free_blocks() 492 block + count < block || ext2_free_blocks() 493 block + count > le32_to_cpu(es->s_blocks_count)) { ext2_free_blocks() 496 "block = %lu, count = %lu", block, count); ext2_free_blocks() 500 ext2_debug ("freeing block(s) %lu-%lu\n", block, block + count - 1); ext2_free_blocks() 504 block_group = (block - le32_to_cpu(es->s_first_data_block)) / ext2_free_blocks() 506 bit = (block - le32_to_cpu(es->s_first_data_block)) % ext2_free_blocks() 525 if (in_range (le32_to_cpu(desc->bg_block_bitmap), block, count) || ext2_free_blocks() 526 in_range (le32_to_cpu(desc->bg_inode_bitmap), block, count) || ext2_free_blocks() 527 in_range (block, le32_to_cpu(desc->bg_inode_table), ext2_free_blocks() 529 in_range (block + count - 1, le32_to_cpu(desc->bg_inode_table), ext2_free_blocks() 534 block, count); ext2_free_blocks() 542 "bit already cleared for block %lu", block + i); ext2_free_blocks() 556 block += count; ext2_free_blocks() 571 * @start: the starting block (group relative) of the search 572 * @bh: bufferhead contains the block group bitmap 573 * @maxblocks: the ending block (group relative) of the reservation 592 * @start: the starting block (group relative) to find next 593 * allocatable block in bitmap. 594 * @bh: bufferhead contains the block group bitmap 595 * @maxblocks: the ending block (group relative) for the search 597 * Find an allocatable block in a bitmap. We perform the "most 598 * appropriate allocation" algorithm of looking for a free block near 611 * block within the next XX blocks. find_next_usable_block() 644 * @group: given allocation block group 645 * @bitmap_bh: bufferhead holds the block bitmap 646 * @grp_goal: given target block within the group 655 * if there is a reservation window, only try to allocate block(s) 657 * Otherwise, the allocation range starts from the give goal block, 658 * ends at the block group's last block. 660 * If we failed to allocate the desired block then we may end up crossing to a 719 * The block was allocated by another thread, or it was ext2_try_to_allocate() 759 * @group_first_block: the first block we consider to start 763 * the maximum block number that our goal reservable space 764 * could start from. This is normally the last block in this 870 * there, we check the bitmap for the first free block after 871 * it. If there is no free block until the end of group, then the 873 * block is inside the expected reservable space, if so, we 875 * If the first free block is outside the reservable space, then 876 * start from the first free block, we search for next available 880 * It contains at least one free block, and it does not overlap with other 890 * no goal(goal = -1), we start from the first block 893 * @sb: the super block 895 * @bitmap_bh: the block group block bitmap 931 * Maybe we could shift the start block of the reservation alloc_new_reservation() 932 * window to the first block of next group. alloc_new_reservation() 957 * shift the search start to the window near the goal block alloc_new_reservation() 983 * to make sure there is at least a free block inside this region. alloc_new_reservation() 985 * Search the first free bit on the block bitmap. Search starts from alloc_new_reservation() 986 * the start block of the reservable space we just found. alloc_new_reservation() 995 * no free block left on the bitmap, no point alloc_new_reservation() 1007 * check if the first free block is within the alloc_new_reservation() 1015 * start from where the free block is, alloc_new_reservation() 1026 * @sb: super block 1068 * @group: given allocation block group 1069 * @bitmap_bh: bufferhead holds the block bitmap 1070 * @grp_goal: given target block within the group 1074 * This is the main function used to allocate a new block and its reservation 1077 * Each time when a new block allocation is need, first try to allocate from 1081 * reservation window for it starting from the goal first. Then do the block 1085 * again when somebody is looking for a free block (without 1105 * or last attempt to allocate a block with reservation turned on failed ext2_try_to_allocate_with_rsv() 1112 * grp_goal is a group relative block number (if there is a goal) ext2_try_to_allocate_with_rsv() 1114 * first block is a filesystem wide block number ext2_try_to_allocate_with_rsv() 1115 * first block is the block number of the first block in this group ext2_try_to_allocate_with_rsv() 1121 * Basically we will allocate a new block from inode's reservation ext2_try_to_allocate_with_rsv() 1126 * b) last attempt to allocate a block from existing reservation ext2_try_to_allocate_with_rsv() 1177 * @sbi: in-core super block structure. 1179 * Check if filesystem has at least 1 free block available for allocation. 1197 * ext2_new_blocks() -- core block(s) allocation function 1199 * @goal: given target block(filesystem wide) 1203 * ext2_new_blocks uses a goal block to assist allocation. If the goal is 1204 * free, or there is a free block within 32 blocks of the goal, that block 1205 * is allocated. Otherwise a forward search is made for a free block; within 1206 * each block group the search first looks for an entire free byte in the block 1217 ext2_grpblk_t grp_target_blk; /* blockgroup relative goal block */ ext2_new_blocks() 1218 ext2_grpblk_t grp_alloc_blk; /* blockgroup-relative allocated block*/ ext2_new_blocks() 1219 ext2_fsblk_t ret_block; /* filesyetem-wide allocated block */ ext2_new_blocks() 1238 * Check quota for allocation of this block. ext2_new_blocks() 1250 * Allocate a block from reservation only when ext2_new_blocks() 1270 * First, test whether the goal block is free. ext2_new_blocks() 1341 * try to allocate block(s) from this group, without a goal(-1). ext2_new_blocks() 1353 * just do block allocation as without reservations. ext2_new_blocks() 1367 ext2_debug("using block group %d(%d)\n", ext2_new_blocks() 1379 "Allocating block in system zone - " ext2_new_blocks() 1394 "block("E2FSBLK") >= blocks count(%d) - " ext2_new_blocks() 1420 * Undo the block allocation ext2_new_blocks()
|
H A D | inode.c | 15 * Goal-directed block allocation by Stephen Tweedie 130 * ext2_block_to_path - parse the block number into array of offsets 132 * @i_block: block number to be parsed 134 * @boundary: set this non-zero if the referred-to block is likely to be 135 * followed (on disk) by an indirect block. 139 * This function translates the block number into path in that tree - 141 * pointer to (n+1)th node in the nth one. If @block is out of range 151 * indirect block) is spelled differently, because otherwise on an 172 "warning: %s: block < 0", __func__); ext2_block_to_path() 193 "warning: %s: block is too big", __func__); ext2_block_to_path() 212 * the number of (i+1)-th block in the chain (as it is stored in memory, 216 * block for i>0 and NULL for i==0. In other words, it holds the block 221 * Function stops when it stumbles upon zero pointer (absent block) 223 * or when it gets an IO error reading an indirect block 273 * @ind: descriptor of indirect block. 275 * This function returns the preferred place for block allocation. 278 * + if there is a block to the left of our position - allocate near it. 279 * + if pointer will live in indirect block - allocate near that block. 282 * In the latter case we colour the starting block by the callers PID to 284 * in the same block group. The PID is used here so that functionally related 298 /* Try to find previous block */ ext2_find_near() 303 /* No such thing, so let's try location of indirect block */ ext2_find_near() 320 * @block: block we want 323 * Returns preferred place for a block (the goal). 326 static inline ext2_fsblk_t ext2_find_goal(struct inode *inode, long block, ext2_find_goal() argument 337 if (block_i && (block == block_i->last_alloc_logical_block + 1) ext2_find_goal() 346 * ext2_blks_to_allocate: Look up the block map and count the number 352 * @blocks_to_boundary: the offset in the indirect block 364 * Simple case, [t,d]Indirect block(s) has not allocated yet ext2_blks_to_allocate() 389 * @new_blocks: on return it will store the new block numbers for 390 * the indirect blocks(if needed) and the first direct block, 409 * the first direct block of this branch. That's the ext2_alloc_blocks() 432 /* save the new block number for the first direct block */ ext2_alloc_blocks() 495 * Get buffer_head for parent block, zero it out ext2_alloc_branch() 545 * @block: (logical) number of block we are adding 552 * chain to new block and return 0. 555 long block, Indirect *where, int num, int blks) ext2_splice_branch() 579 * update the most recently allocated logical & physical block ext2_splice_branch() 580 * in i_block_alloc_info, to assist find the proper goal block for next ext2_splice_branch() 584 block_i->last_alloc_logical_block = block + blks - 1; ext2_splice_branch() 591 /* had we spliced it onto indirect block? */ ext2_splice_branch() 606 * write on the parent block. 642 /* Simplest case - block found, no allocation needed */ ext2_get_blocks() 653 * Indirect block might be removed by ext2_get_blocks() 672 /* Next simple case - plain lookup or failed read of indirect block */ ext2_get_blocks() 678 * If the indirect block is missing while we are reading ext2_get_blocks() 683 * the request block has been allocated or not. ext2_get_blocks() 685 * Since we already block the truncate/other get_block ext2_get_blocks() 706 * Okay, we need to do block allocation. Lazily initialize the block ext2_get_blocks() 735 * block must be initialised before we put it in the tree ext2_get_blocks() 848 static sector_t ext2_bmap(struct address_space *mapping, sector_t block) ext2_bmap() argument 850 return generic_block_bmap(mapping,block,ext2_get_block); ext2_bmap() 932 * it is on the path to the first completely truncated data block, indeed). 939 * We atomically detach the top of branch from the tree, store the block 980 * OK, we've found the last block that must survive. The rest of our ext2_find_shared() 1005 * @p: array of block numbers 1044 * @p: array of block numbers 1071 "Read failure, inode=%ld, block=%ld", ext2_free_branches() 1107 * From here we block out all ext2_get_block() callers who want to __ext2_truncate_blocks() 1108 * modify the block allocation tree. __ext2_truncate_blocks() 1234 unsigned long block; ext2_get_inode() local 1248 * Figure out the offset within the block group inode table ext2_get_inode() 1251 block = le32_to_cpu(gdp->bg_inode_table) + ext2_get_inode() 1253 if (!(bh = sb_bread(sb, block))) ext2_get_inode() 1266 "unable to read inode block - inode=%lu, block=%lu", ext2_get_inode() 1267 (unsigned long) ino, block); ext2_get_inode() 1383 * even on big-endian machines: we do NOT byteswap the block numbers! ext2_iget() 554 ext2_splice_branch(struct inode *inode, long block, Indirect *where, int num, int blks) ext2_splice_branch() argument
|
/linux-4.1.27/fs/udf/ |
H A D | partition.c | 29 uint32_t udf_get_pblock(struct super_block *sb, uint32_t block, udf_get_pblock() argument 35 udf_debug("block=%d, partition=%d, offset=%d: invalid partition\n", udf_get_pblock() 36 block, partition, offset); udf_get_pblock() 41 return map->s_partition_func(sb, block, partition, offset); udf_get_pblock() 43 return map->s_partition_root + block + offset; udf_get_pblock() 46 uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block, udf_get_pblock_virt15() argument 61 if (block > vdata->s_num_entries) { udf_get_pblock_virt15() 62 udf_debug("Trying to access block beyond end of VAT (%d max %d)\n", udf_get_pblock_virt15() 63 block, vdata->s_num_entries); udf_get_pblock_virt15() 69 vdata->s_start_offset))[block]); udf_get_pblock_virt15() 73 if (block >= index) { udf_get_pblock_virt15() 74 block -= index; udf_get_pblock_virt15() 75 newblock = 1 + (block / (sb->s_blocksize / sizeof(uint32_t))); udf_get_pblock_virt15() 76 index = block % (sb->s_blocksize / sizeof(uint32_t)); udf_get_pblock_virt15() 79 index = vdata->s_start_offset / sizeof(uint32_t) + block; udf_get_pblock_virt15() 87 sb, block, partition, loc, index); udf_get_pblock_virt15() 106 inline uint32_t udf_get_pblock_virt20(struct super_block *sb, uint32_t block, udf_get_pblock_virt20() argument 109 return udf_get_pblock_virt15(sb, block, partition, offset); udf_get_pblock_virt20() 112 uint32_t udf_get_pblock_spar15(struct super_block *sb, uint32_t block, udf_get_pblock_spar15() argument 124 packet = (block + offset) & ~(sdata->s_packet_len - 1); udf_get_pblock_spar15() 142 ((block + offset) & udf_get_pblock_spar15() 149 return map->s_partition_root + block + offset; udf_get_pblock_spar15() 280 static uint32_t udf_try_read_meta(struct inode *inode, uint32_t block, udf_try_read_meta() argument 291 if (inode_bmap(inode, block, &epos, &eloc, &elen, &ext_offset) != udf_try_read_meta() 305 uint32_t udf_get_pblock_meta25(struct super_block *sb, uint32_t block, udf_get_pblock_meta25() argument 322 retblk = udf_try_read_meta(inode, block, partition, offset); udf_get_pblock_meta25() 334 retblk = udf_try_read_meta(inode, block, partition, offset); udf_get_pblock_meta25()
|
H A D | misc.c | 31 struct buffer_head *udf_tgetblk(struct super_block *sb, int block) udf_tgetblk() argument 34 return sb_getblk(sb, udf_fixed_to_variable(block)); udf_tgetblk() 36 return sb_getblk(sb, block); udf_tgetblk() 39 struct buffer_head *udf_tread(struct super_block *sb, int block) udf_tread() argument 42 return sb_bread(sb, udf_fixed_to_variable(block)); udf_tread() 44 return sb_bread(sb, block); udf_tread() 195 * Read the first block of a tagged descriptor. 201 struct buffer_head *udf_read_tagged(struct super_block *sb, uint32_t block, udf_read_tagged() argument 208 /* Read the block */ udf_read_tagged() 209 if (block == 0xFFFFFFFF) udf_read_tagged() 212 bh = udf_tread(sb, block); udf_read_tagged() 214 udf_err(sb, "read failed, block=%u, location=%d\n", udf_read_tagged() 215 block, location); udf_read_tagged() 224 udf_debug("location mismatch block %u, tag %u != %u\n", udf_read_tagged() 225 block, le32_to_cpu(tag_p->tagLocation), location); udf_read_tagged() 232 udf_err(sb, "tag checksum failed, block %u: 0x%02x != 0x%02x\n", udf_read_tagged() 233 block, checksum, tag_p->tagChecksum); udf_read_tagged() 240 udf_err(sb, "tag version 0x%04x != 0x0002 || 0x0003, block %u\n", udf_read_tagged() 241 le16_to_cpu(tag_p->descVersion), block); udf_read_tagged() 252 udf_debug("Crc failure block %d: crc = %d, crclen = %d\n", block, udf_read_tagged()
|
H A D | balloc.c | 35 struct udf_bitmap *bitmap, unsigned int block, read_block_bitmap() 45 bh = udf_tread(sb, udf_get_lb_pblock(sb, &loc, block)); read_block_bitmap() 114 unsigned long block; udf_bitmap_free_blocks() local 132 block = bloc->logicalBlockNum + offset + udf_bitmap_free_blocks() 137 block_group = block >> (sb->s_blocksize_bits + 3); udf_bitmap_free_blocks() 138 bit = block % (sb->s_blocksize << 3); udf_bitmap_free_blocks() 162 block += count; udf_bitmap_free_blocks() 178 int bit, block, block_group, group_start; udf_bitmap_prealloc_blocks() local 193 block = first_block + (sizeof(struct spaceBitmapDesc) << 3); udf_bitmap_prealloc_blocks() 194 block_group = block >> (sb->s_blocksize_bits + 3); udf_bitmap_prealloc_blocks() 202 bit = block % (sb->s_blocksize << 3); udf_bitmap_prealloc_blocks() 210 block++; udf_bitmap_prealloc_blocks() 226 int newbit, bit = 0, block, block_group, group_start; udf_bitmap_new_block() local 240 block = goal + (sizeof(struct spaceBitmapDesc) << 3); udf_bitmap_new_block() 241 block_group = block >> (sb->s_blocksize_bits + 3); udf_bitmap_new_block() 252 bit = block % (sb->s_blocksize << 3); udf_bitmap_new_block() 329 udf_debug("bit already cleared for block %d\n", bit); udf_bitmap_new_block() 380 epos.block = oepos.block = iinfo->i_location; udf_table_free_blocks() 425 oepos.block = epos.block; udf_table_free_blocks() 438 * allocate a new block, and since we hold the super block udf_table_free_blocks() 442 * trying to allocate a new block close to the existing one, udf_table_free_blocks() 443 * we just steal a block from the extent we are trying to add. udf_table_free_blocks() 475 /* Steal a block from the extent being free'd */ udf_table_free_blocks() 476 epos.block.logicalBlockNum = eloc.logicalBlockNum; udf_table_free_blocks() 481 udf_get_lb_pblock(sb, &epos.block, 0)); udf_table_free_blocks() 488 cpu_to_le32(oepos.block.logicalBlockNum); udf_table_free_blocks() 518 3, 1, epos.block.logicalBlockNum, udf_table_free_blocks() 522 2, 1, epos.block.logicalBlockNum, udf_table_free_blocks() 532 cpu_to_le32(epos.block.logicalBlockNum); udf_table_free_blocks() 540 cpu_to_lelb(epos.block); udf_table_free_blocks() 551 /* It's possible that stealing the block emptied the extent */ udf_table_free_blocks() 600 epos.block = iinfo->i_location; udf_table_prealloc_blocks() 662 /* We search for the closest matching block to goal. If we find udf_table_new_block() 668 epos.block = iinfo->i_location; udf_table_new_block() 691 goal_epos.block = epos.block; udf_table_new_block() 796 int block; udf_new_block() local 799 block = udf_bitmap_new_block(sb, udf_new_block() 803 block = udf_table_new_block(sb, udf_new_block() 807 block = udf_bitmap_new_block(sb, udf_new_block() 811 block = udf_table_new_block(sb, udf_new_block() 818 if (inode && block) udf_new_block() 820 return block; udf_new_block() 34 read_block_bitmap(struct super_block *sb, struct udf_bitmap *bitmap, unsigned int block, unsigned long bitmap_nr) read_block_bitmap() argument
|
/linux-4.1.27/sound/soc/intel/atom/sst/ |
H A D | sst_pvt.c | 85 * @block: Driver block to wait on 88 * given block event 91 struct sst_block *block) sst_wait_interruptible() 96 block->condition)) { sst_wait_interruptible() 98 if (block->ret_code < 0) { sst_wait_interruptible() 100 "stream failed %d\n", block->ret_code); sst_wait_interruptible() 118 * @block: Driver block to wait on 121 * given block event 123 int sst_wait_timeout(struct intel_sst_drv *sst_drv_ctx, struct sst_block *block) sst_wait_timeout() argument 134 block->condition, block->msg_id, block->drv_id); sst_wait_timeout() 136 block->condition, sst_wait_timeout() 140 block->condition); sst_wait_timeout() 142 block->ret_code); sst_wait_timeout() 143 retval = -block->ret_code; sst_wait_timeout() 145 block->on = false; sst_wait_timeout() 148 block->condition, block->msg_id, sst_drv_ctx->sst_state); sst_wait_timeout() 187 * sst_create_block_and_ipc_msg - Creates IPC message and sst block 191 * @block: return block allocated 196 struct intel_sst_drv *sst_drv_ctx, struct sst_block **block, sst_create_block_and_ipc_msg() 204 *block = sst_create_block(sst_drv_ctx, msg_id, drv_id); sst_create_block_and_ipc_msg() 205 if (*block == NULL) { sst_create_block_and_ipc_msg() 236 struct sst_block *block; sst_prepare_and_post_msg() local 245 &msg, large, sst, &block, ipc_msg, pvt_id); sst_prepare_and_post_msg() 281 ret = sst_wait_timeout(sst, block); sst_prepare_and_post_msg() 284 } else if(block->data) { sst_prepare_and_post_msg() 287 *data = kzalloc(block->size, GFP_KERNEL); sst_prepare_and_post_msg() 292 memcpy(data, (void *) block->data, block->size); sst_prepare_and_post_msg() 297 sst_free_block(sst, block); sst_prepare_and_post_msg() 90 sst_wait_interruptible(struct intel_sst_drv *sst_drv_ctx, struct sst_block *block) sst_wait_interruptible() argument 195 sst_create_block_and_ipc_msg(struct ipc_post **arg, bool large, struct intel_sst_drv *sst_drv_ctx, struct sst_block **block, u32 msg_id, u32 drv_id) sst_create_block_and_ipc_msg() argument
|
H A D | sst_ipc.c | 62 * passed and search that for block threads. 63 * We will not find block in two cases 64 * a) when its small message and block in not there, so silently ignore 66 * b) when we are actually not able to find the block (bug perhaps) 75 struct sst_block *block = NULL; sst_wake_up_block() local 80 list_for_each_entry(block, &ctx->block_list, node) { sst_wake_up_block() 81 dev_dbg(ctx->dev, "Block ipc %d, drv_id %d\n", block->msg_id, sst_wake_up_block() 82 block->drv_id); sst_wake_up_block() 83 if (block->msg_id == ipc && block->drv_id == drv_id) { sst_wake_up_block() 84 dev_dbg(ctx->dev, "free up the block\n"); sst_wake_up_block() 85 block->ret_code = result; sst_wake_up_block() 86 block->data = data; sst_wake_up_block() 87 block->size = size; sst_wake_up_block() 88 block->condition = true; sst_wake_up_block() 103 struct sst_block *block = NULL, *__block; sst_free_block() local 107 list_for_each_entry_safe(block, __block, &ctx->block_list, node) { sst_free_block() 108 if (block == freed) { sst_free_block() 120 dev_err(ctx->dev, "block is already freed!!!\n"); sst_free_block()
|
H A D | sst_loader.c | 177 * Create the memcpy list as the number of block to be copied 183 struct fw_block_info *block; sst_parse_module_memcpy() local 193 block = (void *)module + sizeof(*module); sst_parse_module_memcpy() 196 if (block->size <= 0) { sst_parse_module_memcpy() 197 dev_err(sst_drv_ctx->dev, "block size invalid\n"); sst_parse_module_memcpy() 200 switch (block->type) { sst_parse_module_memcpy() 211 block = (void *)block + sizeof(*block) + block->size; sst_parse_module_memcpy() 215 block->type, count); sst_parse_module_memcpy() 220 ram_iomem + block->ram_offset, sst_parse_module_memcpy() 221 (void *)block + sizeof(*block), block->size, 1); sst_parse_module_memcpy() 225 block = (void *)block + sizeof(*block) + block->size; sst_parse_module_memcpy() 403 struct sst_block *block; sst_load_fw() local 419 block = sst_create_block(sst_drv_ctx, 0, FW_DWNL_ID); sst_load_fw() 420 if (block == NULL) sst_load_fw() 443 ret_val = sst_wait_timeout(sst_drv_ctx, block); sst_load_fw() 455 sst_free_block(sst_drv_ctx, block); sst_load_fw()
|
/linux-4.1.27/drivers/acpi/acpica/ |
H A D | evgpeblk.c | 3 * Module Name: evgpeblk - GPE block creation and initialization. 64 * PARAMETERS: gpe_block - New GPE block 66 * GPE block 70 * DESCRIPTION: Install new GPE block with mutex support 96 /* Install the new block at the end of the list with lock */ acpi_ev_install_gpe_block() 123 * PARAMETERS: gpe_block - Existing GPE block 127 * DESCRIPTION: Remove a GPE block 143 /* Disable all GPEs in this block */ acpi_ev_delete_gpe_block() 157 /* Remove the block on this interrupt with lock */ acpi_ev_delete_gpe_block() 190 * PARAMETERS: gpe_block - New GPE block 194 * DESCRIPTION: Create the register_info and event_info blocks for this GPE block 211 /* Allocate the GPE register information block */ acpi_ev_create_gpe_info_blocks() 224 * Allocate the GPE event_info block. There are eight distinct GPEs acpi_ev_create_gpe_info_blocks() 237 /* Save the new Info arrays in the GPE block */ acpi_ev_create_gpe_info_blocks() 245 * sets in a given GPE hardware block, the status registers occupy the acpi_ev_create_gpe_info_blocks() 316 * PARAMETERS: gpe_device - Handle to the parent GPE block 318 * register_count - Number of GPE register pairs in the block 319 * gpe_block_base_number - Starting GPE number for the block 320 * interrupt_number - H/W interrupt for the block 321 * return_gpe_block - Where the new block descriptor is returned 325 * DESCRIPTION: Create and Install a block of GPE registers. All GPEs within 326 * the block are disabled at exit. 350 /* Allocate a new GPE block */ acpi_ev_create_gpe_block() 357 /* Initialize the new GPE block */ acpi_ev_create_gpe_block() 369 * Note: disables and clears all GPEs in the block acpi_ev_create_gpe_block() 377 /* Install the new block in the global lists */ acpi_ev_create_gpe_block() 389 /* Find all GPE methods (_Lxx or_Exx) for this block */ acpi_ev_create_gpe_block() 400 /* Return the new block */ acpi_ev_create_gpe_block() 430 * DESCRIPTION: Initialize and enable a GPE block. Enable GPEs that have 451 * Ignore a null GPE block (e.g., if no GPE block 1 exists), and acpi_ev_initialize_gpe_block() 460 * ACPI_GPE_CAN_WAKE flag unset. Any other GPEs within this block acpi_ev_initialize_gpe_block() 468 /* Get the info block for this particular GPE */ acpi_ev_initialize_gpe_block() 502 "Enabled %u GPEs in block %02X to %02X", acpi_ev_initialize_gpe_block()
|
H A D | evgpeutil.c | 56 * PARAMETERS: gpe_walk_callback - Routine called for each GPE block 86 /* One callback per GPE block */ acpi_ev_walk_gpe_list() 118 * block device. NULL if the GPE is one of the FADT-defined GPEs. 128 /* Increment Index by the number of GPEs in this block */ acpi_ev_get_gpe_device() 134 * The GPE index is within this block, get the node. Leave the node acpi_ev_get_gpe_device() 152 * PARAMETERS: interrupt_number - Interrupt for a GPE block 153 * gpe_xrupt_block - Where the block is returned 157 * DESCRIPTION: Get or Create a GPE interrupt block. There is one interrupt 158 * block per unique interrupt level used for GPEs. Should be 235 * PARAMETERS: gpe_xrupt - A GPE interrupt info block 239 * DESCRIPTION: Remove and free a gpe_xrupt block. Remove an associated 267 /* Unlink the interrupt block with lock */ acpi_ev_delete_gpe_xrupt() 283 /* Free the block */ acpi_ev_delete_gpe_xrupt() 316 /* Examine each GPE Register within the block */ acpi_ev_delete_gpe_handlers() 332 /* Delete an installed handler block */ acpi_ev_delete_gpe_handlers()
|
/linux-4.1.27/fs/affs/ |
H A D | affs.h | 36 u32 ext; /* idx of the extended block */ 37 u32 key; /* block number */ 48 u32 i_blkcnt; /* block count */ 49 u32 i_extcnt; /* extended block count */ 55 u32 i_ext_last; /* last accessed extended block */ 56 struct buffer_head *i_ext_bh; /* bh of last extended block */ 59 u32 i_lastalloc; /* last allocated block */ 71 * super-block data in memory 78 u32 bm_key; /* Disk block number */ 86 u32 s_data_blksize; /* size of the data block w/o header */ 87 u32 s_root_block; /* FFS root block number. */ 93 struct buffer_head *s_root_bh; /* Cached root block. */ 158 extern void affs_free_block(struct super_block *sb, u32 block); 221 affs_bread(struct super_block *sb, int block) affs_bread() argument 223 pr_debug("%s: %d\n", __func__, block); affs_bread() 224 if (block >= AFFS_SB(sb)->s_reserved && block < AFFS_SB(sb)->s_partition_size) affs_bread() 225 return sb_bread(sb, block); affs_bread() 229 affs_getblk(struct super_block *sb, int block) affs_getblk() argument 231 pr_debug("%s: %d\n", __func__, block); affs_getblk() 232 if (block >= AFFS_SB(sb)->s_reserved && block < AFFS_SB(sb)->s_partition_size) affs_getblk() 233 return sb_getblk(sb, block); affs_getblk() 237 affs_getzeroblk(struct super_block *sb, int block) affs_getzeroblk() argument 240 pr_debug("%s: %d\n", __func__, block); affs_getzeroblk() 241 if (block >= AFFS_SB(sb)->s_reserved && block < AFFS_SB(sb)->s_partition_size) { affs_getzeroblk() 242 bh = sb_getblk(sb, block); affs_getzeroblk() 252 affs_getemptyblk(struct super_block *sb, int block) affs_getemptyblk() argument 255 pr_debug("%s: %d\n", __func__, block); affs_getemptyblk() 256 if (block >= AFFS_SB(sb)->s_reserved && block < AFFS_SB(sb)->s_partition_size) { affs_getemptyblk() 257 bh = sb_getblk(sb, block); affs_getemptyblk()
|
H A D | bitmap.c | 7 * block allocation, deallocation, calculation of free space. 38 affs_free_block(struct super_block *sb, u32 block) affs_free_block() argument 46 pr_debug("%s(%u)\n", __func__, block); affs_free_block() 48 if (block > sbi->s_partition_size) affs_free_block() 51 blk = block - sbi->s_reserved; affs_free_block() 71 /* mark block free */ affs_free_block() 89 affs_warning(sb,"affs_free_block","Trying to free block %u which is already free", block); affs_free_block() 94 affs_error(sb,"affs_free_block","Cannot read bitmap block %u", bm->bm_key); affs_free_block() 101 affs_error(sb, "affs_free_block","Block %u outside partition", block); affs_free_block() 105 * Allocate a block in the given allocation zone. 139 // affs_warning(sb, "affs_balloc", "no last alloc block"); affs_alloc_block() 180 /* find an unused block in this bitmap block */ affs_alloc_block() 234 affs_error(sb,"affs_read_block","Cannot read bitmap block %u", bm->bm_key); affs_alloc_block() 293 pr_debug("read bitmap block %d: %d\n", blk, bm->bm_key); affs_init_bitmap() 296 /* Don't try read the extension if this is the last block, affs_init_bitmap() 342 /* recalculate bitmap count for last block */ affs_init_bitmap()
|
H A D | inode.c | 22 u32 block; affs_iget() local 35 block = inode->i_ino; affs_iget() 36 bh = affs_bread(sb, block); affs_iget() 38 affs_warning(sb, "read_inode", "Cannot read block %d", block); affs_iget() 44 AFFS_HEAD(bh)->ptype, block); affs_iget() 177 // possibly free block affs_write_inode() 181 affs_error(sb,"write_inode","Cannot read block %lu",inode->i_ino); affs_write_inode() 292 u32 block; affs_new_inode() local 298 if (!(block = affs_alloc_block(dir, dir->i_ino))) affs_new_inode() 301 bh = affs_getzeroblk(sb, block); affs_new_inode() 309 inode->i_ino = block; affs_new_inode() 332 affs_free_block(sb, block); affs_new_inode() 340 * Add an entry to a directory. Create the header block 350 u32 block = 0; affs_add_entry() local 366 block = affs_alloc_block(dir, dir->i_ino); affs_add_entry() 367 if (!block) affs_add_entry() 371 bh = affs_getzeroblk(sb, block); affs_add_entry() 390 AFFS_TAIL(sb, inode_bh)->link_chain = cpu_to_be32(block); affs_add_entry() 391 affs_adjust_checksum(inode_bh, block - be32_to_cpu(chain)); affs_add_entry() 412 if (block) affs_add_entry() 413 affs_free_block(sb, block); affs_add_entry()
|
/linux-4.1.27/drivers/misc/ |
H A D | sram.c | 64 struct sram_reserve *rblocks, *block; sram_probe() local 104 * We need an additional block to mark the end of the memory region sram_probe() 114 block = &rblocks[0]; for_each_available_child_of_node() 128 "reserved block %s outside the sram area\n", for_each_available_child_of_node() 134 block->start = child_res.start - res->start; for_each_available_child_of_node() 135 block->size = resource_size(&child_res); for_each_available_child_of_node() 136 list_add_tail(&block->list, &reserve_list); for_each_available_child_of_node() 138 dev_dbg(&pdev->dev, "found reserved block 0x%x-0x%x\n", for_each_available_child_of_node() 139 block->start, for_each_available_child_of_node() 140 block->start + block->size); for_each_available_child_of_node() 142 block++; for_each_available_child_of_node() 154 list_for_each_entry(block, &reserve_list, list) { 156 if (block->start < cur_start) { 158 "block at 0x%x starts after current offset 0x%lx\n", 159 block->start, cur_start); 164 /* current start is in a reserved block, so continue after it */ 165 if (block->start == cur_start) { 166 cur_start = block->start + block->size; 172 * address and the following reserved block, or the 175 cur_size = block->start - cur_start; 185 /* next allocation after this reserved block */ 186 cur_start = block->start + block->size;
|
H A D | atmel_tclib.c | 36 * atmel_tc_alloc - allocate a specified TC block 37 * @block: which block to allocate 39 * Caller allocates a block. If it is available, a pointer to a 43 struct atmel_tc *atmel_tc_alloc(unsigned block) atmel_tc_alloc() argument 53 if ((tc->pdev->dev.of_node && tc->id == block) || atmel_tc_alloc() 54 (tc->pdev->id == block)) { atmel_tc_alloc() 67 * atmel_tc_free - release a specified TC block 68 * @tc: Timer/counter block that was returned by atmel_tc_alloc()
|
/linux-4.1.27/block/partitions/ |
H A D | mac.h | 14 __be32 start_block; /* absolute starting block # of partition */ 18 __be32 data_start; /* rel block # of first data block */ 36 /* Driver descriptor structure, in block 0 */
|
H A D | cmdline.c | 5 * Read block device partition table from the command line. 6 * Typically used for fixed block (eMMC) embedded devices. 8 * by absolute address of data on the block device. 13 * For further information, see "Documentation/block/cmdline-partition.txt"
|
H A D | sysv68.c | 20 * config block: second 256-bytes sector on disk 25 __be32 ios_slcblk; /* Slice table block number */ 31 * combined volumeid and dkconfig block 45 __be32 blkoff; /* block offset of slice */
|
H A D | amiga.c | 4 * Code extracted from drivers/block/genhd.c 35 int blksize = 1; /* Multiplier for disk block size */ amiga_partition() 45 pr_err("Dev %s: unable to read RDB block %d\n", amiga_partition() 62 pr_err("Trashed word at 0xd0 in block %d ignored in checksum calculation\n", amiga_partition() 67 pr_err("Dev %s: RDB in block %d has bad checksum\n", amiga_partition() 71 /* blksize is blocks per 512 byte standard block */ amiga_partition() 88 pr_err("Dev %s: unable to read partition block %d\n", amiga_partition()
|
H A D | ultrix.c | 4 * Code extracted from drivers/block/genhd.c 22 u32 pi_blkoff; /* block offset for start */ ultrix_partition()
|
/linux-4.1.27/include/linux/mtd/ |
H A D | nand_ecc.h | 21 * Calculate 3 byte ECC code for eccsize byte block 27 * Calculate 3 byte ECC code for 256/512 byte block 32 * Detect and correct a 1 bit error for eccsize byte block 38 * Detect and correct a 1 bit error for 256/512 byte block
|
H A D | bbm.h | 35 * struct nand_bbt_descr - bad block table descriptor 48 * bad) block in the stored bbt 49 * @pattern: pattern to identify bad block table or factory marked good / 52 * Descriptor for the bad block table marker and the descriptor for the 55 * of the first block. 69 /* Options for the bad block table descriptors */ 71 /* The number of bits used per block in the bbt on the device */ 77 /* The bad block table is in the last good block of the device */ 96 /* Read and write back block contents when writing bbt */ 103 * Use a flash based bad block table. By default, OOB identifier is saved in 104 * OOB area. This option is passed to the default bad block table function. 108 * Do not store flash based bad block table marker in the OOB area; store it 113 * Do not write new bad block markers to OOB; useful, e.g., when ECC covers 136 * Bad block scanning errors 145 * @badblockpos: [INTERN] position of the bad block marker in the oob area 147 * @bbt: [INTERN] bad block table pointer 148 * @isbad_bbt: function to determine if a block is bad 149 * @badblock_pattern: [REPLACEABLE] bad block scan pattern used for 150 * initial bad block scan
|
H A D | nftl.h | 29 #define BLOCK_NIL 0xffff /* last block of a chain */ 30 #define BLOCK_FREE 0xfffe /* free block */ 31 #define BLOCK_NOTEXPLORED 0xfffd /* non explored block, only used during mounting */ 32 #define BLOCK_RESERVED 0xfffc /* bios block or bad block */ 57 int NFTL_formatblock(struct NFTLrecord *s, int block);
|
/linux-4.1.27/net/mac80211/ |
H A D | michael.c | 60 size_t block, blocks, left; michael_mic() local 69 for (block = 0; block < blocks; block++) michael_mic() 70 michael_block(&mctx, get_unaligned_le32(&data[block * 4])); michael_mic() 72 /* Partial block of 0..3 bytes and padding: 0x5a + 4..7 zeros to make michael_mic()
|
/linux-4.1.27/drivers/platform/x86/ |
H A D | wmi.c | 74 * If the GUID data block is marked as expensive, we must enable and 146 * @src: Memory block holding binary GUID (16 bytes) 147 * @dest: Memory block to hold byte swapped binary GUID (16 bytes) 170 * @dest: Memory block to hold binary GUID (16 bytes) 229 struct guid_block *block; find_guid() local 237 block = &wblock->gblock; find_guid() 239 if (memcmp(block->guid, guid_input, 16) == 0) { find_guid() 250 struct guid_block *block = NULL; wmi_method_enable() local 255 block = &wblock->gblock; wmi_method_enable() 258 snprintf(method, 5, "WE%02X", block->notify_id); wmi_method_enable() 283 struct guid_block *block = NULL; wmi_evaluate_method() local 294 block = &wblock->gblock; wmi_evaluate_method() 297 if (!(block->flags & ACPI_WMI_METHOD)) wmi_evaluate_method() 300 if (block->instance_count < instance) wmi_evaluate_method() 313 if (block->flags & ACPI_WMI_STRING) { wmi_evaluate_method() 322 strncat(method, block->object_id, 2); wmi_evaluate_method() 331 * wmi_query_block - Return contents of a WMI block 334 * &out: Empty buffer to return the contents of the data block to 336 * Return the contents of an ACPI-WMI data block to a buffer 341 struct guid_block *block = NULL; wmi_query_block() local 356 block = &wblock->gblock; wmi_query_block() 359 if (block->instance_count < instance) wmi_query_block() 362 /* Check GUID is a data block */ wmi_query_block() 363 if (block->flags & (ACPI_WMI_EVENT | ACPI_WMI_METHOD)) wmi_query_block() 375 if (block->flags & ACPI_WMI_EXPENSIVE) { wmi_query_block() 376 strncat(wc_method, block->object_id, 2); wmi_query_block() 389 strncat(method, block->object_id, 2); wmi_query_block() 397 if ((block->flags & ACPI_WMI_EXPENSIVE) && ACPI_SUCCESS(wc_status)) { wmi_query_block() 406 * wmi_set_block - Write to a WMI block 409 * &in: Buffer containing new values for the data block 411 * Write the contents of the input buffer to an ACPI-WMI data block 416 struct guid_block *block = NULL; wmi_set_block() local 429 block = &wblock->gblock; wmi_set_block() 432 if (block->instance_count < instance) wmi_set_block() 435 /* Check GUID is a data block */ wmi_set_block() 436 if (block->flags & (ACPI_WMI_EVENT | ACPI_WMI_METHOD)) wmi_set_block() 444 if (block->flags & ACPI_WMI_STRING) { wmi_set_block() 452 strncat(method, block->object_id, 2); wmi_set_block() 531 struct wmi_block *block; wmi_install_notify_handler() local 544 block = list_entry(p, struct wmi_block, list); wmi_install_notify_handler() 546 if (memcmp(block->gblock.guid, guid_input, 16) == 0) { wmi_install_notify_handler() 547 if (block->handler && wmi_install_notify_handler() 548 block->handler != wmi_notify_debug) wmi_install_notify_handler() 551 block->handler = handler; wmi_install_notify_handler() 552 block->handler_data = data; wmi_install_notify_handler() 554 wmi_status = wmi_method_enable(block, 1); wmi_install_notify_handler() 572 struct wmi_block *block; wmi_remove_notify_handler() local 585 block = list_entry(p, struct wmi_block, list); wmi_remove_notify_handler() 587 if (memcmp(block->gblock.guid, guid_input, 16) == 0) { wmi_remove_notify_handler() 588 if (!block->handler || wmi_remove_notify_handler() 589 block->handler == wmi_notify_debug) wmi_remove_notify_handler() 593 block->handler = wmi_notify_debug; wmi_remove_notify_handler() 596 wmi_status = wmi_method_enable(block, 0); wmi_remove_notify_handler() 597 block->handler = NULL; wmi_remove_notify_handler() 598 block->handler_data = NULL; wmi_remove_notify_handler() 877 struct guid_block *block; acpi_wmi_notify() local 884 block = &wblock->gblock; acpi_wmi_notify() 886 if ((block->flags & ACPI_WMI_EVENT) && acpi_wmi_notify() 887 (block->notify_id == event)) { acpi_wmi_notify()
|
/linux-4.1.27/drivers/net/wan/ |
H A D | hd64570.h | 107 #define BARL 0x00 /* Buffer Address L (chained block) */ 108 #define BARH 0x01 /* Buffer Address H (chained block) */ 109 #define BARB 0x02 /* Buffer Address B (chained block) */ 111 #define DARL 0x00 /* RX Destination Addr L (single block) */ 112 #define DARH 0x01 /* RX Destination Addr H (single block) */ 113 #define DARB 0x02 /* RX Destination Addr B (single block) */ 115 #define SARL 0x04 /* TX Source Address L (single block) */ 116 #define SARH 0x05 /* TX Source Address H (single block) */ 117 #define SARB 0x06 /* TX Source Address B (single block) */ 119 #define CPB 0x06 /* Chain Pointer Base (chained block) */ 121 #define CDAL 0x08 /* Current Descriptor Addr L (chained block) */ 122 #define CDAH 0x09 /* Current Descriptor Addr H (chained block) */ 123 #define EDAL 0x0A /* Error Descriptor Addr L (chained block) */ 124 #define EDAH 0x0B /* Error Descriptor Addr H (chained block) */ 125 #define BFLL 0x0C /* RX Receive Buffer Length L (chained block)*/ 126 #define BFLH 0x0D /* RX Receive Buffer Length H (chained block)*/ 174 #define DIR_EOME 0x40 /* Frame Transfer Completed (chained-block) */ 175 #define DIR_BOFE 0x20 /* Buffer Overflow/Underflow (chained-block)*/ 176 #define DIR_COFE 0x10 /* Counter Overflow (chained-block) */ 180 #define DSR_EOM 0x40 /* Frame Transfer Completed (chained-block) */ 181 #define DSR_BOF 0x20 /* Buffer Overflow/Underflow (chained-block)*/ 182 #define DSR_COF 0x10 /* Counter Overflow (chained-block) */
|
/linux-4.1.27/drivers/edac/ |
H A D | edac_device_sysfs.c | 413 /* edac_dev -> instance -> block information */ 420 * Set of low-level block attribute show functions 425 struct edac_device_block *block = to_block(kobj); block_ue_count_show() local 427 return sprintf(data, "%u\n", block->counters.ue_count); block_ue_count_show() 433 struct edac_device_block *block = to_block(kobj); block_ce_count_show() local 435 return sprintf(data, "%u\n", block->counters.ce_count); block_ce_count_show() 438 /* DEVICE block kobject release() function */ edac_device_ctrl_block_release() 441 struct edac_device_block *block; edac_device_ctrl_block_release() local 446 block = to_block(kobj); edac_device_ctrl_block_release() 448 /* map from 'block kobj' to 'block->instance->controller->main_kobj' edac_device_ctrl_block_release() 449 * now 'release' the block kobject edac_device_ctrl_block_release() 451 kobject_put(&block->instance->ctl->kobj); edac_device_ctrl_block_release() 455 /* Function to 'show' fields from the edac_dev 'block' structure */ edac_dev_block_show() 467 /* Function to 'store' fields into the edac_dev 'block' structure */ edac_dev_block_store() 481 /* edac_dev file operations for a 'block' */ 497 /* list of edac_dev 'block' attributes */ 504 /* The 'ktype' for each edac_dev 'block' */ 511 /* block ctor/dtor code */ 518 struct edac_device_block *block) edac_device_create_block() 525 edac_dbg(4, "Instance '%s' inst_p=%p block '%s' block_p=%p\n", edac_device_create_block() 526 instance->name, instance, block->name, block); edac_device_create_block() 527 edac_dbg(4, "block kobj=%p block kobj->parent=%p\n", edac_device_create_block() 528 &block->kobj, &block->kobj.parent); edac_device_create_block() 530 /* init this block's kobject */ edac_device_create_block() 531 memset(&block->kobj, 0, sizeof(struct kobject)); edac_device_create_block() 542 /* Add this block's kobject */ edac_device_create_block() 543 err = kobject_init_and_add(&block->kobj, &ktype_block_ctrl, edac_device_create_block() 545 "%s", block->name); edac_device_create_block() 547 edac_dbg(1, "Failed to register instance '%s'\n", block->name); edac_device_create_block() 553 /* If there are driver level block attributes, then added them edac_device_create_block() 554 * to the block kobject edac_device_create_block() 556 sysfs_attrib = block->block_attributes; edac_device_create_block() 557 if (sysfs_attrib && block->nr_attribs) { edac_device_create_block() 558 for (i = 0; i < block->nr_attribs; i++, sysfs_attrib++) { edac_device_create_block() 560 edac_dbg(4, "creating block attrib='%s' attrib->%p to kobj=%p\n", edac_device_create_block() 562 sysfs_attrib, &block->kobj); edac_device_create_block() 565 err = sysfs_create_file(&block->kobj, edac_device_create_block() 571 kobject_uevent(&block->kobj, KOBJ_ADD); edac_device_create_block() 577 kobject_put(&block->kobj); edac_device_create_block() 584 * edac_device_delete_block(edac_dev,block); 587 struct edac_device_block *block) edac_device_delete_block() 592 /* if this block has 'attributes' then we need to iterate over the list edac_device_delete_block() 593 * and 'remove' the attributes on this block edac_device_delete_block() 595 sysfs_attrib = block->block_attributes; edac_device_delete_block() 596 if (sysfs_attrib && block->nr_attribs) { edac_device_delete_block() 597 for (i = 0; i < block->nr_attribs; i++, sysfs_attrib++) { edac_device_delete_block() 600 sysfs_remove_file(&block->kobj, edac_device_delete_block() 605 /* unregister this block's kobject, SEE: edac_device_delete_block() 608 kobject_put(&block->kobj); edac_device_delete_block() 801 * created. 'instance' and 'block' kobjects should be registered 802 * along with any 'block' attributes from the low driver. In addition, 877 /* walk the instance/block kobject tree, deconstructing it */ edac_device_remove_sysfs() 516 edac_device_create_block(struct edac_device_ctl_info *edac_dev, struct edac_device_instance *instance, struct edac_device_block *block) edac_device_create_block() argument 586 edac_device_delete_block(struct edac_device_ctl_info *edac_dev, struct edac_device_block *block) edac_device_delete_block() argument
|
H A D | edac_device.c | 82 unsigned instance, block, attr; edac_device_alloc_ctl_info() local 90 * (instance,block,attrib) from the start of an allocated structure. edac_device_alloc_ctl_info() 91 * We want the alignment of each item (instance,block,attrib) edac_device_alloc_ctl_info() 104 * which will become the start of the block array edac_device_alloc_ctl_info() 174 /* Initialize every block in each instance */ edac_device_alloc_ctl_info() 175 for (block = 0; block < nr_blocks; block++) { edac_device_alloc_ctl_info() 176 blk = &blk_p[block]; edac_device_alloc_ctl_info() 179 "%s%d", edac_block_name, block+offset_value); edac_device_alloc_ctl_info() 181 edac_dbg(4, "instance=%d inst_p=%p block=#%d block_p=%p name='%s'\n", edac_device_alloc_ctl_info() 182 instance, inst, block, blk, blk->name); edac_device_alloc_ctl_info() 185 * then continue on to next block iteration edac_device_alloc_ctl_info() 190 /* setup the attribute array for this block */ edac_device_alloc_ctl_info() 192 attrib_p = &dev_attrib[block*nr_instances*nr_attrib]; edac_device_alloc_ctl_info() 199 * block with the data the caller passed in edac_device_alloc_ctl_info() 200 * Each block gets its own copy of pointers, edac_device_alloc_ctl_info() 213 attrib->block = blk; /* up link */ edac_device_alloc_ctl_info() 625 struct edac_device_block *block = NULL; edac_device_handle_ce() local 639 "INTERNAL ERROR: instance %d 'block' " edac_device_handle_ce() 647 block = instance->blocks + block_nr; edac_device_handle_ce() 648 block->counters.ce_count++; edac_device_handle_ce() 657 "CE: %s instance: %s block: %s '%s'\n", edac_device_handle_ce() 659 block ? block->name : "N/A", msg); edac_device_handle_ce() 671 struct edac_device_block *block = NULL; edac_device_handle_ue() local 685 "INTERNAL ERROR: instance %d 'block' " edac_device_handle_ue() 693 block = instance->blocks + block_nr; edac_device_handle_ue() 694 block->counters.ue_count++; edac_device_handle_ue() 703 "UE: %s instance: %s block: %s '%s'\n", edac_device_handle_ue() 705 block ? block->name : "N/A", msg); edac_device_handle_ue() 708 panic("EDAC %s: UE instance: %s block %s '%s'\n", edac_device_handle_ue() 710 block ? block->name : "N/A", msg); edac_device_handle_ue()
|
/linux-4.1.27/sound/soc/intel/haswell/ |
H A D | sst-haswell-dsp.c | 91 struct dma_block_info *block; hsw_parse_module() local 124 block = (void *)module + sizeof(*module); hsw_parse_module() 128 if (block->size <= 0) { hsw_parse_module() 130 "error: block %d size invalid\n", count); hsw_parse_module() 135 switch (block->type) { hsw_parse_module() 139 block->ram_offset + dsp->addr.iram_offset; hsw_parse_module() 145 mod->offset = block->ram_offset; hsw_parse_module() 149 dev_err(dsp->dev, "error: bad type 0x%x for block 0x%x\n", hsw_parse_module() 150 block->type, count); hsw_parse_module() 155 mod->size = block->size; hsw_parse_module() 156 mod->data = (void *)block + sizeof(*block); hsw_parse_module() 159 dev_dbg(dsp->dev, "module block %d type 0x%x " hsw_parse_module() 161 count, mod->type, block->size, ram, hsw_parse_module() 162 block->ram_offset); hsw_parse_module() 172 block = (void *)block + sizeof(*block) + block->size; hsw_parse_module() 368 can't be accessed, please enable each block before accessing. */ hsw_set_dsp_D0() 371 /* for D0, always enable the block(DSRAM[0]) used for FW dump */ hsw_set_dsp_D0() 497 static u32 hsw_block_get_bit(struct sst_mem_block *block) hsw_block_get_bit() argument 500 struct sst_dsp *sst = block->dsp; hsw_block_get_bit() 508 switch (block->type) { hsw_block_get_bit() 521 bit = 1 << (block->index + shift); hsw_block_get_bit() 526 /*dummy read a SRAM block.*/ sst_mem_block_dummy_read() 527 static void sst_mem_block_dummy_read(struct sst_mem_block *block) sst_mem_block_dummy_read() argument 531 struct sst_dsp *sst = block->dsp; sst_mem_block_dummy_read() 533 size = block->size > 4 ? 4 : block->size; sst_mem_block_dummy_read() 534 memcpy_fromio(tmp_buf, sst->addr.lpe + block->offset, size); sst_mem_block_dummy_read() 537 /* enable 32kB memory block - locks held by caller */ hsw_block_enable() 538 static int hsw_block_enable(struct sst_mem_block *block) hsw_block_enable() argument 540 struct sst_dsp *sst = block->dsp; hsw_block_enable() 543 if (block->users++ > 0) hsw_block_enable() 546 dev_dbg(block->dsp->dev, " enabled block %d:%d at offset 0x%x\n", hsw_block_enable() 547 block->type, block->index, block->offset); hsw_block_enable() 555 bit = hsw_block_get_bit(block); hsw_block_enable() 568 /*add a dummy read before the SRAM block is written, otherwise the writing may miss bytes sometimes.*/ hsw_block_enable() 569 sst_mem_block_dummy_read(block); hsw_block_enable() 573 /* disable 32kB memory block - locks held by caller */ hsw_block_disable() 574 static int hsw_block_disable(struct sst_mem_block *block) hsw_block_disable() argument 576 struct sst_dsp *sst = block->dsp; hsw_block_disable() 579 if (--block->users > 0) hsw_block_disable() 582 dev_dbg(block->dsp->dev, " disabled block %d:%d at offset 0x%x\n", hsw_block_disable() 583 block->type, block->index, block->offset); hsw_block_disable() 592 bit = hsw_block_get_bit(block); hsw_block_disable() 677 /* always enable the block(DSRAM[0]) used for FW dump */ hsw_init() 680 can't be accessed, please enable each block before accessing. */ hsw_init()
|
/linux-4.1.27/sound/pci/emu10k1/ |
H A D | emu10k1_patch.c | 35 * allocate a sample block and copy data from userspace 90 /* try to allocate a memory block */ snd_emu10k1_sample_new() 94 sp->block = snd_emu10k1_synth_alloc(emu, blocksize); snd_emu10k1_sample_new() 95 if (sp->block == NULL) { snd_emu10k1_sample_new() 111 snd_emu10k1_synth_bzero(emu, sp->block, offset, size); snd_emu10k1_sample_new() 120 if (snd_emu10k1_synth_copy_from_user(emu, sp->block, offset, data, size)) { snd_emu10k1_sample_new() 121 snd_emu10k1_synth_free(emu, sp->block); snd_emu10k1_sample_new() 122 sp->block = NULL; snd_emu10k1_sample_new() 134 unsigned short *wblock = (unsigned short*)block; snd_emu10k1_sample_new() 145 block[offset + i] = block[offset - i -1]; snd_emu10k1_sample_new() 167 if (snd_emu10k1_synth_copy_from_user(emu, sp->block, offset, data, size)) { snd_emu10k1_sample_new() 168 snd_emu10k1_synth_free(emu, sp->block); snd_emu10k1_sample_new() 169 sp->block = NULL; snd_emu10k1_sample_new() 176 snd_emu10k1_synth_bzero(emu, sp->block, offset, blocksize - offset); snd_emu10k1_sample_new() 190 unsigned short *wblock = (unsigned short*)block; snd_emu10k1_sample_new() 195 block[i] ^= 0x80; snd_emu10k1_sample_new() 213 * free a sample block 225 if (sp->block) { snd_emu10k1_sample_free() 226 snd_emu10k1_synth_free(emu, sp->block); snd_emu10k1_sample_free() 227 sp->block = NULL; snd_emu10k1_sample_free()
|
/linux-4.1.27/fs/logfs/ |
H A D | readwrite.c | 12 * seek_data find next data block 13 * valid check whether a block still belongs to a file 15 * delete delete a block (for directories and ifile) 52 * set, the actual block index (bix) and level can be derived from the page 55 * The lowest three bits of the block index are set to 0 after packing and 389 static void indirect_write_block(struct logfs_block *block) indirect_write_block() argument 395 page = block->page; indirect_write_block() 416 static void inode_write_block(struct logfs_block *block) inode_write_block() argument 421 inode = block->inode; inode_write_block() 462 struct logfs_block *block, write_alias_t *write_one_alias) inode_write_alias() 464 struct inode *inode = block->inode; inode_write_alias() 473 pos = fnb(block->alias_map, LOGFS_BLOCK_FACTOR, pos); inode_write_alias() 504 struct logfs_block *block, write_alias_t *write_one_alias) indirect_write_alias() 507 struct page *page = block->page; indirect_write_alias() 514 pos = fnb(block->alias_map, LOGFS_BLOCK_FACTOR, pos); indirect_write_alias() 532 struct logfs_block *block; logfs_write_obj_aliases_pagecache() local 535 list_for_each_entry(block, &super->s_object_alias, alias_list) { logfs_write_obj_aliases_pagecache() 536 err = block->ops->write_alias(sb, block, write_alias_journal); logfs_write_obj_aliases_pagecache() 543 void __free_block(struct super_block *sb, struct logfs_block *block) __free_block() argument 545 BUG_ON(!list_empty(&block->item_list)); __free_block() 546 list_del(&block->alias_list); __free_block() 547 mempool_free(block, logfs_super(sb)->s_block_pool); __free_block() 550 static void inode_free_block(struct super_block *sb, struct logfs_block *block) inode_free_block() argument 552 struct inode *inode = block->inode; inode_free_block() 555 __free_block(sb, block); inode_free_block() 559 struct logfs_block *block) indirect_free_block() 561 struct page *page = block->page; indirect_free_block() 568 __free_block(sb, block); indirect_free_block() 588 struct logfs_block *block; __alloc_block() local 590 block = mempool_alloc(super->s_block_pool, GFP_NOFS); __alloc_block() 591 memset(block, 0, sizeof(*block)); __alloc_block() 592 INIT_LIST_HEAD(&block->alias_list); __alloc_block() 593 INIT_LIST_HEAD(&block->item_list); __alloc_block() 594 block->sb = sb; __alloc_block() 595 block->ino = ino; __alloc_block() 596 block->bix = bix; __alloc_block() 597 block->level = level; __alloc_block() 598 return block; __alloc_block() 604 struct logfs_block *block; alloc_inode_block() local 609 block = __alloc_block(inode->i_sb, LOGFS_INO_MASTER, inode->i_ino, 0); alloc_inode_block() 610 block->inode = inode; alloc_inode_block() 611 li->li_block = block; alloc_inode_block() 612 block->ops = &inode_block_ops; alloc_inode_block() 615 void initialize_block_counters(struct page *page, struct logfs_block *block, initialize_block_counters() argument 621 block->partial = 0; initialize_block_counters() 622 block->full = 0; initialize_block_counters() 631 block->full = I0_BLOCKS; initialize_block_counters() 637 block->partial++; initialize_block_counters() 639 block->full++; initialize_block_counters() 646 struct logfs_block *block; alloc_data_block() local 654 block = __alloc_block(inode->i_sb, inode->i_ino, bix, level); alloc_data_block() 655 block->page = page; alloc_data_block() 659 set_page_private(page, (unsigned long) block); alloc_data_block() 661 block->ops = &indirect_block_ops; alloc_data_block() 667 struct logfs_block *block; alloc_indirect_block() local 675 block = logfs_block(page); alloc_indirect_block() 677 initialize_block_counters(page, block, array, page_is_empty); alloc_indirect_block() 683 struct logfs_block *block = logfs_block(page); block_set_pointer() local 687 BUG_ON(!block); block_set_pointer() 694 block->full += !!(ptr & LOGFS_FULLY_POPULATED) block_set_pointer() 696 block->partial += !!ptr - !!oldptr; block_set_pointer() 701 __be64 *block; block_get_pointer() local 704 block = kmap_atomic(page); block_get_pointer() 705 ptr = be64_to_cpu(block[index]); block_get_pointer() 706 kunmap_atomic(block); block_get_pointer() 720 u64 block; logfs_read_direct() local 722 block = li->li_data[index]; logfs_read_direct() 723 if (!block) logfs_read_direct() 726 return logfs_segment_read(inode, page, block, index, 0); logfs_read_direct() 880 * logfs_seek_hole - find next hole starting at a given block index 882 * @bix: block index to start searching 885 * block address next to eof is returned instead. 937 * logfs_seek_data - find next data block after a given block index 939 * @bix: block index to start searching 941 * Returns next data block. If the file doesn't contain any further data 942 * blocks, the last block in the file is returned instead. 1020 * logfs_is_valid_block - check whether this block is still valid 1023 * @ofs: block physical offset 1024 * @ino: block inode number 1025 * @bix: block index 1026 * @gc_level: block level 1028 * Returns 0 if the block is invalid, 1 if it is valid and 2 if it will 1104 struct logfs_block *block = logfs_block(page); get_page_reserve() local 1107 if (block && block->reserved_bytes) get_page_reserve() 1113 block = list_entry(super->s_writeback_list.next, get_page_reserve() 1115 block->ops->write_block(block); get_page_reserve() 1119 block = logfs_block(page); get_page_reserve() 1120 block->reserved_bytes += 6 * LOGFS_MAX_OBJECTSIZE; get_page_reserve() 1122 list_move_tail(&block->alias_list, &super->s_writeback_list); get_page_reserve() 1263 * every single write. It is attached to the indirect block, which is 1264 * marked dirty. When the indirect block is written, its shadows are 1265 * handed up to the next indirect block (or inode). Untimately they 1270 * the page's tree, in case it was an indirect block. If a page is 1278 struct logfs_block *block = logfs_block(page); fill_shadow_tree() local 1282 if (block->alias_map) fill_shadow_tree() 1284 block->alias_map, LOGFS_BLOCK_FACTOR); fill_shadow_tree() 1285 logfs_handle_transaction(inode, block->ta); fill_shadow_tree() 1286 block->ops->free_block(inode->i_sb, block); fill_shadow_tree() 1303 static void logfs_set_alias(struct super_block *sb, struct logfs_block *block, logfs_set_alias() argument 1308 if (block->inode && block->inode->i_ino == LOGFS_INO_MASTER) { logfs_set_alias() 1313 if (!test_bit(child_no, block->alias_map)) { logfs_set_alias() 1314 set_bit(child_no, block->alias_map); logfs_set_alias() 1317 list_move_tail(&block->alias_list, &super->s_object_alias); logfs_set_alias() 1400 struct logfs_block *block = logfs_block(page); ptr_change() local 1404 empty1 = block->partial == 0; ptr_change() 1410 full1 = block->full == LOGFS_BLOCK_FACTOR; ptr_change() 1503 struct logfs_block *block = logfs_inode(inode)->li_block; logfs_del_transaction() local 1505 if (block && block->ta) logfs_del_transaction() 1506 block->ta = NULL; logfs_del_transaction() 1865 * every single block resided in a different segment. 1907 struct logfs_block *block = logfs_block(page); move_page_to_inode() local 1909 if (!block) move_page_to_inode() 1913 block->ino, block->bix, block->level); move_page_to_inode() 1915 block->ops = &inode_block_ops; move_page_to_inode() 1916 block->inode = inode; move_page_to_inode() 1917 li->li_block = block; move_page_to_inode() 1919 block->page = NULL; move_page_to_inode() 1930 struct logfs_block *block = li->li_block; move_inode_to_page() local 1932 if (!block) move_inode_to_page() 1936 block->ino, block->bix, block->level); move_inode_to_page() 1938 block->ops = &indirect_block_ops; move_inode_to_page() 1939 block->page = page; move_inode_to_page() 1944 set_page_private(page, (unsigned long) block); move_inode_to_page() 1947 block->inode = NULL; move_inode_to_page() 2172 struct logfs_block *block = li->li_block; logfs_evict_inode() local 2191 if (!block) logfs_evict_inode() 2194 block->ops->free_block(inode->i_sb, block); logfs_evict_inode() 2203 void btree_write_block(struct logfs_block *block) btree_write_block() argument 2209 inode = logfs_safe_iget(block->sb, block->ino, &cookie); btree_write_block() 2210 page = logfs_get_write_page(inode, block->bix, block->level); btree_write_block() 2215 BUG_ON(logfs_block(page) != block); btree_write_block() 2230 * @bix: block index 461 inode_write_alias(struct super_block *sb, struct logfs_block *block, write_alias_t *write_one_alias) inode_write_alias() argument 503 indirect_write_alias(struct super_block *sb, struct logfs_block *block, write_alias_t *write_one_alias) indirect_write_alias() argument 558 indirect_free_block(struct super_block *sb, struct logfs_block *block) indirect_free_block() argument
|
H A D | segment.c | 185 static int btree_write_alias(struct super_block *sb, struct logfs_block *block, btree_write_alias() argument 191 list_for_each_entry(item, &block->item_list, list) { btree_write_alias() 192 err = write_alias_journal(sb, block->ino, block->bix, btree_write_alias() 193 block->level, item->child_no, item->val); btree_write_alias() 210 struct logfs_block *block; logfs_load_object_aliases() local 235 block = alias_tree_lookup(sb, ino, bix, level); logfs_load_object_aliases() 236 if (!block) { logfs_load_object_aliases() 237 block = __alloc_block(sb, ino, bix, level); logfs_load_object_aliases() 238 block->ops = &btree_block_ops; logfs_load_object_aliases() 239 err = alias_tree_insert(sb, ino, bix, level, block); logfs_load_object_aliases() 242 if (test_and_set_bit(item->child_no, block->alias_map)) { logfs_load_object_aliases() 246 list_move_tail(&block->alias_list, &super->s_object_alias); logfs_load_object_aliases() 247 list_add(&item->list, &block->item_list); logfs_load_object_aliases() 255 struct logfs_block *block = _block; kill_alias() local 256 struct super_block *sb = block->sb; kill_alias() 260 while (!list_empty(&block->item_list)) { kill_alias() 261 item = list_entry(block->item_list.next, typeof(*item), list); kill_alias() 265 block->ops->free_block(sb, block); kill_alias() 358 * logfs_segment_write - write data block to object store 426 * of any data block somewhere behind this indirect block. So we need to 481 struct logfs_block *block; move_btree_to_page() local 487 block = btree_remove128(head, inode->i_ino, page->index); move_btree_to_page() 488 if (!block) move_btree_to_page() 492 block->ino, block->bix, block->level); move_btree_to_page() 493 list_for_each_entry_safe(item, next, &block->item_list, list) { move_btree_to_page() 498 block->page = page; move_btree_to_page() 503 set_page_private(page, (unsigned long) block); move_btree_to_page() 505 block->ops = &indirect_block_ops; move_btree_to_page() 506 initialize_block_counters(page, block, data, 0); move_btree_to_page() 522 struct logfs_block *block = logfs_block(page); move_page_to_btree() local 523 struct super_block *sb = block->sb; move_page_to_btree() 531 block->ops->free_block(sb, block); move_page_to_btree() 535 block->ino, block->bix, block->level); move_page_to_btree() 539 pos = fnb(block->alias_map, LOGFS_BLOCK_FACTOR, pos); move_page_to_btree() 551 list_add(&item->list, &block->item_list); move_page_to_btree() 553 block->page = NULL; move_page_to_btree() 560 block->ops = &btree_block_ops; move_page_to_btree() 561 err = alias_tree_insert(block->sb, block->ino, block->bix, block->level, move_page_to_btree() 562 block); move_page_to_btree() 647 * logfs_segment_read - read data block from object store 651 * @bix: block index 652 * @level: block level
|
/linux-4.1.27/drivers/net/wireless/ath/wil6210/ |
H A D | ioctl.c | 50 wil_err(wil, "Requested block does not fit into memory: " wil_ioc_addr() 105 void *block; wil_ioc_memio_block() local 128 block = kmalloc(io.size, GFP_USER); wil_ioc_memio_block() 129 if (!block) wil_ioc_memio_block() 135 wil_memcpy_fromio_32(block, a, io.size); wil_ioc_memio_block() 136 wil_hex_dump_ioctl("Read ", block, io.size); wil_ioc_memio_block() 137 if (copy_to_user(io.block, block, io.size)) { wil_ioc_memio_block() 143 if (copy_from_user(block, io.block, io.size)) { wil_ioc_memio_block() 147 wil_memcpy_toio_32(a, block, io.size); wil_ioc_memio_block() 149 wil_hex_dump_ioctl("Write ", block, io.size); wil_ioc_memio_block() 158 kfree(block); wil_ioc_memio_block()
|
H A D | fw_inc.c | 206 const struct wil_fw_data_dwrite *block = d->data; fw_handle_direct_write() local 209 if (size % sizeof(*block)) { fw_handle_direct_write() 211 sizeof(*block), size); fw_handle_direct_write() 214 n = size / sizeof(*block); fw_handle_direct_write() 218 u32 m = le32_to_cpu(block[i].mask); fw_handle_direct_write() 219 u32 v = le32_to_cpu(block[i].value); fw_handle_direct_write() 222 FW_ADDR_CHECK(dst, block[i].addr, "address"); fw_handle_direct_write() 228 le32_to_cpu(block[i].addr), y, x, v, m); fw_handle_direct_write() 262 const struct wil_fw_data_gw *block = d->data; fw_handle_gateway_data() local 270 if (size < sizeof(*d) + sizeof(*block)) { fw_handle_gateway_data() 275 if ((size - sizeof(*d)) % sizeof(*block)) { fw_handle_gateway_data() 278 sizeof(*block), size - sizeof(*d)); fw_handle_gateway_data() 281 n = (size - sizeof(*d)) / sizeof(*block); fw_handle_gateway_data() 302 u32 a = le32_to_cpu(block[i].addr); fw_handle_gateway_data() 303 u32 v = le32_to_cpu(block[i].value); fw_handle_gateway_data() 321 const struct wil_fw_data_gw4 *block = d->data; fw_handle_gateway_data4() local 323 void __iomem *gwa_val[ARRAY_SIZE(block->value)]; fw_handle_gateway_data4() 329 if (size < sizeof(*d) + sizeof(*block)) { fw_handle_gateway_data4() 334 if ((size - sizeof(*d)) % sizeof(*block)) { fw_handle_gateway_data4() 337 sizeof(*block), size - sizeof(*d)); fw_handle_gateway_data4() 340 n = (size - sizeof(*d)) / sizeof(*block); fw_handle_gateway_data4() 348 for (k = 0; k < ARRAY_SIZE(block->value); k++) fw_handle_gateway_data4() 364 u32 a = le32_to_cpu(block[i].addr); fw_handle_gateway_data4() 365 u32 v[ARRAY_SIZE(block->value)]; fw_handle_gateway_data4() 367 for (k = 0; k < ARRAY_SIZE(block->value); k++) fw_handle_gateway_data4() 368 v[k] = le32_to_cpu(block[i].value[k]); fw_handle_gateway_data4() 374 for (k = 0; k < ARRAY_SIZE(block->value); k++) fw_handle_gateway_data4()
|
/linux-4.1.27/drivers/s390/char/ |
H A D | sclp_ocf.c | 48 /* Find the 0x9f00 block. */ sclp_ocf_handler() 53 /* Find the 0x9f22 block inside the 0x9f00 block. */ sclp_ocf_handler() 57 /* Find the 0x81 block inside the 0x9f22 block. */ sclp_ocf_handler() 61 /* Find the 0x01 block inside the 0x81 block. */ sclp_ocf_handler() 63 /* Find the 0x02 block inside the 0x81 block. */ sclp_ocf_handler()
|
/linux-4.1.27/fs/nilfs2/ |
H A D | mdt.c | 41 nilfs_mdt_insert_new_block(struct inode *inode, unsigned long block, nilfs_mdt_insert_new_block() argument 55 ret = nilfs_bmap_insert(ii->i_bmap, block, (unsigned long)bh); nilfs_mdt_insert_new_block() 74 static int nilfs_mdt_create_block(struct inode *inode, unsigned long block, nilfs_mdt_create_block() argument 88 bh = nilfs_grab_buffer(inode, inode->i_mapping, block, 0); nilfs_mdt_create_block() 101 err = nilfs_mdt_insert_new_block(inode, block, bh, init_block); nilfs_mdt_create_block() 173 static int nilfs_mdt_read_block(struct inode *inode, unsigned long block, nilfs_mdt_read_block() argument 181 err = nilfs_mdt_submit_block(inode, block, READ, &first_bh); nilfs_mdt_read_block() 189 blkoff = block + 1; nilfs_mdt_read_block() 221 * @blkoff: block offset 223 * @init_block: initializer used for newly allocated block 238 * %-ENOENT - the specified block does not exist (hole block) 266 * @start: start block offset (inclusive) 267 * @end: end block offset (inclusive) 268 * @blkoff: block offset 271 * nilfs_mdt_find_block() looks up an existing block in range of 272 * [@start, @end] and stores pointer to a buffer head of the block to 273 * @out_bh, and block offset to @blkoff, respectively. @out_bh and 283 * %-ENOENT - no block was found in the range 320 * @block: block offset 329 int nilfs_mdt_delete_block(struct inode *inode, unsigned long block) nilfs_mdt_delete_block() argument 334 err = nilfs_bmap_delete(ii->i_bmap, block); nilfs_mdt_delete_block() 337 nilfs_mdt_forget_block(inode, block); nilfs_mdt_delete_block() 345 * @block: block offset 357 int nilfs_mdt_forget_block(struct inode *inode, unsigned long block) nilfs_mdt_forget_block() argument 359 pgoff_t index = (pgoff_t)block >> nilfs_mdt_forget_block() 377 bh = nilfs_page_get_nth_block(page, block - first_block); nilfs_mdt_forget_block() 391 * nilfs_mdt_mark_block_dirty - mark a block on the meta data file dirty. 393 * @block: block offset 402 * %-ENOENT - the specified block does not exist (hole block) 404 int nilfs_mdt_mark_block_dirty(struct inode *inode, unsigned long block) nilfs_mdt_mark_block_dirty() argument 409 err = nilfs_mdt_read_block(inode, block, 0, &bh); nilfs_mdt_mark_block_dirty()
|
H A D | dat.c | 266 * @vblocknr: virtual block number 290 * nilfs_dat_freev - free virtual block numbers 292 * @vblocknrs: array of virtual block numbers 293 * @nitems: number of virtual block numbers 295 * Description: nilfs_dat_freev() frees the virtual block numbers specified by 305 * %-ENOENT - The virtual block number have not been allocated. 313 * nilfs_dat_move - change a block number 315 * @vblocknr: virtual block number 316 * @blocknr: block number 318 * Description: nilfs_dat_move() changes the block number associated with 340 * The given disk block number (blocknr) is not yet written to nilfs_dat_move() 344 * uncommitted block number, this makes a copy of the entry nilfs_dat_move() 379 * nilfs_dat_translate - translate a virtual block number to a block number 381 * @vblocknr: virtual block number 382 * @blocknrp: pointer to a block number 384 * Description: nilfs_dat_translate() maps the virtual block number @vblocknr 385 * to the corresponding block number. 387 * Return Value: On success, 0 is returned and the block number associated 395 * %-ENOENT - A block number associated with @vblocknr does not exist. 450 /* last virtual block number in this block */ nilfs_dat_get_vinfo() 474 * @sb: super block instance
|
/linux-4.1.27/include/uapi/linux/ |
H A D | minix_fs.h | 13 * minix filesystem (aka V2) with bigger inodes and 32-bit block 46 * long block numbers and a third indirect block (7+1+1+1 63 * minix super-block data on disk 79 * V3 minix super-block data on disk
|
/linux-4.1.27/include/trace/events/ |
H A D | block.h | 2 #define TRACE_SYSTEM block 99 * block_rq_abort - abort block operation request 100 * @q: queue containing the block operation request 101 * @rq: block IO operation request 103 * Called immediately after pending block IO operation request @rq in 116 * block_rq_requeue - place block IO request back on a queue 118 * @rq: block IO operation request 120 * The block operation request @rq is being placed back into queue 132 * block_rq_complete - block IO operation completed by device driver 133 * @q: queue containing the block operation request 134 * @rq: block operations request 214 * block_rq_insert - insert block operation request into queue 216 * @rq: block IO operation request 218 * Called immediately before block operation request @rq is inserted 231 * block_rq_issue - issue pending block IO request operation to device driver 233 * @rq: block IO operation operation request 235 * Called when block operation request @rq from queue @q is sent to a 246 * block_bio_bounce - used bounce buffer when processing block operation 247 * @q: queue holding the block operation 248 * @bio: block operation 250 * A bounce buffer was used to handle the block operation @bio in @q. 286 * block_bio_complete - completed all work on the block operation 287 * @q: queue holding the block operation 288 * @bio: block operation completed 292 * block IO operation @bio. 351 * block_bio_backmerge - merging block operation to the end of an existing operation 354 * @bio: new block operation to merge 356 * Merging block request @bio to the end of an existing block request 367 * block_bio_frontmerge - merging block operation to the beginning of an existing operation 370 * @bio: new block operation to merge 372 * Merging block IO operation @bio to the beginning of an existing block 383 * block_bio_queue - putting new block IO operation in queue 385 * @bio: new block operation 387 * About to place the block IO operation @bio into queue @q. 447 * block_getrq - get a free request entry in queue for block IO operations 449 * @bio: pending block IO operation 453 * block IO operation @bio. 463 * block_sleeprq - waiting to get a free request entry in queue for block IO operation 465 * @bio: pending block IO operation 484 * Plug the request queue @q. Do not allow block operation requests 486 * the queue to improve throughput performance of the block device. 543 * @bio: block operation being split 589 * raw block device. 625 * block_rq_remap - map request for a block operation request 627 * @rq: block IO operation request 631 * The block operation request @rq in @q has been remapped. The block
|
/linux-4.1.27/sound/synth/ |
H A D | util_mem.c | 47 INIT_LIST_HEAD(&hdr->block); snd_util_memhdr_new() 62 while ((p = hdr->block.next) != &hdr->block) { snd_util_memhdr_free() 70 * allocate a memory block (without mutex) 89 /* look for empty block */ __snd_util_mem_alloc() 91 list_for_each(p, &hdr->block) { __snd_util_mem_alloc() 106 * create a new memory block with the given size 107 * the block is linked next to prev 120 if (prev == &hdr->block) __snd_util_memblk_new() 135 * allocate a memory block (with mutex) 149 * remove the block from linked-list and free resource 162 * free a memory block (with mutex)
|
/linux-4.1.27/fs/ufs/ |
H A D | util.h | 320 * Extract the bits for a block from a map inside ufs_buffer_head 470 #define ubh_isblockclear(ubh,begin,block) (!_ubh_isblockset_(uspi,ubh,begin,block)) 472 #define ubh_isblockset(ubh,begin,block) _ubh_isblockset_(uspi,ubh,begin,block) _ubh_isblockset_() 474 struct ufs_buffer_head * ubh, unsigned begin, unsigned block) _ubh_isblockset_() 478 return (*ubh_get_addr (ubh, begin + block) == 0xff); _ubh_isblockset_() 480 return (*ubh_get_addr (ubh, begin + (block >> 1)) == (0x0f << ((block & 0x01) << 2))); _ubh_isblockset_() 482 return (*ubh_get_addr (ubh, begin + (block >> 2)) == (0x03 << ((block & 0x03) << 1))); _ubh_isblockset_() 484 return (*ubh_get_addr (ubh, begin + (block >> 3)) == (0x01 << (block & 0x07))); _ubh_isblockset_() 489 #define ubh_clrblock(ubh,begin,block) _ubh_clrblock_(uspi,ubh,begin,block) _ubh_clrblock_() 491 struct ufs_buffer_head * ubh, unsigned begin, unsigned block) _ubh_clrblock_() 495 *ubh_get_addr (ubh, begin + block) = 0x00; _ubh_clrblock_() 498 *ubh_get_addr (ubh, begin + (block >> 1)) &= ~(0x0f << ((block & 0x01) << 2)); _ubh_clrblock_() 501 *ubh_get_addr (ubh, begin + (block >> 2)) &= ~(0x03 << ((block & 0x03) << 1)); _ubh_clrblock_() 504 *ubh_get_addr (ubh, begin + (block >> 3)) &= ~(0x01 << ((block & 0x07))); _ubh_clrblock_() 509 #define ubh_setblock(ubh,begin,block) _ubh_setblock_(uspi,ubh,begin,block) _ubh_setblock_() 511 struct ufs_buffer_head * ubh, unsigned begin, unsigned block) _ubh_setblock_() 515 *ubh_get_addr(ubh, begin + block) = 0xff; _ubh_setblock_() 518 *ubh_get_addr(ubh, begin + (block >> 1)) |= (0x0f << ((block & 0x01) << 2)); _ubh_setblock_() 521 *ubh_get_addr(ubh, begin + (block >> 2)) |= (0x03 << ((block & 0x03) << 1)); _ubh_setblock_() 524 *ubh_get_addr(ubh, begin + (block >> 3)) |= (0x01 << ((block & 0x07))); _ubh_setblock_() 473 _ubh_isblockset_(struct ufs_sb_private_info * uspi, struct ufs_buffer_head * ubh, unsigned begin, unsigned block) _ubh_isblockset_() argument 490 _ubh_clrblock_(struct ufs_sb_private_info * uspi, struct ufs_buffer_head * ubh, unsigned begin, unsigned block) _ubh_clrblock_() argument 510 _ubh_setblock_(struct ufs_sb_private_info * uspi, struct ufs_buffer_head * ubh, unsigned begin, unsigned block) _ubh_setblock_() argument
|
H A D | ufs_fs.h | 62 * A filesystem is described by its super-block, which in turn 63 * describes the cylinder groups. The super-block is critical 66 * super-block data does not change, so the copies need not be 70 * are given in the super block as: 71 * [fs->fs_sblkno] Super-block 72 * [fs->fs_cblkno] Cylinder group block 79 * reside in any one of four places. For tiny media where every block 204 * Turn file system block numbers into disk block addresses. 218 #define ufs_cgcmin(c) (ufs_cgstart(c) + uspi->s_cblkno) /* cg block */ 224 * inode number to file system block offset. 226 * inode number to file system block address. 234 * Compute the cylinder and rotational position of a cyl block addr. 354 __fs32 fs_sblkno; /* addr of super-block in filesys */ 355 __fs32 fs_cblkno; /* offset of cyl-block in filesys */ 366 __fs32 fs_frag; /* number of frags in a block in fs */ 369 __fs32 fs_rotdelay; /* num of ms for optimal next block */ 380 __fs32 fs_fragshift; /* block to frag shift */ 382 __fs32 fs_sbsize; /* actual size of super block */ 383 __fs32 fs_csmask; /* csum block offset */ 384 __fs32 fs_csshift; /* csum block number */ 423 __s8 fs_fmod; /* super block modified flag */ 434 __fs16 fs_opostbl[16][8]; /* old rotation block list head */ 449 __fs64 fs_sparecon64[17];/*old rotation block list head */ 490 __fs32 fs_postbloff; /* (__s16) rotation block list head */ 515 * Cylinder group block for a file system. 518 * super block lock fs->fs_lock. 545 __fs32 cg_rotor; /* position of last used block */ 549 __fs32 cg_btotoff; /* (__u32) block totals per cylinder */ 550 __fs32 cg_boff; /* (short) free block positions */ 552 __fs32 cg_freeoff; /* (u_char) free block map */ 587 __fs32 cg_rotor; /* position of last used block */ 591 __fs32 cg_btot[32]; /* block totals per cylinder */ 595 __u8 cg_free[1]; /* free block map */ 669 __fs32 ui_extsize; /* 92: External attributes block. */ 670 __fs64 ui_extb[UFS_NXADDR];/* 96: External attributes block. */ 713 __u32 c_rotor; /* position of last used block */ 716 __u32 c_btotoff; /* (__u32) block totals per cylinder */ 717 __u32 c_boff; /* (short) free block positions */ 719 __u32 c_freeoff; /* (u_char) free block map */ 728 struct ufs_buffer_head s_ubh; /* buffer containing super block */ 731 __u32 s_cblkno; /* offset of cg-block in filesys */ 743 __u32 s_fpb; /* fragments per block */ 749 __u32 s_fpbshift; /* fragments per block shift */ 751 __u32 s_sbsize; /* actual size of super block */ 752 __u32 s_csmask; /* csum block offset */ 753 __u32 s_csshift; /* csum block number */ 774 __s32 s_postbloff; /* (__s16) rotation block list head */ 777 __u32 s_fpbmask; /* fragments per block mask */ 778 __u32 s_apb; /* address per block */ 779 __u32 s_2apb; /* address per block^2 */ 780 __u32 s_3apb; /* address per block^3 */ 781 __u32 s_apbmask; /* address per block mask */ 782 __u32 s_apbshift; /* address per block shift */ 783 __u32 s_2apbshift; /* address per block shift * 2 */ 784 __u32 s_3apbshift; /* address per block shift * 3 */ 786 __u32 s_nspb; /* number of sector per block */
|
/linux-4.1.27/fs/xfs/ |
H A D | xfs_rtalloc.c | 42 * bitmap block combination. 43 * Keeps track of a current summary block, so we don't keep reading 51 xfs_rtblock_t bbno, /* bitmap block number */ xfs_rtget_summary() 52 xfs_buf_t **rbpp, /* in/out: summary block buffer */ xfs_rtget_summary() 53 xfs_fsblock_t *rsb, /* in/out: summary block number */ xfs_rtget_summary() 54 xfs_suminfo_t *sum) /* out: summary info for this block */ xfs_rtget_summary() 61 * by low and high, for the bitmap block bbno. 69 xfs_rtblock_t bbno, /* bitmap block number */ xfs_rtany_summary() 70 xfs_buf_t **rbpp, /* in/out: summary block buffer */ xfs_rtany_summary() 71 xfs_fsblock_t *rsb, /* in/out: summary block number */ xfs_rtany_summary() 115 xfs_rtblock_t bbno; /* bitmap block number */ xfs_rtcopy_summary() 120 xfs_fsblock_t sumbno; /* summary block number */ xfs_rtcopy_summary() 154 xfs_rtblock_t start, /* start block to allocate */ xfs_rtallocate_range() 156 xfs_buf_t **rbpp, /* in/out: summary block buffer */ xfs_rtallocate_range() 157 xfs_fsblock_t *rsb) /* in/out: summary block number */ xfs_rtallocate_range() 161 xfs_rtblock_t postblock = 0; /* first block allocated > end */ xfs_rtallocate_range() 162 xfs_rtblock_t preblock = 0; /* first block allocated < start */ xfs_rtallocate_range() 175 * Find the next allocated block (end of free extent). xfs_rtallocate_range() 225 * bitmap block bbno. If we don't get maxlen then use prod to trim 226 * the length, if given. Returns error; returns starting block in *rtblock. 233 xfs_rtblock_t bbno, /* bitmap block number */ xfs_rtallocate_extent_block() 237 xfs_rtblock_t *nextp, /* out: next block to try */ xfs_rtallocate_extent_block() 238 xfs_buf_t **rbpp, /* in/out: summary block buffer */ xfs_rtallocate_extent_block() 239 xfs_fsblock_t *rsb, /* in/out: summary block number */ xfs_rtallocate_extent_block() 241 xfs_rtblock_t *rtblock) /* out: start block allocated */ xfs_rtallocate_extent_block() 252 * Loop over all the extents starting in this bitmap block, xfs_rtallocate_extent_block() 329 * Allocation failed. Set *nextp to the next block to try. xfs_rtallocate_extent_block() 337 * Allocate an extent of length minlen<=len<=maxlen, starting at block 339 * Returns error; returns starting block in *rtblock. 346 xfs_rtblock_t bno, /* starting block number to allocate */ xfs_rtallocate_extent_exact() 350 xfs_buf_t **rbpp, /* in/out: summary block buffer */ xfs_rtallocate_extent_exact() 351 xfs_fsblock_t *rsb, /* in/out: summary block number */ xfs_rtallocate_extent_exact() 353 xfs_rtblock_t *rtblock) /* out: start block allocated */ xfs_rtallocate_extent_exact() 358 xfs_rtblock_t next; /* next block to try (dummy) */ xfs_rtallocate_extent_exact() 425 xfs_rtblock_t bno, /* starting block number to allocate */ xfs_rtallocate_extent_near() 429 xfs_buf_t **rbpp, /* in/out: summary block buffer */ xfs_rtallocate_extent_near() 430 xfs_fsblock_t *rsb, /* in/out: summary block number */ xfs_rtallocate_extent_near() 432 xfs_rtblock_t *rtblock) /* out: start block allocated */ xfs_rtallocate_extent_near() 435 xfs_rtblock_t bbno; /* bitmap block number */ xfs_rtallocate_extent_near() 437 int i; /* bitmap block offset (loop control) */ xfs_rtallocate_extent_near() 440 xfs_rtblock_t n; /* next block to try */ xfs_rtallocate_extent_near() 441 xfs_rtblock_t r; /* result block */ xfs_rtallocate_extent_near() 445 * If the block number given is off the end, silently set it to xfs_rtallocate_extent_near() 446 * the last block. xfs_rtallocate_extent_near() 470 * Loop over all bitmap blocks (bbno + i is current block). xfs_rtallocate_extent_near() 475 * starting in this bitmap block. xfs_rtallocate_extent_near() 493 * this block. xfs_rtallocate_extent_near() 517 * bitmap block and is long enough. xfs_rtallocate_extent_near() 522 * this bitmap block. xfs_rtallocate_extent_near() 534 * earlier block. If there is an xfs_rtallocate_extent_near() 559 * Try to allocate from the summary block xfs_rtallocate_extent_near() 591 * blocks to go, go there. The 0 case moves to block 1. xfs_rtallocate_extent_near() 623 xfs_buf_t **rbpp, /* in/out: summary block buffer */ xfs_rtallocate_extent_size() 624 xfs_fsblock_t *rsb, /* in/out: summary block number */ xfs_rtallocate_extent_size() 626 xfs_rtblock_t *rtblock) /* out: start block allocated */ xfs_rtallocate_extent_size() 629 int i; /* bitmap block number */ xfs_rtallocate_extent_size() 631 xfs_rtblock_t n; /* next block to be tried */ xfs_rtallocate_extent_size() 632 xfs_rtblock_t r; /* result block number */ xfs_rtallocate_extent_size() 651 * Get the summary for this level/block. xfs_rtallocate_extent_size() 659 * Nothing there, on to the next block. xfs_rtallocate_extent_size() 679 * If the "next block to try" returned from the xfs_rtallocate_extent_size() 680 * allocator is beyond the next bitmap block, xfs_rtallocate_extent_size() 681 * skip to that bitmap block. xfs_rtallocate_extent_size() 706 * starting in that block. xfs_rtallocate_extent_size() 710 * Get the summary information for this level/block. xfs_rtallocate_extent_size() 742 * If the "next block to try" returned from the xfs_rtallocate_extent_size() 743 * allocator is beyond the next bitmap block, xfs_rtallocate_extent_size() 744 * skip to that bitmap block. xfs_rtallocate_extent_size() 767 xfs_fileoff_t bno; /* block number in file */ xfs_growfs_rt_alloc() 770 xfs_daddr_t d; /* disk block address */ xfs_growfs_rt_alloc() 772 xfs_fsblock_t firstblock; /* first block allocated in xaction */ xfs_growfs_rt_alloc() 774 xfs_fsblock_t fsbno; /* filesystem block for bno */ xfs_growfs_rt_alloc() 775 xfs_bmbt_irec_t map; /* block map output */ xfs_growfs_rt_alloc() 776 int nmap; /* number of block maps */ xfs_growfs_rt_alloc() 826 * Do this one block per transaction, to keep it simple. xfs_growfs_rt_alloc() 834 * Reserve log for one block zeroing. xfs_growfs_rt_alloc() 846 * Get a buffer for the block. xfs_growfs_rt_alloc() 889 xfs_rtblock_t bmbno; /* bitmap block number */ xfs_growfs_rt() 904 xfs_fsblock_t sumbno; /* summary block number */ xfs_growfs_rt() 919 * Read in the last block of the device, make sure it exists. xfs_growfs_rt() 947 * Get the old block counts for bitmap and summary inodes. xfs_growfs_rt() 967 * We will do everything one bitmap block at a time. xfs_growfs_rt() 968 * Skip the current block if it is exactly full. xfs_growfs_rt() 1031 * Do this when the real size (not block-aligned) changes. xfs_growfs_rt() 1095 * result block number. 1100 xfs_rtblock_t bno, /* starting block number to allocate */ xfs_rtallocate_extent() 1107 xfs_rtblock_t *rtblock) /* out: start block allocated */ xfs_rtallocate_extent() 1111 xfs_rtblock_t r; /* result allocated block */ xfs_rtallocate_extent() 1112 xfs_fsblock_t sb; /* summary file block number */ xfs_rtallocate_extent() 1113 xfs_buf_t *sumbp; /* summary file block buffer */ xfs_rtallocate_extent() 1136 * Allocate by size, or near another block, or exactly at some block. xfs_rtallocate_extent() 1181 struct xfs_buf *bp; /* buffer for last block of subvolume */ xfs_rtmount_init() 1183 xfs_daddr_t d; /* address of last block of subvolume */ xfs_rtmount_init() 1273 xfs_rtblock_t b; /* result block */ xfs_rtpick_extent()
|
/linux-4.1.27/drivers/gpu/drm/omapdrm/ |
H A D | omap_dmm_tiler.h | 38 struct list_head alloc_node; /* node for global block list */ 43 /* bits representing the same slot in DMM-TILER hw-block */ 47 /* bits reserved to describe coordinates in DMM-TILER hw-block */ 91 int tiler_pin(struct tiler_block *block, struct page **pages, 93 int tiler_unpin(struct tiler_block *block); 99 int tiler_release(struct tiler_block *block); 102 dma_addr_t tiler_ssptr(struct tiler_block *block); 103 dma_addr_t tiler_tsptr(struct tiler_block *block, uint32_t orient,
|
H A D | omap_dmm_tiler.c | 337 int tiler_pin(struct tiler_block *block, struct page **pages, tiler_pin() argument 342 ret = fill(&block->area, pages, npages, roll, wait); tiler_pin() 345 tiler_unpin(block); tiler_pin() 350 int tiler_unpin(struct tiler_block *block) tiler_unpin() argument 352 return fill(&block->area, NULL, 0, 0, false); tiler_unpin() 361 struct tiler_block *block = kzalloc(sizeof(*block), GFP_KERNEL); tiler_reserve_2d() local 377 block->fmt = fmt; tiler_reserve_2d() 379 ret = tcm_reserve_2d(containers[fmt], w, h, align, &block->area); tiler_reserve_2d() 381 kfree(block); tiler_reserve_2d() 387 list_add(&block->alloc_node, &omap_dmm->alloc_head); tiler_reserve_2d() 390 return block; tiler_reserve_2d() 395 struct tiler_block *block = kzalloc(sizeof(*block), GFP_KERNEL); tiler_reserve_1d() local 399 if (!block) tiler_reserve_1d() 402 block->fmt = TILFMT_PAGE; tiler_reserve_1d() 405 &block->area)) { tiler_reserve_1d() 406 kfree(block); tiler_reserve_1d() 411 list_add(&block->alloc_node, &omap_dmm->alloc_head); tiler_reserve_1d() 414 return block; tiler_reserve_1d() 418 int tiler_release(struct tiler_block *block) tiler_release() argument 420 int ret = tcm_free(&block->area); tiler_release() 423 if (block->area.tcm) tiler_release() 424 dev_err(omap_dmm->dev, "failed to release block\n"); tiler_release() 427 list_del(&block->alloc_node); tiler_release() 430 kfree(block); tiler_release() 490 dma_addr_t tiler_ssptr(struct tiler_block *block) tiler_ssptr() argument 492 BUG_ON(!validfmt(block->fmt)); tiler_ssptr() 494 return TILVIEW_8BIT + tiler_get_address(block->fmt, 0, tiler_ssptr() 495 block->area.p0.x * geom[block->fmt].slot_w, tiler_ssptr() 496 block->area.p0.y * geom[block->fmt].slot_h); tiler_ssptr() 499 dma_addr_t tiler_tsptr(struct tiler_block *block, uint32_t orient, tiler_tsptr() argument 502 struct tcm_pt *p = &block->area.p0; tiler_tsptr() 503 BUG_ON(!validfmt(block->fmt)); tiler_tsptr() 505 return tiler_get_address(block->fmt, orient, tiler_tsptr() 506 (p->x * geom[block->fmt].slot_w) + x, tiler_tsptr() 507 (p->y * geom[block->fmt].slot_h) + y); tiler_tsptr() 551 struct tiler_block *block, *_block; omap_dmm_remove() local 558 list_for_each_entry_safe(block, _block, &omap_dmm->alloc_head, omap_dmm_remove() 560 list_del(&block->alloc_node); omap_dmm_remove() 561 kfree(block); omap_dmm_remove() 873 struct tiler_block *block; tiler_map_show() local 911 list_for_each_entry(block, &omap_dmm->alloc_head, alloc_node) { tiler_map_show() 912 if (block->area.tcm == omap_dmm->tcm[lut_idx]) { tiler_map_show() 913 if (block->fmt != TILFMT_PAGE) { tiler_map_show() 914 fill_map(map, xdiv, ydiv, &block->area, tiler_map_show() 921 &block->area); tiler_map_show() 924 ydiv, &block->area.p0) == ' '; tiler_map_show() 926 &block->area.p1) == ' '; tiler_map_show() 928 tcm_for_each_slice(a, block->area, p) tiler_map_show() 932 &block->area.p0, tiler_map_show() 935 &block->area.p1, tiler_map_show() 938 &block->area); tiler_map_show()
|
/linux-4.1.27/fs/reiserfs/ |
H A D | bitmap.c | 4 /* Reiserfs block (de)allocator, bitmap-based. */ 18 /* different reiserfs block allocator options */ 42 reiserfs_info(s, "block allocator option \"%s\" is set", #optname); \ 49 b_blocknr_t block, get_bit_address() 54 * It is in the bitmap block number equal to the block get_bit_address() 55 * number divided by the number of bits in a block. get_bit_address() 57 *bmap_nr = block >> (s->s_blocksize_bits + 3); get_bit_address() 58 /* Within that bitmap block it is located at bit offset *offset. */ get_bit_address() 59 *offset = block & ((s->s_blocksize << 3) - 1); get_bit_address() 62 int is_reusable(struct super_block *s, b_blocknr_t block, int bit_value) is_reusable() argument 67 if (block == 0 || block >= SB_BLOCK_COUNT(s)) { is_reusable() 69 "block number is out of range %lu (%u)", is_reusable() 70 block, SB_BLOCK_COUNT(s)); is_reusable() 74 get_bit_address(s, block, &bmap, &offset); is_reusable() 83 if (block >= bmap1 && is_reusable() 84 block <= bmap1 + bmap_count) { is_reusable() 85 reiserfs_error(s, "vs-4019", "bitmap block %lu(%u) " is_reusable() 87 block, bmap_count); is_reusable() 92 reiserfs_error(s, "vs-4020", "bitmap block %lu(%u) " is_reusable() 94 block, bmap_count); is_reusable() 100 reiserfs_error(s, "vs-4030", "bitmap for requested block " is_reusable() 101 "is out of range: block=%lu, bitmap_nr=%u", is_reusable() 102 block, bmap); is_reusable() 106 if (bit_value == 0 && block == SB_ROOT_BLOCK(s)) { is_reusable() 107 reiserfs_error(s, "vs-4050", "this is root block (%u), " is_reusable() 116 * Searches in journal structures for a given block number (bmap, off). 117 * If block is found in reiserfs journal it suggests next free block 141 * lengths in one bitmap block 180 * search for a zero bit fails or the rest of bitmap block scan_bitmap_block() 251 * Search again in current block scan_bitmap_block() 261 /* free block count calculation */ scan_bitmap_block() 296 * hashes the id and then returns > 0 if the block group for the 305 * If we don't have cached information on this bitmap block, we're block_group_used() 417 struct inode *inode, b_blocknr_t block, _reiserfs_free_block() 432 get_bit_address(s, block, &nr, &offset); _reiserfs_free_block() 435 reiserfs_error(s, "vs-4075", "block %lu is out of range", _reiserfs_free_block() 436 block); _reiserfs_free_block() 446 /* clear bit for the given block in bit map */ _reiserfs_free_block() 449 "block %lu: bit already cleared", block); _reiserfs_free_block() 456 /* update super block */ _reiserfs_free_block() 468 struct inode *inode, b_blocknr_t block, reiserfs_free_block() 474 RFALSE(!s, "vs-4061: trying to free block on nonexistent device"); reiserfs_free_block() 475 if (!is_reusable(s, block, 1)) reiserfs_free_block() 478 if (block > sb_block_count(REISERFS_SB(s)->s_rs)) { reiserfs_free_block() 480 "Trying to free block outside file system " reiserfs_free_block() 482 block, sb_block_count(REISERFS_SB(s)->s_rs)); reiserfs_free_block() 486 journal_mark_freed(th, s, block); reiserfs_free_block() 487 _reiserfs_free_block(th, inode, block, for_unformatted); reiserfs_free_block() 492 struct inode *inode, b_blocknr_t block) reiserfs_free_prealloc_block() 496 "vs-4060: trying to free block on nonexistent device"); reiserfs_free_prealloc_block() 497 if (!is_reusable(th->t_super, block, 1)) reiserfs_free_prealloc_block() 499 _reiserfs_free_block(th, inode, block, 1); reiserfs_free_prealloc_block() 565 /* block allocator related options are parsed here */ reiserfs_parse_alloc_options() 788 * Relocation based on dirid, hashing them into a given bitmap block 806 /* give a portion of the block group to metadata */ dirid_groups() 814 * Relocation based on oid, hashing them into a given bitmap block 944 return hint->block == this_blocknr_allocation_would_make_it_a_large_file() 1064 * Mimic old block allocator behaviour, that is if VFS allowed for determine_search_start() 1067 * block, we start searching from it, assuming that HDD dataflow determine_search_start() 1155 !hint->formatted_node, hint->block); allocate_without_wrapping_disk() 1353 * We have all the block numbers we need from the reiserfs_allocate_blocknrs() 1393 reiserfs_error(sb, "reiserfs-2025", "bitmap block %lu is " reiserfs_cache_bitmap_metadata() 1410 b_blocknr_t block = (sb->s_blocksize << 3) * bitmap; reiserfs_read_bitmap_block() local 1420 block = REISERFS_SB(sb)->s_sbh->b_blocknr + 1 + bitmap; reiserfs_read_bitmap_block() 1422 block = (REISERFS_DISK_OFFSET_IN_BYTES >> sb->s_blocksize_bits) + 1; reiserfs_read_bitmap_block() 1424 bh = sb_bread(sb, block); reiserfs_read_bitmap_block() 1426 reiserfs_warning(sb, "sh-2029: %s: bitmap block (#%u) " reiserfs_read_bitmap_block() 1427 "reading failed", __func__, block); reiserfs_read_bitmap_block() 48 get_bit_address(struct super_block *s, b_blocknr_t block, unsigned int *bmap_nr, unsigned int *offset) get_bit_address() argument 416 _reiserfs_free_block(struct reiserfs_transaction_handle *th, struct inode *inode, b_blocknr_t block, int for_unformatted) _reiserfs_free_block() argument 467 reiserfs_free_block(struct reiserfs_transaction_handle *th, struct inode *inode, b_blocknr_t block, int for_unformatted) reiserfs_free_block() argument 491 reiserfs_free_prealloc_block(struct reiserfs_transaction_handle *th, struct inode *inode, b_blocknr_t block) reiserfs_free_prealloc_block() argument
|
/linux-4.1.27/include/linux/platform_data/ |
H A D | gpio-ts5500.h | 16 * struct ts5500_dio_platform_data - TS-5500 pin block configuration 18 * @strap: The only pin connected to an interrupt in a block is input-only.
|
/linux-4.1.27/fs/isofs/ |
H A D | namei.c | 41 unsigned long block, f_pos, offset, block_saved, offset_saved; isofs_find_entry() local 50 block = 0; isofs_find_entry() 58 bh = isofs_bread(dir, block); isofs_find_entry() 70 block = f_pos >> bufbits; isofs_find_entry() 85 block++; isofs_find_entry() 89 bh = isofs_bread(dir, block); isofs_find_entry() 102 " in block %lu of inode %lu\n", block, isofs_find_entry() 154 unsigned long uninitialized_var(block); isofs_lookup() 164 &block, &offset, isofs_lookup() 169 inode = found ? isofs_iget(dir->i_sb, block, offset) : NULL; isofs_lookup()
|
H A D | export.c | 20 unsigned long block, isofs_export_iget() 26 if (block == 0) isofs_export_iget() 28 inode = isofs_iget(sb, block, offset); isofs_export_iget() 40 * simply need to find its ".." entry, normalize its block and offset, 73 * the ".." entry is located in the same block. */ isofs_export_get_parent() 76 /* Get the block in question. */ isofs_export_get_parent() 153 u32 block; member in struct:isofs_fid 169 return isofs_export_iget(sb, ifid->block, ifid->offset, isofs_fh_to_dentry() 19 isofs_export_iget(struct super_block *sb, unsigned long block, unsigned long offset, __u32 generation) isofs_export_iget() argument
|
/linux-4.1.27/arch/s390/include/asm/ |
H A D | pci_clp.h | 35 /* request or response block header length */ 38 /* Number of function handles fitting in response block */ 52 u32 fmt : 4; /* cmd request block format */ 62 u32 fmt : 4; /* cmd request block format */ 76 u32 fmt : 4; /* cmd request block format */ 87 u32 fmt : 4; /* cmd request block format */ 111 u32 fmt : 4; /* cmd request block format */ 123 u32 fmt : 4; /* cmd request block format */ 144 u32 fmt : 4; /* cmd request block format */ 157 u32 fmt : 4; /* cmd request block format */ 165 /* Combined request/response block structures used by clp insn */
|
H A D | elf.h | 58 block offset. */ 60 block offset. */ 62 block offset. */ 68 negated static TLS block offset. */ 70 negated static TLS block offset. */ 72 negated static TLS block offset. */ 74 static TLS block. */ 76 static TLS block. */ 78 block. */ 80 block. */ 82 #define R_390_TLS_DTPOFF 55 /* Offset in TLS block. */ 84 block. */ 89 block offset. */
|
/linux-4.1.27/drivers/mfd/ |
H A D | pm8921-core.c | 109 static int pm8xxx_irq_block_handler(struct pm_irq_chip *chip, int block) pm8xxx_irq_block_handler() argument 114 ret = pm8xxx_read_block_irq(chip, block, &bits); pm8xxx_irq_block_handler() 116 pr_err("Failed reading %d block ret=%d", block, ret); pm8xxx_irq_block_handler() 120 pr_err("block bit set in master but no irqs: %d", block); pm8xxx_irq_block_handler() 127 pmirq = block * 8 + i; pm8xxx_irq_block_handler() 153 block_number = master * 8 + i; /* block # */ pm8xxx_irq_master_handler() 189 u8 block, config; pm8xxx_irq_mask_ack() local 191 block = pmirq / 8; pm8xxx_irq_mask_ack() 194 pm8xxx_config_irq(chip, block, config); pm8xxx_irq_mask_ack() 201 u8 block, config; pm8xxx_irq_unmask() local 203 block = pmirq / 8; pm8xxx_irq_unmask() 206 pm8xxx_config_irq(chip, block, config); pm8xxx_irq_unmask() 214 u8 block, config; pm8xxx_irq_set_type() local 216 block = pmirq / 8; pm8xxx_irq_set_type() 236 return pm8xxx_config_irq(chip, block, config); pm8xxx_irq_set_type()
|
/linux-4.1.27/sound/soc/intel/baytrail/ |
H A D | sst-baytrail-dsp.c | 68 struct dma_block_info *block; sst_byt_parse_module() local 81 block = (void *)module + sizeof(*module); sst_byt_parse_module() 85 if (block->size <= 0) { sst_byt_parse_module() 86 dev_err(dsp->dev, "block %d size invalid\n", count); sst_byt_parse_module() 90 switch (block->type) { sst_byt_parse_module() 92 mod->offset = block->ram_offset + sst_byt_parse_module() 97 mod->offset = block->ram_offset + sst_byt_parse_module() 102 mod->offset = block->ram_offset + sst_byt_parse_module() 108 block->type, count); sst_byt_parse_module() 112 mod->size = block->size; sst_byt_parse_module() 113 mod->data = (void *)block + sizeof(*block); sst_byt_parse_module() 117 block = (void *)block + sizeof(*block) + block->size; sst_byt_parse_module() 212 * save the physical address of extended firmware block in the first sst_byt_boot()
|
/linux-4.1.27/drivers/i2c/ |
H A D | i2c-stub.c | 74 u8 block[I2C_SMBUS_BLOCK_MAX]; member in struct:smbus_block_data 223 * block transfers stub_xfer() 225 if (data->block[0] > 256 - command) /* Avoid overrun */ stub_xfer() 226 data->block[0] = 256 - command; stub_xfer() 227 len = data->block[0]; stub_xfer() 231 chip->words[command + i] |= data->block[1 + i]; stub_xfer() 234 "i2c block data - addr 0x%02x, wrote %d bytes at 0x%02x.\n", stub_xfer() 238 data->block[1 + i] = stub_xfer() 242 "i2c block data - addr 0x%02x, read %d bytes at 0x%02x.\n", stub_xfer() 252 * banks and SMBus block transfers stub_xfer() 256 len = data->block[0]; stub_xfer() 269 /* Largest write sets read block length */ stub_xfer() 273 b->block[i] = data->block[i + 1]; stub_xfer() 275 chip->words[command] = (b->block[0] << 8) | b->len; stub_xfer() 277 "smbus block data - addr 0x%02x, wrote %d bytes at 0x%02x.\n", stub_xfer() 282 "SMBus block read command without prior block write not supported\n"); stub_xfer() 287 data->block[0] = len; stub_xfer() 289 data->block[i + 1] = b->block[i]; stub_xfer() 291 "smbus block data - addr 0x%02x, read %d bytes at 0x%02x.\n", stub_xfer()
|
/linux-4.1.27/scripts/mod/ |
H A D | sumversion.c | 42 uint32_t block[MD4_BLOCK_WORDS]; member in struct:md4_ctx 156 le32_to_cpu_array(ctx->block, sizeof(ctx->block) / sizeof(uint32_t)); md4_transform_helper() 157 md4_transform(ctx->hash, ctx->block); md4_transform_helper() 172 const uint32_t avail = sizeof(mctx->block) - (mctx->byte_count & 0x3f); md4_update() 177 memcpy((char *)mctx->block + (sizeof(mctx->block) - avail), md4_update() 182 memcpy((char *)mctx->block + (sizeof(mctx->block) - avail), md4_update() 189 while (len >= sizeof(mctx->block)) { md4_update() 190 memcpy(mctx->block, data, sizeof(mctx->block)); md4_update() 192 data += sizeof(mctx->block); md4_update() 193 len -= sizeof(mctx->block); md4_update() 196 memcpy(mctx->block, data, len); md4_update() 202 char *p = (char *)mctx->block + offset; md4_final_ascii() 209 p = (char *)mctx->block; md4_final_ascii() 214 mctx->block[14] = mctx->byte_count << 3; md4_final_ascii() 215 mctx->block[15] = mctx->byte_count >> 29; md4_final_ascii() 216 le32_to_cpu_array(mctx->block, (sizeof(mctx->block) - md4_final_ascii() 218 md4_transform(mctx->hash, mctx->block); md4_final_ascii()
|
/linux-4.1.27/arch/powerpc/lib/ |
H A D | rheap.c | 47 rh_block_t *block, *blk; grow() local 57 block = kmalloc(sizeof(rh_block_t) * max_blocks, GFP_ATOMIC); grow() 58 if (block == NULL) grow() 63 /* copy old block area */ grow() 64 memcpy(block, info->block, grow() 67 delta = (char *)block - (char *)info->block; grow() 70 blks = (unsigned long)info->block; grow() 71 blke = (unsigned long)(info->block + info->max_blocks); grow() 73 for (i = 0, blk = block; i < info->max_blocks; i++, blk++) grow() 82 kfree(info->block); grow() 85 info->block = block; grow() 91 blk = block + info->max_blocks - new_blocks; grow() 100 * causes a grow in the block area then all pointers kept to the block 115 /* Next 16 sized block */ assure_empty() 213 /* Grow the before block */ attach_free_block() 219 /* Grow the after block backwards */ attach_free_block() 226 /* Grow the before block, and release the after block */ attach_free_block() 237 /* Find the block immediately before the given one (if any) */ attach_taken_block() 268 info->block = NULL; rh_create() 288 kfree(info->block); rh_destroy() 296 * Initialize in place a remote heap info block. This is needed to support 301 rh_block_t * block) rh_init() 313 info->block = block; rh_init() 323 for (i = 0, blk = block; i < max_blocks; i++, blk++) rh_init() 369 /* Detatch given address range, splits free block if needed. */ rh_detach_region() 397 /* The range must lie entirely inside one free block */ rh_detach_region() 438 /* Allocate a block of memory at the specified alignment. The value returned 480 /* Create block for fragment in the beginning */ rh_alloc_align() 513 /* Allocate a block of memory at the default alignment. The value returned is 523 /* Allocate a block of memory at the given offset, rounded up to the default 554 /* The range must lie entirely inside one free block */ rh_alloc_fixed() 609 * The return value is the size of the deallocated block, or a negative number 618 /* Linear search for block */ rh_free() 633 /* Get size of freed block */ rh_free() 662 /* Linear search for block */ rh_get_stats() 685 /* Linear search for block */ rh_set_owner() 300 rh_init(rh_info_t * info, unsigned int alignment, int max_blocks, rh_block_t * block) rh_init() argument
|
/linux-4.1.27/arch/s390/include/uapi/asm/ |
H A D | zcrypt.h | 89 * The request (or reply) parameter block is organized thus: 91 * VUD block 92 * key block 102 unsigned int rpl_msgbl; /* reply message block length */ 103 unsigned int rpld_parml; /* replied parameter block len */ 104 unsigned int rpl_datal; /* reply data block len */ 105 unsigned int rpld_datal; /* replied data block len */ 106 unsigned int req_extbl; /* request extension block len */ 108 unsigned int rpld_extbl; /* replied extension block len */ 110 unsigned char * req_parmb; /* request parm block 'address' */ 112 unsigned char * req_datab; /* request data block 'address' */ 114 unsigned char * rpl_parmb; /* reply parm block 'address' */ 116 unsigned char * rpl_datab; /* reply data block 'address' */ 118 unsigned char * req_extb; /* request extension block 'addr'*/ 120 unsigned char * rpl_extb; /* reply extension block 'address'*/ 159 * struct ep11_cprb - EP11 connectivity programming request block 197 * struct ep11_urb - EP11 user request block 203 * @req: Addr to request block 205 * @resp: Addr to response block 234 * block 242 * block
|
/linux-4.1.27/fs/ext4/ |
H A D | ext4_extents.h | 64 * covers all valid ext4 block sizes. Therefore, this tail structure can be 65 * crammed into the end of the block without having to rebalance the tree. 76 __le32 ee_block; /* first logical block extent covers */ 78 __le16 ee_start_hi; /* high 16 bits of physical block */ 79 __le32 ee_start_lo; /* low 32 bits of physical block */ 87 __le32 ei_block; /* index covers logical blocks from 'block' */ 88 __le32 ei_leaf_lo; /* pointer to the physical block of the next * 90 __le16 ei_leaf_hi; /* high 16 bits of physical block */ 95 * Each block (leaves and indexes), even inode-stored has header. 218 * combine low and high parts of physical block number into ext4_fsblk_t 222 ext4_fsblk_t block; ext4_ext_pblock() local 224 block = le32_to_cpu(ex->ee_start_lo); ext4_ext_pblock() 225 block |= ((ext4_fsblk_t) le16_to_cpu(ex->ee_start_hi) << 31) << 1; ext4_ext_pblock() 226 return block; ext4_ext_pblock() 231 * combine low and high parts of a leaf physical block number into ext4_fsblk_t 235 ext4_fsblk_t block; ext4_idx_pblock() local 237 block = le32_to_cpu(ix->ei_leaf_lo); ext4_idx_pblock() 238 block |= ((ext4_fsblk_t) le16_to_cpu(ix->ei_leaf_hi) << 31) << 1; ext4_idx_pblock() 239 return block; ext4_idx_pblock() 244 * stores a large physical block number into an extent struct, 257 * stores a large physical block number into an index struct,
|
H A D | balloc.c | 9 * Enhanced block allocation by Stephen Tweedie (sct@redhat.com), 1993 32 * Calculate block group number for a given block number 35 ext4_fsblk_t block) ext4_get_group_number() 40 group = (block - ext4_get_group_number() 44 ext4_get_group_no_and_offset(sb, block, &group, NULL); ext4_get_group_number() 49 * Calculate the block group number and offset into the block/cluster 50 * allocation bitmap, given a block number 69 * Check whether the 'block' lives within the 'block_group'. Returns 1 if so 73 ext4_fsblk_t block, ext4_block_in_group() 78 actual_group = ext4_get_group_number(sb, block); ext4_block_in_group() 96 * block group descriptors, and reserved block group ext4_num_overhead_clusters() 102 * to check to see if the block is in the block group. If it ext4_num_overhead_clusters() 106 * that block. Otherwise, we will have to track the cluster ext4_num_overhead_clusters() 177 /* Initializes an uninitialized block bitmap */ ext4_init_block_bitmap() 219 /* Set bits for block and inode bitmaps, and inode table */ ext4_init_block_bitmap() 238 * of the block bitmap to 1 ext4_init_block_bitmap() 247 /* Return the number of free blocks in a block group. It is used when 248 * the block bitmap is uninitialized, so we can't just count the bits 260 * blocks groups. Each group contains 1 bitmap block for blocks, 1 bitmap 261 * block for inodes, N blocks for the inode table and data blocks. 264 * super block. Each descriptor contains the number of the bitmap block and 265 * the free blocks count in the block. The descriptors are loaded in memory 271 * @sb: super block 272 * @block_group: given block group 273 * @bh: pointer to the buffer head to store the block 311 * Return the block number which was discovered to be invalid, or 0 if 312 * the block bitmap is valid. 326 /* with FLEX_BG, the inode/block bitmaps and itable ext4_valid_block_bitmap() 329 * or it has to also read the block group where the bitmaps ext4_valid_block_bitmap() 336 /* check whether block bitmap block number is set */ ext4_valid_block_bitmap() 340 /* bad block bitmap */ ext4_valid_block_bitmap() 343 /* check whether the inode bitmap block number is set */ ext4_valid_block_bitmap() 347 /* bad block bitmap */ ext4_valid_block_bitmap() 350 /* check whether the inode table block number is set */ ext4_valid_block_bitmap() 379 ext4_error(sb, "bg %u: block %llu: invalid block bitmap", ext4_validate_block_bitmap() 390 ext4_error(sb, "bg %u: bad block bitmap checksum", block_group); ext4_validate_block_bitmap() 403 * @sb: super block 404 * @block_group: given block group 407 * bits for block/inode/inode tables are set in the bitmaps 424 ext4_error(sb, "Cannot get buffer for block bitmap - " ext4_read_block_bitmap_nowait() 491 ext4_error(sb, "Cannot read block bitmap - " ext4_wait_block_bitmap() 497 /* Panic or remount fs read-only if block bitmap is invalid */ ext4_wait_block_bitmap() 520 * @sbi: in-core super block structure. 587 * @sb: super block 610 * ext4_new_meta_blocks() -- allocate block for meta data (indexing) blocks 614 * @goal: given target block(filesystem wide) 618 * Return 1st allocated block number on success, *count stores total account 653 * Adds up the number of free clusters from each block group. 810 * the beginning of a block group, including the reserved gdt blocks. 834 * ext4_inode_to_goal_block - return a hint for block allocation 835 * @inode: inode for block allocation 853 * block groups per flexgroup, reserve the first block ext4_inode_to_goal_block() 855 * files will start at the second block group. This ext4_inode_to_goal_block() 34 ext4_get_group_number(struct super_block *sb, ext4_fsblk_t block) ext4_get_group_number() argument 72 ext4_block_in_group(struct super_block *sb, ext4_fsblk_t block, ext4_group_t block_group) ext4_block_in_group() argument
|
H A D | extents_status.h | 60 ext4_lblk_t es_lblk; /* first logical block extent covers */ 61 ext4_lblk_t es_len; /* length of extent in block */ 62 ext4_fsblk_t es_pblk; /* first physical block */ 151 ext4_fsblk_t block; ext4_es_store_pblock() local 153 block = (pb & ~ES_MASK) | (es->es_pblk & ES_MASK); ext4_es_store_pblock() 154 es->es_pblk = block; ext4_es_store_pblock()
|
H A D | indirect.c | 19 * Goal-directed block allocation by Stephen Tweedie 42 * ext4_block_to_path - parse the block number into array of offsets 44 * @i_block: block number to be parsed 46 * @boundary: set this non-zero if the referred-to block is likely to be 47 * followed (on disk) by an indirect block. 52 * This function translates the block number into path in that tree - 54 * pointer to (n+1)th node in the nth one. If @block is out of range 64 * indirect block) is spelled differently, because otherwise on an 103 ext4_warning(inode->i_sb, "block %lu > max in inode %lu", ext4_block_to_path() 123 * the number of (i+1)-th block in the chain (as it is stored in memory, 127 * block for i>0 and NULL for i==0. In other words, it holds the block 132 * Function stops when it stumbles upon zero pointer (absent block) 134 * or when it gets an IO error reading an indirect block 168 /* validate block references */ ext4_get_branch() 191 * @ind: descriptor of indirect block. 193 * This function returns the preferred place for block allocation. 196 * + if there is a block to the left of our position - allocate near it. 197 * + if pointer will live in indirect block - allocate near that block. 201 * In the latter case we colour the starting block by the callers PID to 203 * in the same block group. The PID is used here so that functionally related 214 /* Try to find previous block */ ext4_find_near() 220 /* No such thing, so let's try location of indirect block */ ext4_find_near() 234 * @block: block we want 237 * Normally this function find the preferred place for block allocation, 239 * Because this is only used for non-extent files, we limit the block nr 242 static ext4_fsblk_t ext4_find_goal(struct inode *inode, ext4_lblk_t block, ext4_find_goal() argument 248 * XXX need to get goal block from mballoc's data structures ext4_find_goal() 257 * ext4_blks_to_allocate - Look up the block map and count the number 263 * @blocks_to_boundary: the offset in the indirect block 274 * Simple case, [t,d]Indirect block(s) has not allocated yet ext4_blks_to_allocate() 384 * buffer at branch[0].bh is indirect block / inode already ext4_alloc_branch() 400 * @block: (logical) number of block we are adding 409 * chain to new block and return 0. 420 * If we're splicing into a [td]indirect block (as opposed to the ext4_splice_branch() 421 * inode) then we need to get write access to the [td]indirect block ext4_splice_branch() 445 /* had we spliced it onto indirect block? */ ext4_splice_branch() 448 * If we spliced it onto an indirect block, we haven't ext4_splice_branch() 450 * onto an indirect block at the very end of the file (the ext4_splice_branch() 462 * OK, we spliced it into the inode itself on a direct block. ext4_splice_branch() 473 * need to revoke the block, which is why we don't ext4_splice_branch() 496 * write on the parent block. 539 /* Simplest case - block found, no allocation needed */ ext4_ind_map_blocks() 557 /* Next simple case - plain lookup or failed read of indirect block */ ext4_ind_map_blocks() 562 * Okay, we need to do block allocation. ext4_ind_map_blocks() 571 /* Set up for the direct block allocation */ ext4_ind_map_blocks() 763 * to allocate a new block at @lblocks for non extent file based file 796 * 2 dindirect blocks, and 1 tindirect block ext4_ind_trans_blocks() 851 * data block, indeed). We have to free the top of that path along 859 * block number of its root in *@top, pointers to buffer_heads of 897 * OK, we've found the last block that must survive. The rest of our ext4_find_shared() 922 * Zero a number of block pointers in either an inode or an indirect block. 924 * indirect block for further modification. 929 * Return 0 on success, 1 on invalid block range 992 * @first: array of block numbers 1004 * block pointers. 1010 ext4_fsblk_t block_to_free = 0; /* Starting block # of a run */ ext4_free_data() 1015 ext4_fsblk_t nr; /* Current block # */ ext4_free_data() 1017 for current block */ ext4_free_data() 1020 if (this_bh) { /* For indirect block */ ext4_free_data() 1065 * block pointed to itself, it would have been detached when ext4_free_data() 1066 * the block was cleared. Check for this instead of OOPSing. ext4_free_data() 1072 "circular indirect block detected at " ext4_free_data() 1073 "block %llu", ext4_free_data() 1083 * @first: array of block numbers 1114 "block %lu (level %d)", ext4_free_branches() 1132 /* This zaps the entire block. Bottom up. */ ext4_free_branches() 1144 * We want the freeing of this indirect block to be ext4_free_branches() 1146 * bitmap block which owns it. So make some room in ext4_free_branches() 1153 * will merely complain about releasing a free block, ext4_free_branches() 1170 * indirect block if it gets reallocated as a ext4_free_branches() 1171 * data block. This must happen in the same ext4_free_branches() 1181 * The block which we have just freed is ext4_free_branches() 1182 * pointed to by an indirect block: journal it ext4_free_branches() 1241 * equal to the indirect block limit. ext4_ind_truncate() 1263 /* Shared branch grows from an indirect block */ ext4_ind_truncate() 1309 * @start: First block to remove 1310 * @end: One block after the last block to remove (exclusive) 1342 /* We're punching only within direct block range */ ext4_ind_remove_space() 1349 * free partial block at start, and partial block at end of ext4_ind_remove_space() 1356 * Start is at the direct block level, free ext4_ind_remove_space() 1373 /* Shared branch grows from an indirect block */ ext4_ind_remove_space() 1458 /* Shared branch grows from an indirect block */ ext4_ind_remove_space() 1485 * We've converged on the same block. Clear the range, ext4_ind_remove_space() 1504 * block. ext4_ind_remove_space()
|
/linux-4.1.27/drivers/ipack/devices/ |
H A D | scc2698.h | 30 u8 junk[8]; /* other crap for block control */ 37 u8 junk[8]; /* other crap for block control */ 44 * The scc2698 contain 4 block. 45 * Each block containt two channel a and b. 55 u8 d4, ipcr; /* Input port change register of block */ 56 u8 d5, isr; /* Interrupt status register of block */ 57 u8 d6, ctur; /* Counter timer upper register of block */ 58 u8 d7, ctlr; /* Counter timer lower register of block */ 64 u8 dd, ip; /* Input port register of block */ 65 u8 de, ctg; /* Start counter timer of block */ 66 u8 df, cts; /* Stop counter timer of block */ 73 u8 d4, acr; /* Auxiliary control register of block */ 74 u8 d5, imr; /* Interrupt mask register of block */ 75 u8 d6, ctu; /* Counter timer upper register of block */ 76 u8 d7, ctl; /* Counter timer lower register of block */ 82 u8 dd, opcr; /* Output port configuration register of block */
|
/linux-4.1.27/drivers/isdn/hardware/eicon/ |
H A D | dfifo.h | 45 byte[1] -> length of data in block 49 #define DIVA_DFIFO_WRAP 0x80 /* This is the last block in fifo */ 50 #define DIVA_DFIFO_READY 0x40 /* This block is ready for processing */ 51 #define DIVA_DFIFO_LAST 0x20 /* This block is last in message */
|
/linux-4.1.27/drivers/s390/cio/ |
H A D | orb.h | 15 * Command-mode operation request block 31 u32 i2k:1; /* IDAW 2/4kB block size control */ 40 * Transport-mode operation request block 63 * eadm operation request block
|
/linux-4.1.27/drivers/base/regmap/ |
H A D | regcache-lzo.c | 174 /* alloc the working space for the compressed block */ regcache_lzo_init() 242 /* index of the compressed lzo block */ regcache_lzo_read() 244 /* register index within the decompressed block */ regcache_lzo_read() 246 /* size of the compressed block */ regcache_lzo_read() 251 /* save the pointer and length of the compressed block */ regcache_lzo_read() 255 /* prepare the source to be the compressed block */ regcache_lzo_read() 259 /* decompress the block */ regcache_lzo_read() 266 /* restore the pointer and length of the compressed block */ regcache_lzo_read() 281 /* index of the compressed lzo block */ regcache_lzo_write() 283 /* register index within the decompressed block */ regcache_lzo_write() 285 /* size of the compressed block */ regcache_lzo_write() 290 /* save the pointer and length of the compressed block */ regcache_lzo_write() 294 /* prepare the source to be the compressed block */ regcache_lzo_write() 298 /* decompress the block */ regcache_lzo_write() 311 /* prepare the source to be the decompressed block */ regcache_lzo_write() 315 /* compress the block */ regcache_lzo_write()
|
/linux-4.1.27/arch/cris/boot/rescue/ |
H A D | testrescue.S | 2 * Simple testcode to download by the rescue block.
|
/linux-4.1.27/arch/m68k/include/asm/ |
H A D | pci.h | 8 * address space. The networking and block device layers use
|
/linux-4.1.27/include/linux/amba/ |
H A D | mmci.h | 11 * (also known as PL180) block. 12 * @ocr_mask: available voltages on the 4 pins from the block, this 19 * block. May also control external power based on the power_mode. 20 * @status: if no GPIO read function was given to the block in
|
/linux-4.1.27/drivers/gpu/drm/udl/ |
H A D | udl_connector.c | 24 u8 *block; udl_get_edid() local 28 block = kmalloc(EDID_LENGTH, GFP_KERNEL); udl_get_edid() 29 if (block == NULL) udl_get_edid() 45 block[i] = rbuf[1]; udl_get_edid() 49 return block; udl_get_edid() 52 kfree(block); udl_get_edid() 70 * We only read the main block, but if the monitor reports extension udl_get_modes()
|
/linux-4.1.27/fs/hfs/ |
H A D | extent.c | 21 static void hfs_ext_build_key(hfs_btree_key *key, u32 cnid, u16 block, u8 type) hfs_ext_build_key() argument 26 key->ext.FABN = cpu_to_be16(block); hfs_ext_build_key() 37 * and the allocation block number field is the least significant 72 * Find a block within an extent record 82 return be16_to_cpu(ext->block) + off; hfs_ext_find_block() 107 return be16_to_cpu(ext->block) + be16_to_cpu(ext->count); hfs_ext_lastblock() 147 u32 cnid, u32 block, u8 type) __hfs_ext_read_extent() 151 hfs_ext_build_key(fd->search_key, cnid, block, type); __hfs_ext_read_extent() 165 static inline int __hfs_ext_cache_extent(struct hfs_find_data *fd, struct inode *inode, u32 block) __hfs_ext_cache_extent() argument 176 block, HFS_IS_RSRC(inode) ? HFS_FK_RSRC : HFS_FK_DATA); __hfs_ext_cache_extent() 187 static int hfs_ext_read_extent(struct inode *inode, u16 block) hfs_ext_read_extent() argument 192 if (block >= HFS_I(inode)->cached_start && hfs_ext_read_extent() 193 block < HFS_I(inode)->cached_start + HFS_I(inode)->cached_blocks) hfs_ext_read_extent() 198 res = __hfs_ext_cache_extent(&fd, inode, block); hfs_ext_read_extent() 211 be16_to_cpu(extent[i].block), hfs_dump_extent() 226 start = be16_to_cpu(extent->block); hfs_add_extent() 231 extent->block = cpu_to_be16(alloc_block); hfs_add_extent() 263 start = be16_to_cpu(extent->block); hfs_free_extents() 266 extent->block = 0; hfs_free_extents() 332 int hfs_get_block(struct inode *inode, sector_t block, hfs_get_block() argument 340 /* Convert inode block to disk allocation block */ hfs_get_block() 341 ablock = (u32)block / HFS_SB(sb)->fs_div; hfs_get_block() 343 if (block >= HFS_I(inode)->fs_blocks) { hfs_get_block() 344 if (block > HFS_I(inode)->fs_blocks || !create) hfs_get_block() 373 (u32)block % HFS_SB(sb)->fs_div); hfs_get_block() 413 HFS_I(inode)->first_extents[0].block = cpu_to_be16(start); hfs_extend_file() 459 HFS_I(inode)->cached_extents[0].block = cpu_to_be16(start); hfs_extend_file() 146 __hfs_ext_read_extent(struct hfs_find_data *fd, struct hfs_extent *extent, u32 cnid, u32 block, u8 type) __hfs_ext_read_extent() argument
|
H A D | part_tbl.c | 17 * For each partition on the media there is a physical block (512-byte 18 * block) containing one of these structures. These blocks are 19 * contiguous starting at block 1. 25 __be32 pmPyPartStart; /* physical block start of partition */ 26 __be32 pmPartBlkCnt; /* physical block count of partition */
|
/linux-4.1.27/arch/powerpc/crypto/ |
H A D | md5-glue.c | 60 memcpy((char *)sctx->block + offset, src, len); ppc_md5_update() 65 memcpy((char *)sctx->block + offset, src, avail); ppc_md5_update() 66 ppc_md5_transform(sctx->hash, (const u8 *)sctx->block, 1); ppc_md5_update() 77 memcpy((char *)sctx->block, src, len); ppc_md5_update() 85 const u8 *src = (const u8 *)sctx->block; ppc_md5_final() 88 __le64 *pbits = (__le64 *)((char *)sctx->block + 56); ppc_md5_final() 96 p = (char *)sctx->block; ppc_md5_final()
|
/linux-4.1.27/include/sound/ |
H A D | util_mem.h | 26 * memory block 29 unsigned int size; /* size of this block */ 30 unsigned int offset; /* zero-offset of this block */ 41 struct list_head block; /* block linked-list header */ member in struct:snd_util_memhdr
|
/linux-4.1.27/arch/arm/mach-omap2/ |
H A D | msdi.c | 2 * MSDI IP block reset 37 * MSDI_CON_OFFSET: offset in bytes of the MSDI IP block's CON register 38 * from the IP block's base address 51 * omap_msdi_reset - reset the MSDI IP block 54 * The MSDI IP block on OMAP2420 has to have both the POW and CLKD
|
/linux-4.1.27/arch/x86/kernel/cpu/mcheck/ |
H A D | mce_amd.c | 123 "for bank %d, block %d (MSR%08X=0x%x%08x)\n", b->cpu, lvt_off_valid() 124 b->bank, b->block, b->address, hi, lo); lvt_off_valid() 130 "for bank %d, block %d (MSR%08X=0x%x%08x)\n", lvt_off_valid() 131 b->cpu, apic, b->bank, b->block, b->address, hi, lo); lvt_off_valid() 214 unsigned int bank, block; mce_amd_feature_init() local 218 for (block = 0; block < NR_BLOCKS; ++block) { mce_amd_feature_init() 219 if (block == 0) mce_amd_feature_init() 221 else if (block == 1) { mce_amd_feature_init() 240 if (!block) mce_amd_feature_init() 246 b.block = block; mce_amd_feature_init() 280 unsigned int bank, block; amd_threshold_interrupt() local 287 for (block = 0; block < NR_BLOCKS; ++block) { amd_threshold_interrupt() 288 if (block == 0) { amd_threshold_interrupt() 290 } else if (block == 1) { amd_threshold_interrupt() 303 if (block) amd_threshold_interrupt() 468 unsigned int block, u32 address) allocate_threshold_blocks() 474 if ((bank >= mca_cfg.banks) || (block >= NR_BLOCKS)) allocate_threshold_blocks() 481 if (block) allocate_threshold_blocks() 495 b->block = block; allocate_threshold_blocks() 525 if (!block) { allocate_threshold_blocks() 534 err = allocate_threshold_blocks(cpu, bank, ++block, address); allocate_threshold_blocks() 467 allocate_threshold_blocks(unsigned int cpu, unsigned int bank, unsigned int block, u32 address) allocate_threshold_blocks() argument
|
/linux-4.1.27/fs/hfsplus/ |
H A D | part_tbl.c | 21 #define HFS_DD_BLK 0 /* Driver Descriptor block */ 22 #define HFS_PMAP_BLK 1 /* First block of partition map */ 29 #define HFS_SUPER_MAGIC 0x4244 /* "BD": HFS MDB (super block) */ 30 #define HFS_MFS_SUPER_MAGIC 0xD2D7 /* MFS MDB (super block) */ 35 * For each partition on the media there is a physical block (512-byte 36 * block) containing one of these structures. These blocks are 37 * contiguous starting at block 1. 43 __be32 pmPyPartStart; /* physical block start of partition */ 44 __be32 pmPartBlkCnt; /* physical block count of partition */
|
/linux-4.1.27/arch/arm64/kernel/ |
H A D | setup.c | 239 u64 features, block; setup_processor() local 269 block = (features >> 4) & 0xf; setup_processor() 270 if (!(block & 0x8)) { setup_processor() 271 switch (block) { setup_processor() 282 block = (features >> 8) & 0xf; setup_processor() 283 if (block && !(block & 0x8)) setup_processor() 286 block = (features >> 12) & 0xf; setup_processor() 287 if (block && !(block & 0x8)) setup_processor() 290 block = (features >> 16) & 0xf; setup_processor() 291 if (block && !(block & 0x8)) setup_processor() 300 block = (features >> 4) & 0xf; setup_processor() 301 if (!(block & 0x8)) { setup_processor() 302 switch (block) { setup_processor() 313 block = (features >> 8) & 0xf; setup_processor() 314 if (block && !(block & 0x8)) setup_processor() 317 block = (features >> 12) & 0xf; setup_processor() 318 if (block && !(block & 0x8)) setup_processor() 321 block = (features >> 16) & 0xf; setup_processor() 322 if (block && !(block & 0x8)) setup_processor()
|
/linux-4.1.27/fs/ocfs2/ |
H A D | ocfs2_fs.h | 137 * s_tunefs_flags on the super block describes precisely which 171 /* Discontigous block groups */ 209 /* The byte offset of the first backup block will be 1G. 231 #define OCFS2_SUPER_BLOCK_FL (0x00000020) /* Super block */ 248 #define OCFS2_INLINE_DATA_FL (0x0001) /* Data stored in inode block */ 543 * On disk extent block (indirect block) for OCFS2 552 block group */ 553 __le32 h_fs_generation; /* Must match super block */ 555 /*20*/ __le64 h_suballoc_loc; /* Suballocator block group this 558 discontiguous block group */ 563 /* Actual on-disk size is one block */ 574 * Actual on-disk size is one block. OCFS2_MAX_SLOTS is 255, 575 * 255 * sizeof(__le16) == 512B, within the 512B block minimum blocksize. 708 block group */ 724 block */ 735 /*88*/ __le64 i_dx_root; /* Pointer to dir index root block */ 737 __le64 i_suballoc_loc; /* Suballocator block group this 740 discontiguous block group */ 774 /* Actual on-disk size is one block */ 792 * Per-block record for the unindexed directory btree. This is carefully 808 * in this block. (unused) */ 811 __le64 db_free_next; /* Next block in list (unused) */ 830 * block in cluster */ 831 __le64 dx_dirent_blk; /* Physical block in unindexed 849 * A directory indexing block. Each indexed directory has one of these, 852 * This block stores an indexed btree root, and a set of free space 859 * block belongs to. */ 861 * block group */ 862 __le32 dr_fs_generation; /* Must match super block */ 865 * extent block */ 877 * unindexed block list. */ 878 __le64 dr_suballoc_loc; /* Suballocator block group 882 block group */ 888 struct ocfs2_dx_entry_list dr_entries; /* In-root-block list of 896 * The header of a leaf block in the indexed tree. 902 __le32 dl_fs_generation;/* Must match super block */ 909 * Largest bitmap for a block (suballocator) group in bytes. This limit 911 * bitmaps run to the end of the block. 942 * The extents of a discontigous block group are 946 * bg_list->l_next_free_rec. Only block groups 948 * We've never made a block group with more than 951 * bg_size of a discontiguous block group will 958 /* Actual on-disk size is one block */ 984 __le16 rf_suballoc_slot; /* Slot suballocator this block 987 block group */ 990 __le64 rf_parent; /* Parent block, only valid if 994 __le64 rf_last_eb_blk; /* Pointer to last extent block */ 1003 __le64 rf_suballoc_loc; /* Suballocator block group this 1004 refcount block belongs to. Only 1006 discontiguous block group */ 1016 /* Actual on-disk size is one block */ 1026 * Note that it can be stored in inode, one block or one xattr bucket. 1031 local xattr storage(inode, xattr block or 1061 buckets. A block uses 1076 __le64 xr_last_eb_blk; /* Pointer to last extent block */ 1089 __le64 xt_last_eb_blk; /* Pointer to last extent block */ 1104 * On disk structure for xattr block. 1109 block belongs to. */ 1111 block group */ 1112 __le32 xb_fs_generation; /* Must match super block */ 1115 /*20*/ __le16 xb_flags; /* Indicates whether this block contains 1119 __le64 xb_suballoc_loc; /* Suballocator block group this 1120 xattr block belongs to. Only 1122 discontiguous block group */ 1125 block contains xattr */ 1127 block cotains xattr 1174 /* Each block of each quota file has a certain fixed number of bytes reserved 1195 /*10*/ __le32 dqi_free_blk; /* First free block in quota file */ 1196 __le32 dqi_free_entry; /* First block with free dquot entry in quota 1263 * The quota trailer lives at the end of each quota block. 1407 * The cluster allocator uses the entire block. Suballocators have ocfs2_group_bitmap_size() 1555 * The cluster allocator uses the entire block. Suballocators have ocfs2_group_bitmap_size()
|
/linux-4.1.27/fs/qnx4/ |
H A D | namei.c | 59 unsigned long block, offset, blkofs; qnx4_find_entry() local 64 block = offset = blkofs = 0; qnx4_find_entry() 67 block = qnx4_block_map(dir, blkofs); qnx4_find_entry() 68 if (block) qnx4_find_entry() 69 bh = sb_bread(dir->i_sb, block); qnx4_find_entry() 77 *ino = block * QNX4_INODES_PER_BLOCK + qnx4_find_entry()
|
H A D | inode.c | 62 // logical block is before EOF qnx4_get_block() 86 u32 block = try_extent(&qnx4_inode->di_first_xtnt, &offset); qnx4_block_map() local 88 if (block) { qnx4_block_map() 96 // read next xtnt block. qnx4_block_map() 99 QNX4DEBUG((KERN_ERR "qnx4: I/O error reading xtnt block [%ld])\n", i_xblk - 1)); qnx4_block_map() 104 QNX4DEBUG((KERN_ERR "qnx4: block at %ld is not a valid xtnt\n", qnx4_inode->i_xblk)); qnx4_block_map() 108 block = try_extent(&xblk->xblk_xtnts[ix], &offset); qnx4_block_map() 109 if (block) { qnx4_block_map() 124 QNX4DEBUG((KERN_INFO "qnx4: mapping block %ld of inode %ld = %ld\n",iblock,inode->i_ino,block)); qnx4_block_map() 125 return block; qnx4_block_map() 164 bh = sb_bread(sb, rd + j); /* root dir, first block */ qnx4_checkroot() 251 static sector_t qnx4_bmap(struct address_space *mapping, sector_t block) qnx4_bmap() argument 253 return generic_block_bmap(mapping,block,qnx4_get_block); qnx4_bmap() 264 int block; qnx4_iget() local 285 block = ino / QNX4_INODES_PER_BLOCK; qnx4_iget() 287 if (!(bh = sb_bread(sb, block))) { qnx4_iget()
|
/linux-4.1.27/fs/gfs2/ |
H A D | rgrp.c | 53 * to keep track of block allocation. Each block is represented by two 84 * @new_state: the new state of the block 127 * Returns: The two bit block state of the requested bit 177 * rs_cmp - multi-block reservation range compare 178 * @blk: absolute file system block number of the new reservation 182 * returns: 1 if the block range is beyond the reach of the reservation 183 * -1 if the block range is before the start of the reservation 184 * 0 if the block range overlaps with the reservation 199 * a block in a given allocation state. 202 * @goal: start search at this block's bit-pair (within @buffer) 203 * @state: GFS2_BLKST_XXX the state of the block we're looking for. 205 * Scope of @goal and returned block number is only within this bitmap buffer, 207 * beginning of a bitmap block buffer, skipping any header structures, but 213 * of the block in case the end is no aligned to a natural boundary. 215 * Return: the block number (bitmap buffer scope) that was found 249 * gfs2_rbm_from_block - Set the rbm based upon rgd and block number 251 * @block: The block number (filesystem relative) 254 * resource group and a filesystem relative block number. The 261 static int gfs2_rbm_from_block(struct gfs2_rbm *rbm, u64 block) gfs2_rbm_from_block() argument 263 u64 rblock = block - rbm->rgd->rd_data0; gfs2_rbm_from_block() 267 if (block >= rbm->rgd->rd_data0 + rbm->rgd->rd_data) gfs2_rbm_from_block() 272 /* Check if the block is within the first block */ gfs2_rbm_from_block() 289 * viable block offset. 314 * @len: Decremented for each block found (terminate on zero) 316 * Returns: true if a non-free block is encountered 343 * Starting at the block specified by the rbm, see how many free blocks 346 * on a block by block basis in case of unaligned blocks. Also this 361 u64 block; gfs2_free_extlen() local 385 block = gfs2_rbm_to_block(&rbm); gfs2_free_extlen() 386 if (gfs2_rbm_from_block(&rbm, block + chunk_size)) { gfs2_free_extlen() 409 * @state: the state of the block we're looking for 487 static inline int rgrp_contains_block(struct gfs2_rgrpd *rgd, u64 block) rgrp_contains_block() argument 491 return first <= block && block < last; rgrp_contains_block() 495 * gfs2_blk2rgrpd - Find resource group for a given data/meta block number 497 * @blk: The data block number 631 * __rs_deltree - remove a multi-block reservation from the rgd tree 664 * gfs2_rs_deltree - remove a multi-block reservation from the rgd tree 681 * gfs2_rs_delete - delete a multi-block reservation 759 * Calculates bitmap descriptors, one for each block that contains bitmap data 785 /* small rgrp; bitmap stored completely in header block */ compute_bitstructs() 792 /* header block */ compute_bitstructs() 799 /* last block */ compute_bitstructs() 1435 * rs_insert - insert a new multi-block reservation into the rgrp's rb_tree 1505 /* Find bitmap block that contains bits for goal block */ rg_mblk_search() 1527 * gfs2_next_unreserved_block - Return next block that is not reserved 1529 * @block: The starting block 1533 * If the block does not appear in any reservation, then return the 1534 * block number unchanged. If it does appear in the reservation, then 1536 * first block number which is not reserved. 1539 static u64 gfs2_next_unreserved_block(struct gfs2_rgrpd *rgd, u64 block, gfs2_next_unreserved_block() argument 1551 rc = rs_cmp(block, length, rs); gfs2_next_unreserved_block() 1561 while ((rs_cmp(block, length, rs) == 0) && (ip->i_res != rs)) { gfs2_next_unreserved_block() 1562 block = gfs2_rbm_to_block(&rs->rs_rbm) + rs->rs_free; gfs2_next_unreserved_block() 1571 return block; gfs2_next_unreserved_block() 1575 * gfs2_reservation_check_and_update - Check for reservations during block alloc 1582 * a reservation covering this block. If not then this function is a 1585 * non-reserved block. 1595 u64 block = gfs2_rbm_to_block(rbm); gfs2_reservation_check_and_update() local 1614 nblock = gfs2_next_unreserved_block(rbm->rgd, block, extlen, ip); gfs2_reservation_check_and_update() 1615 if (nblock == block) { gfs2_reservation_check_and_update() 1624 nblock = block + extlen; gfs2_reservation_check_and_update() 1636 * @minext: Pointer to the requested extent length (NULL for a single block) 1647 * has come up short on a free block search. 1649 * Returns: 0 on success, -ENOSPC if there is no block of the requested state 1757 * @last_unlinked: block address of the last dinode we unlinked 1758 * @skip: block address we should explicitly not unlink 1766 u64 block; try_rgrp_unlink() local 1784 block = gfs2_rbm_to_block(&rbm); try_rgrp_unlink() 1785 if (gfs2_rbm_from_block(&rbm, block + 1)) try_rgrp_unlink() 1787 if (*last_unlinked != NO_BLOCK && block <= *last_unlinked) try_rgrp_unlink() 1789 if (block == skip) try_rgrp_unlink() 1791 *last_unlinked = block; try_rgrp_unlink() 1793 error = gfs2_glock_get(sdp, block, &gfs2_inode_glops, CREATE, &gl); try_rgrp_unlink() 1886 * @rs: The block reservation with the rgrp to test 2100 * gfs2_get_block_type - Check a block in a RG is of given type 2101 * @rgd: the resource group holding the block 2102 * @block: the block number 2104 * Returns: The block type (GFS2_BLKST_*) 2107 static unsigned char gfs2_get_block_type(struct gfs2_rgrpd *rgd, u64 block) gfs2_get_block_type() argument 2112 ret = gfs2_rbm_from_block(&rbm, block); gfs2_get_block_type() 2122 * @dinode: TRUE if the first block we allocate is for a dinode 2126 * Set the found bits to @new_state to change block's allocation state. 2133 u64 block; gfs2_alloc_extent() local 2137 block = gfs2_rbm_to_block(rbm); gfs2_alloc_extent() 2140 block++; gfs2_alloc_extent() 2142 ret = gfs2_rbm_from_block(&pos, block); gfs2_alloc_extent() 2148 block++; gfs2_alloc_extent() 2153 * rgblk_free - Change alloc state of given block(s) 2156 * @blen: the length of the block run (all must lie within ONE RG!) 2157 * @new_state: GFS2_BLKST_XXX the after-allocation block state 2159 * Returns: Resource group containing the block(s) 2171 fs_err(sdp, "block = %llu\n", (unsigned long long)bstart); rgblk_free() 2250 u64 block; gfs2_adjust_reservation() local 2256 block = gfs2_rbm_to_block(rbm); gfs2_adjust_reservation() 2257 ret = gfs2_rbm_from_block(&rs->rs_rbm, block + len); gfs2_adjust_reservation() 2264 /* We used up our block reservation, so we should gfs2_adjust_reservation() 2275 * gfs2_set_alloc_start - Set starting point for block allocation 2282 * inode's goal block or the last allocation point in the rgrp. 2305 * @ip: the inode to allocate the block for 2306 * @bn: Used to return the starting block number 2308 * @dinode: 1 if we're allocating a dinode block, else 0 2321 u64 block; /* block, within the file system scope */ gfs2_alloc_blocks() local 2343 block = gfs2_rbm_to_block(&rbm); gfs2_alloc_blocks() 2344 rbm.rgd->rd_last_alloc = block - rbm.rgd->rd_data0; gfs2_alloc_blocks() 2352 ip->i_goal = block + ndata - 1; gfs2_alloc_blocks() 2382 gfs2_trans_add_unrevoke(sdp, block, *nblocks); gfs2_alloc_blocks() 2387 trace_gfs2_block_alloc(ip, rbm.rgd, block, *nblocks, gfs2_alloc_blocks() 2389 *bn = block; gfs2_alloc_blocks() 2398 * __gfs2_free_blocks - free a contiguous run of block(s) 2400 * @bstart: first block of a run of contiguous blocks 2401 * @blen: the length of the block run 2427 * gfs2_free_meta - free a contiguous run of data block(s) 2429 * @bstart: first block of a run of contiguous blocks 2430 * @blen: the length of the block run 2493 * gfs2_check_blk_type - Check the type of a block 2495 * @no_addr: The block number to check 2496 * @type: The block type we are looking for 2498 * Returns: 0 if the block type matches the expected type 2529 * @block: the block 2531 * Figure out what RG a block belongs to and add that RG to the list 2538 u64 block) gfs2_rlist_add() 2549 if (ip->i_rgd && rgrp_contains_block(ip->i_rgd, block)) gfs2_rlist_add() 2552 rgd = gfs2_blk2rgrpd(sdp, block, 1); gfs2_rlist_add() 2554 fs_err(sdp, "rlist_add: no rgrp for block %llu\n", (unsigned long long)block); gfs2_rlist_add() 2537 gfs2_rlist_add(struct gfs2_inode *ip, struct gfs2_rgrp_list *rlist, u64 block) gfs2_rlist_add() argument
|
/linux-4.1.27/drivers/gpu/drm/nouveau/nvkm/subdev/mmu/ |
H A D | nv50.c | 82 u32 block, target; nv50_vm_map() local 101 block = 1 << (i + 3); nv50_vm_map() 102 if (cnt >= block && !(pte & (block - 1))) nv50_vm_map() 107 phys += block << (vma->node->type - 3); nv50_vm_map() 108 cnt -= block; nv50_vm_map() 112 delta += block << (vma->node->type - 3); nv50_vm_map() 115 while (block) { nv50_vm_map() 119 block -= 8; nv50_vm_map() 198 u32 block = (1 << (mmu->pgt_bits + 12)); nv50_vm_create() local 199 if (block > length) nv50_vm_create() 200 block = length; nv50_vm_create() 202 return nvkm_vm_create(mmu, offset, length, mm_offset, block, pvm); nv50_vm_create()
|
/linux-4.1.27/init/ |
H A D | do_mounts_rd.c | 36 int __initdata rd_image_start; /* starting block # of image */ 90 * Read block 0 to test for compressed kernel identify_ramdisk_image() 97 printk(KERN_NOTICE "RAMDISK: %s image found at block %d\n", identify_ramdisk_image() 107 /* romfs is at block zero too */ identify_ramdisk_image() 111 "RAMDISK: romfs filesystem found at block %d\n", identify_ramdisk_image() 119 "RAMDISK: cramfs filesystem found at block %d\n", identify_ramdisk_image() 125 /* squashfs is at block zero too */ identify_ramdisk_image() 128 "RAMDISK: squashfs filesystem found at block %d\n", identify_ramdisk_image() 143 "RAMDISK: cramfs filesystem found at block %d\n", identify_ramdisk_image() 150 * Read block 1 to test for minix and ext2 superblock identify_ramdisk_image() 159 "RAMDISK: Minix filesystem found at block %d\n", identify_ramdisk_image() 169 "RAMDISK: ext2 filesystem found at block %d\n", identify_ramdisk_image() 219 * So any ramdisk block size that is a multiple of 1KiB should rd_load_image()
|
/linux-4.1.27/fs/ntfs/ |
H A D | compress.c | 44 /* Compression sub-block constants. */ 50 * The maximum compression block size is by definition 16 * the cluster 133 * ntfs_decompress - decompress a compression block into an array of pages 141 * @cb_start: compression block to decompress (IN) 142 * @cb_size: size of compression block @cb_start in bytes (IN) 149 * This decompresses the compression block @cb_start into the array of 156 * @cb_start is a pointer to the compression block which needs decompressing 161 * completed during the decompression of the compression block (@cb_start). 167 * the compression block @cb_start as it is a per-CPU buffer. 176 * Pointers into the compressed data, i.e. the compression block (cb), ntfs_decompress() 187 u8 *dp_sb_start; /* Start of current sub-block in dp. */ ntfs_decompress() 190 u16 do_sb_start; /* @dest_ofs when starting this sub-block. */ ntfs_decompress() 207 ntfs_debug("Beginning sub-block at offset = 0x%zx in the cb.", ntfs_decompress() 210 * Have we reached the end of the compression block or the end of the ntfs_decompress() 212 * position in the compression block is one byte before its end so the ntfs_decompress() 251 /* Setup offsets for the current sub-block destination. */ ntfs_decompress() 263 /* Setup the current sub-block source pointers and validate range. */ ntfs_decompress() 273 /* No page present. Skip decompression of this sub-block. */ ntfs_decompress() 276 /* Advance destination position to next sub-block. */ ntfs_decompress() 286 /* Now, we are ready to process the current sub-block (sb). */ ntfs_decompress() 288 ntfs_debug("Found uncompressed sub-block."); ntfs_decompress() 298 /* Copy the block and advance the source position. */ ntfs_decompress() 302 /* Advance destination position to next sub-block. */ ntfs_decompress() 316 ntfs_debug("Found compressed sub-block."); ntfs_decompress() 323 /* Forward to the first tag in the sub-block. */ ntfs_decompress() 327 /* Check if the decompressed sub-block was not full-length. */ ntfs_decompress() 331 ntfs_debug("Filling incomplete sub-block with " ntfs_decompress() 337 /* We have finished the current sub-block. */ ntfs_decompress() 448 * ntfs_read_compressed_block - read a compressed block into the page cache 449 * @page: locked page in the compression block(s) we need to read 454 * 1. Determine which compression block(s) @page is in. 455 * 2. Get hold of all pages corresponding to this/these compression block(s). 456 * 3. Read the (first) compression block. 459 * block or return success if no more compression blocks left. 521 int block, max_block, cb_max_page, bhs_size, nr_bhs, err = 0; ntfs_read_compressed_block() local 601 * Now read the first compression block. ntfs_read_compressed_block() 650 block = lcn << vol->cluster_size_bits >> block_size_bits; ntfs_read_compressed_block() 652 max_block = block + (vol->cluster_size >> block_size_bits); ntfs_read_compressed_block() 654 ntfs_debug("block = 0x%x.", block); ntfs_read_compressed_block() 655 if (unlikely(!(bhs[nr_bhs] = sb_getblk(sb, block)))) ntfs_read_compressed_block() 658 } while (++block < max_block); ntfs_read_compressed_block() 735 ntfs_debug("Successfully read the compression block."); ntfs_read_compressed_block() 742 /* Catch end of file inside a compression block. */ ntfs_read_compressed_block() 748 ntfs_debug("Found sparse compression block."); ntfs_read_compressed_block() 800 ntfs_debug("Found uncompressed compression block."); ntfs_read_compressed_block() 865 ntfs_debug("Found compressed compression block."); ntfs_read_compressed_block() 877 "this compression block.", ntfs_read_compressed_block() 942 "compression block."); ntfs_read_compressed_block() 948 "compression block."); ntfs_read_compressed_block() 953 ntfs_error(vol->sb, "getblk() failed. Cannot read compression block."); ntfs_read_compressed_block()
|
/linux-4.1.27/drivers/media/platform/vivid/ |
H A D | vivid-rds-gen.c | 51 * All remaining groups use a filler group 15B block that just repeats 66 data[0].block = V4L2_RDS_BLOCK_A | (V4L2_RDS_BLOCK_A << 3); vivid_rds_generate() 69 data[1].block = V4L2_RDS_BLOCK_B | (V4L2_RDS_BLOCK_B << 3); vivid_rds_generate() 70 data[3].block = V4L2_RDS_BLOCK_D | (V4L2_RDS_BLOCK_D << 3); vivid_rds_generate() 81 data[2].block = V4L2_RDS_BLOCK_C_ALT | (V4L2_RDS_BLOCK_C_ALT << 3); vivid_rds_generate() 91 data[2].block = V4L2_RDS_BLOCK_C | (V4L2_RDS_BLOCK_C << 3); vivid_rds_generate() 117 data[2].block = V4L2_RDS_BLOCK_C | (V4L2_RDS_BLOCK_C << 3); vivid_rds_generate() 127 data[2].block = V4L2_RDS_BLOCK_C_ALT | (V4L2_RDS_BLOCK_C_ALT << 3); vivid_rds_generate()
|
/linux-4.1.27/drivers/scsi/ |
H A D | st_options.h | 34 /* The "guess" for the block size for devices that don't support MODE 38 /* The minimum tape driver buffer size in kilobytes in fixed block mode. 49 /* The size of the first scatter/gather segments (determines the maximum block 63 /* If ST_BUFFER_WRITES is non-zero, writes in fixed block mode are 73 /* If ST_READ_AHEAD is non-zero, blocks are read ahead in fixed block 88 /* If ST_SCSI2LOGICAL is nonzero, the logical block addresses are used for 97 /* If ST_SILI is non-zero, the SILI bit is set when reading in variable block 98 mode and the block size is determined using the residual returned by the HBA. */
|
/linux-4.1.27/fs/jbd2/ |
H A D | recovery.c | 58 * When reading from the journal, we are going through the block device 85 * a time to the block device IO layer. */ do_readahead() 93 printk(KERN_ERR "JBD2: bad block at offset %u\n", do_readahead() 129 * Read a block from the journal 149 printk(KERN_ERR "JBD2: bad block at offset %u\n", jread() 167 printk(KERN_ERR "JBD2: Failed to read block at offset %u\n", jread() 198 * Count the number of in-use tags in a journal descriptor block. 344 unsigned long long block = be32_to_cpu(tag->t_blocknr); read_tag_block() local 346 block |= (u64)be32_to_cpu(tag->t_blocknr_high) << 32; read_tag_block() 347 return block; read_tag_block() 352 * descriptor block. 362 /* Calculate checksum of the descriptor block. */ calc_chksums() 370 printk(KERN_ERR "JBD2: IO error %d recovering block " calc_chksums() 439 * block offsets): query the superblock. do_one_pass() 454 * making sure that each transaction has a commit block in the do_one_pass() 480 * either the next descriptor block or the final commit do_one_pass() 483 jbd_debug(3, "JBD2: checking block %ld\n", next_log_block); do_one_pass() 493 * If it is a descriptor block, check that it has the do_one_pass() 514 /* OK, we have a valid descriptor block which matches do_one_pass() 528 "recovering block %lu in log\n", do_one_pass() 535 /* If it is a valid descriptor block, replay it do_one_pass() 559 /* A descriptor block: we can now write all of do_one_pass() 580 "block %ld in log\n", do_one_pass() 589 /* If the block has been do_one_pass() 600 /* Look for block corruption */ do_one_pass() 608 "block %llu in log\n", do_one_pass() 678 * Commit block found Commit block not found do_one_pass() 685 * before commit block do_one_pass() 692 /* Found an expected commit block: if checksums do_one_pass() 767 * just skip over this block. */ do_one_pass() 791 * known end of the log or we found an unexpected block in the do_one_pass()
|
/linux-4.1.27/arch/powerpc/include/asm/ |
H A D | vdso_datapage.h | 81 __u32 dcache_block_size; /* L1 d-cache block size */ 82 __u32 icache_block_size; /* L1 i-cache block size */ 83 __u32 dcache_log_block_size; /* L1 d-cache log block size */ 84 __u32 icache_log_block_size; /* L1 i-cache log block size */ 111 __u32 dcache_block_size; /* L1 d-cache block size */ 112 __u32 icache_block_size; /* L1 i-cache block size */ 113 __u32 dcache_log_block_size; /* L1 d-cache log block size */ 114 __u32 icache_log_block_size; /* L1 i-cache log block size */
|
/linux-4.1.27/arch/x86/include/asm/ |
H A D | xor_64.h | 16 /* We force the use of the SSE xor block because it can write around L2.
|