root/fs/sysv/balloc.c

DEFINITIONS

1. get_chunk
2. sysv_free_block
3. sysv_new_block
4. sysv_count_free_blocks

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *  linux/fs/sysv/balloc.c
   4  *
   5  *  minix/bitmap.c
   6  *  Copyright (C) 1991, 1992  Linus Torvalds
   7  *
   8  *  ext/freelists.c
   9  *  Copyright (C) 1992  Remy Card (card@masi.ibp.fr)
  10  *
  11  *  xenix/alloc.c
  12  *  Copyright (C) 1992  Doug Evans
  13  *
  14  *  coh/alloc.c
  15  *  Copyright (C) 1993  Pascal Haible, Bruno Haible
  16  *
  17  *  sysv/balloc.c
  18  *  Copyright (C) 1993  Bruno Haible
  19  *
  20  *  This file contains code for allocating/freeing blocks.
  21  */
  22 
  23 #include <linux/buffer_head.h>
  24 #include <linux/string.h>
  25 #include "sysv.h"
  26 
  27 /* We don't trust the value of
  28    sb->sv_sbd2->s_tfree = *sb->sv_free_blocks
  29    but we nevertheless keep it up to date. */
  30 
  31 static inline sysv_zone_t *get_chunk(struct super_block *sb, struct buffer_head *bh)
  32 {
  33         char *bh_data = bh->b_data;
  34 
  35         if (SYSV_SB(sb)->s_type == FSTYPE_SYSV4)
  36                 return (sysv_zone_t*)(bh_data+4);
  37         else
  38                 return (sysv_zone_t*)(bh_data+2);
  39 }
  40 
  41 /* NOTE NOTE NOTE: nr is a block number _as_ _stored_ _on_ _disk_ */
  42 
  43 void sysv_free_block(struct super_block * sb, sysv_zone_t nr)
  44 {
  45         struct sysv_sb_info * sbi = SYSV_SB(sb);
  46         struct buffer_head * bh;
  47         sysv_zone_t *blocks = sbi->s_bcache;
  48         unsigned count;
  49         unsigned block = fs32_to_cpu(sbi, nr);
  50 
  51         /*
  52          * This code does not work at all for AFS (it has a bitmap
  53          * free list).  As AFS is supposed to be read-only no one
  54          * should call this for an AFS filesystem anyway...
  55          */
  56         if (sbi->s_type == FSTYPE_AFS)
  57                 return;
  58 
  59         if (block < sbi->s_firstdatazone || block >= sbi->s_nzones) {
  60                 printk("sysv_free_block: trying to free block not in datazone\n");
  61                 return;
  62         }
  63 
  64         mutex_lock(&sbi->s_lock);
  65         count = fs16_to_cpu(sbi, *sbi->s_bcache_count);
  66 
  67         if (count > sbi->s_flc_size) {
  68                 printk("sysv_free_block: flc_count > flc_size\n");
  69                 mutex_unlock(&sbi->s_lock);
  70                 return;
  71         }
  72         /* If the free list head in super-block is full, it is copied
  73          * into this block being freed, ditto if it's completely empty
  74          * (applies only on Coherent).
  75          */
  76         if (count == sbi->s_flc_size || count == 0) {
  77                 block += sbi->s_block_base;
  78                 bh = sb_getblk(sb, block);
  79                 if (!bh) {
  80                         printk("sysv_free_block: getblk() failed\n");
  81                         mutex_unlock(&sbi->s_lock);
  82                         return;
  83                 }
  84                 memset(bh->b_data, 0, sb->s_blocksize);
  85                 *(__fs16*)bh->b_data = cpu_to_fs16(sbi, count);
  86                 memcpy(get_chunk(sb,bh), blocks, count * sizeof(sysv_zone_t));
  87                 mark_buffer_dirty(bh);
  88                 set_buffer_uptodate(bh);
  89                 brelse(bh);
  90                 count = 0;
  91         }
  92         sbi->s_bcache[count++] = nr;
  93 
  94         *sbi->s_bcache_count = cpu_to_fs16(sbi, count);
  95         fs32_add(sbi, sbi->s_free_blocks, 1);
  96         dirty_sb(sb);
  97         mutex_unlock(&sbi->s_lock);
  98 }
  99 
 100 sysv_zone_t sysv_new_block(struct super_block * sb)
 101 {
 102         struct sysv_sb_info *sbi = SYSV_SB(sb);
 103         unsigned int block;
 104         sysv_zone_t nr;
 105         struct buffer_head * bh;
 106         unsigned count;
 107 
 108         mutex_lock(&sbi->s_lock);
 109         count = fs16_to_cpu(sbi, *sbi->s_bcache_count);
 110 
 111         if (count == 0) /* Applies only to Coherent FS */
 112                 goto Enospc;
 113         nr = sbi->s_bcache[--count];
 114         if (nr == 0)  /* Applies only to Xenix FS, SystemV FS */
 115                 goto Enospc;
 116 
 117         block = fs32_to_cpu(sbi, nr);
 118 
 119         *sbi->s_bcache_count = cpu_to_fs16(sbi, count);
 120 
 121         if (block < sbi->s_firstdatazone || block >= sbi->s_nzones) {
 122                 printk("sysv_new_block: new block %d is not in data zone\n",
 123                         block);
 124                 goto Enospc;
 125         }
 126 
 127         if (count == 0) { /* the last block continues the free list */
 128                 unsigned count;
 129 
 130                 block += sbi->s_block_base;
 131                 if (!(bh = sb_bread(sb, block))) {
 132                         printk("sysv_new_block: cannot read free-list block\n");
 133                         /* retry this same block next time */
 134                         *sbi->s_bcache_count = cpu_to_fs16(sbi, 1);
 135                         goto Enospc;
 136                 }
 137                 count = fs16_to_cpu(sbi, *(__fs16*)bh->b_data);
 138                 if (count > sbi->s_flc_size) {
 139                         printk("sysv_new_block: free-list block with >flc_size entries\n");
 140                         brelse(bh);
 141                         goto Enospc;
 142                 }
 143                 *sbi->s_bcache_count = cpu_to_fs16(sbi, count);
 144                 memcpy(sbi->s_bcache, get_chunk(sb, bh),
 145                                 count * sizeof(sysv_zone_t));
 146                 brelse(bh);
 147         }
 148         /* Now the free list head in the superblock is valid again. */
 149         fs32_add(sbi, sbi->s_free_blocks, -1);
 150         dirty_sb(sb);
 151         mutex_unlock(&sbi->s_lock);
 152         return nr;
 153 
 154 Enospc:
 155         mutex_unlock(&sbi->s_lock);
 156         return 0;
 157 }
 158 
 159 unsigned long sysv_count_free_blocks(struct super_block * sb)
 160 {
 161         struct sysv_sb_info * sbi = SYSV_SB(sb);
 162         int sb_count;
 163         int count;
 164         struct buffer_head * bh = NULL;
 165         sysv_zone_t *blocks;
 166         unsigned block;
 167         int n;
 168 
 169         /*
 170          * This code does not work at all for AFS (it has a bitmap
 171          * free list).  As AFS is supposed to be read-only we just
 172          * lie and say it has no free block at all.
 173          */
 174         if (sbi->s_type == FSTYPE_AFS)
 175                 return 0;
 176 
 177         mutex_lock(&sbi->s_lock);
 178         sb_count = fs32_to_cpu(sbi, *sbi->s_free_blocks);
 179 
 180         if (0)
 181                 goto trust_sb;
 182 
 183         /* this causes a lot of disk traffic ... */
 184         count = 0;
 185         n = fs16_to_cpu(sbi, *sbi->s_bcache_count);
 186         blocks = sbi->s_bcache;
 187         while (1) {
 188                 sysv_zone_t zone;
 189                 if (n > sbi->s_flc_size)
 190                         goto E2big;
 191                 zone = 0;
 192                 while (n && (zone = blocks[--n]) != 0)
 193                         count++;
 194                 if (zone == 0)
 195                         break;
 196 
 197                 block = fs32_to_cpu(sbi, zone);
 198                 if (bh)
 199                         brelse(bh);
 200 
 201                 if (block < sbi->s_firstdatazone || block >= sbi->s_nzones)
 202                         goto Einval;
 203                 block += sbi->s_block_base;
 204                 bh = sb_bread(sb, block);
 205                 if (!bh)
 206                         goto Eio;
 207                 n = fs16_to_cpu(sbi, *(__fs16*)bh->b_data);
 208                 blocks = get_chunk(sb, bh);
 209         }
 210         if (bh)
 211                 brelse(bh);
 212         if (count != sb_count)
 213                 goto Ecount;
 214 done:
 215         mutex_unlock(&sbi->s_lock);
 216         return count;
 217 
 218 Einval:
 219         printk("sysv_count_free_blocks: new block %d is not in data zone\n",
 220                 block);
 221         goto trust_sb;
 222 Eio:
 223         printk("sysv_count_free_blocks: cannot read free-list block\n");
 224         goto trust_sb;
 225 E2big:
 226         printk("sysv_count_free_blocks: >flc_size entries in free-list block\n");
 227         if (bh)
 228                 brelse(bh);
 229 trust_sb:
 230         count = sb_count;
 231         goto done;
 232 Ecount:
 233         printk("sysv_count_free_blocks: free block count was %d, "
 234                 "correcting to %d\n", sb_count, count);
 235         if (!sb_rdonly(sb)) {
 236                 *sbi->s_free_blocks = cpu_to_fs32(sbi, count);
 237                 dirty_sb(sb);
 238         }
 239         goto done;
 240 }