ext2ed/blockbitmap_com.c

   1 /*
   2
   3 /usr/src/ext2ed/blockbitmap_com.c
   4
   5 A part of the extended file system 2 disk editor.
   6
   7 -------------------------
   8 Handles the block bitmap.
   9 -------------------------
  10
  11 This file implements the commands which are specific to the blockbitmap type.
  12
  13 First written on: July 5 1995
  14
  15 Copyright (C) 1995 Gadi Oxman
  16
  17 */
  18
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22
  23 #include "ext2ed.h"
  24
  25 /*
  26
  27 The functions in this file use the flobal structure block_bitmap_info. This structure contains the current
  28 position in the bitmap.
  29
  30 */
  31
  32 void type_ext2_block_bitmap___entry (char *command_line)
  33
  34 /*
  35
  36 This function changes the current entry in the bitmap. It just changes the entry_num variable in block_bitmap_info
  37 and dispatches a show command to show the new entry.
  38
  39 */
  40
  41 {
  42         unsigned long entry_num;
  43         char *ptr,buffer [80];
  44
  45
  46
  47         ptr=parse_word (command_line,buffer);                                   /* Get the requested entry */
  48         if (*ptr==0) {
  49                 wprintw (command_win,"Error - No argument specified\n");
  50                 refresh_command_win (); return;
  51         }
  52         ptr=parse_word (ptr,buffer);
  53
  54         entry_num=atol (buffer);
  55
  56
  57         if (entry_num >= file_system_info.super_block.s_blocks_per_group) {     /* Check if it is a valid entry number */
  58
  59                 wprintw (command_win,"Error - Entry number out of bounds\n");
  60                 refresh_command_win ();return;
  61         }
  62
  63
  64
  65         block_bitmap_info.entry_num=entry_num;                                  /* If it is, just change entry_num and */
  66         strcpy (buffer,"show");dispatch (buffer);                               /* dispatch a show command */
  67 }
  68
  69 void type_ext2_block_bitmap___next (char *command_line)
  70
  71 /*
  72
  73 This function passes to the next entry in the bitmap. We just call the above entry command.
  74
  75 */
  76
  77 {
  78         long entry_offset=1;
  79         char *ptr,buffer [80];
  80
  81         ptr=parse_word (command_line,buffer);
  82         if (*ptr!=0) {
  83                 ptr=parse_word (ptr,buffer);
  84                 entry_offset=atol (buffer);
  85         }
  86
  87         sprintf (buffer,"entry %ld",block_bitmap_info.entry_num+entry_offset);
  88         dispatch (buffer);
  89 }
  90
  91 void type_ext2_block_bitmap___prev (char *command_line)
  92
  93 {
  94         long entry_offset=1;
  95         char *ptr,buffer [80];
  96
  97         ptr=parse_word (command_line,buffer);
  98         if (*ptr!=0) {
  99                 ptr=parse_word (ptr,buffer);
 100                 entry_offset=atol (buffer);
 101         }
 102
 103         sprintf (buffer,"entry %ld",block_bitmap_info.entry_num-entry_offset);
 104         dispatch (buffer);
 105 }
 106
 107 void type_ext2_block_bitmap___allocate (char *command_line)
 108
 109 /*
 110
 111 This function starts allocating block from the current position. Allocating involves setting the correct bits
 112 in the bitmap. This function is a vector version of allocate_block below - We just run on the blocks that
 113 we need to allocate, and call allocate_block for each one.
 114
 115 */
 116
 117 {
 118         long entry_num,num=1;
 119         char *ptr,buffer [80];
 120
 121         ptr=parse_word (command_line,buffer);                                   /* Get the number of blocks to allocate */
 122         if (*ptr!=0) {
 123                 ptr=parse_word (ptr,buffer);
 124                 num=atol (buffer);
 125         }
 126
 127         entry_num=block_bitmap_info.entry_num;
 128                                                                                 /* Check for limits */
 129         if (num > file_system_info.super_block.s_blocks_per_group-entry_num) {
 130                 wprintw (command_win,"Error - There aren't that much blocks in the group\n");
 131                 refresh_command_win ();return;
 132         }
 133
 134         while (num) {                                                           /* And call allocate_block */
 135                 allocate_block (entry_num);                                     /* for each block */
 136                 num--;entry_num++;
 137         }
 138
 139         dispatch ("show");                                                      /* Show the result */
 140 }
 141
 142 void type_ext2_block_bitmap___deallocate (char *command_line)
 143
 144 /* This is the opposite of the above function - We call deallocate_block instead of allocate_block */
 145
 146 {
 147         long entry_num,num=1;
 148         char *ptr,buffer [80];
 149
 150         ptr=parse_word (command_line,buffer);
 151         if (*ptr!=0) {
 152                 ptr=parse_word (ptr,buffer);
 153                 num=atol (buffer);
 154         }
 155
 156         entry_num=block_bitmap_info.entry_num;
 157         if (num > file_system_info.super_block.s_blocks_per_group-entry_num) {
 158                 wprintw (command_win,"Error - There aren't that much blocks in the group\n");
 159                 refresh_command_win ();return;
 160         }
 161
 162         while (num) {
 163                 deallocate_block (entry_num);
 164                 num--;entry_num++;
 165         }
 166
 167         dispatch ("show");
 168 }
 169
 170
 171 void allocate_block (long entry_num)
 172
 173 /* In this function we convert the bit number into the right byte and inner bit positions. */
 174
 175 {
 176         unsigned char bit_mask=1;
 177         int byte_offset,j;
 178
 179         byte_offset=entry_num/8;                                        /* Find the correct byte - entry_num/8 */
 180                                                                         /* The position inside the byte is entry_num %8 */
 181         for (j=0;j<entry_num%8;j++)
 182                 bit_mask*=2;                                            /* Generate the or mask - 1 at the right place */
 183         type_data.u.buffer [byte_offset] |= bit_mask;                   /* And apply it */
 184 }
 185
 186 void deallocate_block (long entry_num)
 187
 188 /* This is the opposite of allocate_block above. We use an and mask instead of an or mask. */
 189
 190 {
 191         unsigned char bit_mask=1;
 192         int byte_offset,j;
 193
 194         byte_offset=entry_num/8;
 195         for (j=0;j<entry_num%8;j++)
 196                 bit_mask*=2;
 197         bit_mask^=0xff;
 198
 199         type_data.u.buffer [byte_offset] &= bit_mask;
 200 }
 201
 202 void type_ext2_block_bitmap___show (char *command_line)
 203
 204 /*
 205
 206 We show the bitmap as a series of bits, grouped at 8-bit intervals. We display 8 such groups on each line.
 207 The current position (as known from block_bitmap_info.entry_num) is highlighted.
 208
 209 */
 210
 211 {
 212         int i,j;
 213         unsigned char *ptr;
 214         unsigned long block_num,entry_num;
 215
 216         ptr=type_data.u.buffer;
 217         show_pad_info.line=0;show_pad_info.max_line=-1;
 218
 219         wmove (show_pad,0,0);
 220         for (i=0,entry_num=0;i<file_system_info.super_block.s_blocks_per_group/8;i++,ptr++) {
 221                 for (j=1;j<=128;j*=2) {                                         /* j contains the and bit mask */
 222                         if (entry_num==block_bitmap_info.entry_num) {           /* Highlight the current entry */
 223                                 wattrset (show_pad,A_REVERSE);
 224                                 show_pad_info.line=show_pad_info.max_line-show_pad_info.display_lines/2;
 225                         }
 226
 227                         if ((*ptr) & j)                                         /* Apply the mask */
 228                                 wprintw (show_pad,"1");
 229                         else
 230                                 wprintw (show_pad,"0");
 231
 232                         if (entry_num==block_bitmap_info.entry_num)
 233                                 wattrset (show_pad,A_NORMAL);
 234
 235                         entry_num++;                                            /* Pass to the next entry */
 236                 }
 237                 wprintw (show_pad," ");
 238                 if (i%8==7) {                                                   /* Display 8 groups in a row */
 239                         wprintw (show_pad,"\n");
 240                         show_pad_info.max_line++;
 241                 }
 242         }
 243
 244         refresh_show_pad ();
 245         show_info ();                                                           /* Show the usual information */
 246
 247                                                                                 /* Show the group number */
 248         wmove (show_win,1,0);
 249         wprintw (show_win,"Block bitmap of block group %ld\n",block_bitmap_info.group_num);
 250                                                                                 /* Show the block number */
 251
 252         block_num=block_bitmap_info.entry_num+block_bitmap_info.group_num*file_system_info.super_block.s_blocks_per_group;
 253         block_num+=file_system_info.super_block.s_first_data_block;
 254
 255         wprintw (show_win,"Status of block %ld - ",block_num);                  /* and the allocation status */
 256         ptr=type_data.u.buffer+block_bitmap_info.entry_num/8;
 257         j=1;
 258         for (i=block_bitmap_info.entry_num % 8;i>0;i--)
 259                 j*=2;
 260         if ((*ptr) & j)
 261                 wprintw (show_win,"Allocated\n");
 262         else
 263                 wprintw (show_win,"Free\n");
 264         refresh_show_win ();
 265 }