~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/sysv/balloc.c

Version: ~ [ linux-5.2-rc4 ] ~ [ linux-5.1.9 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.50 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.125 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.181 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.181 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.68 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp