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