modules/ps2fs/super.c

   1 /*
   2 # _____     ___ ____     ___ ____
   3 #  ____|   |    ____|   |        | |____|
   4 # |     ___|   |____ ___|    ____| |    \    PS2DEV Open Source Project.
   5 #-----------------------------------------------------------------------
   6 # Copyright 2001-2004, ps2dev - http://www.ps2dev.org
   7 # Licenced under Academic Free License version 2.0
   8 # Review ps2sdk README & LICENSE files for further details.
   9 #
  10 # $Id: super.c 911 2005-03-14 21:02:17Z oopo $
  11 # PFS superblock manipulation routines
  12 */
  13
  14 #include "pfs.h"
  15
  16 int checkZoneSize(u32 zone_size)
  17 {
  18         if((zone_size & (zone_size - 1)) || (zone_size < (2 * 1024)) || (zone_size > (128 * 1024)))
  19         {
  20                 printf("ps2fs: Error: Invalid zone size\n");
  21                 return 0;
  22         }
  23
  24         return 1;
  25 }
  26
  27 // Returns the number of sectors (512 byte units) which will be used
  28 // for bitmaps, given the zone size and partition size
  29 u32 getBitmapSectors(int zoneScale, u32 partSize)
  30 {
  31         int w, zones = partSize / (1 << zoneScale);
  32
  33         w = (zones & 7);
  34         zones = zones / 8 + w;
  35
  36         w = (zones & 511);
  37         return zones / 512 + w;
  38 }
  39
  40 // Returns the number of blocks/zones which will be used for bitmaps
  41 u32 getBitmapBocks(int scale, u32 mainsize)
  42 {
  43         u32 a=getBitmapSectors(scale, mainsize);
  44         return a / (1<<scale) + ((a % (1<<scale))>0);
  45 }
  46
  47 // Formats a partition (main or sub) by filling with fragment pattern and setting the bitmap accordingly
  48 int formatSub(block_device *blockDev, int fd, u32 sub, u32 reserved, u32 scale, u32 fragment)
  49 {
  50         pfs_cache_t *cache;
  51         int i;
  52         u32 sector, count, size, *b;
  53         int result = 0;
  54
  55         size = blockDev->getSize(fd, sub);
  56         sector = 1 << scale;
  57         count = getBitmapSectors(scale, size);
  58         if (reserved>=2)
  59                 sector+=0x2000;
  60         reserved += getBitmapBocks(scale, size);
  61
  62         if((cache = cacheAllocClean(&result)))
  63         {
  64                 // fill with fragment pattern
  65                 for (i=127; i>=0; i--)
  66                         cache->u.bitmap[i]=fragment;
  67
  68                 // set as allocated the sectors up to reserved, for the first part of the bitmap
  69                 // this will mark the area the bitmaps themselves occupy as used
  70                 for (i=0, b=cache->u.bitmap; i<reserved; i++)
  71                 {
  72                         if (i && ((i & 0x1F)==0))
  73                                 b++;
  74                         *b |= 1 << (i & 0x1F);
  75                 }
  76
  77                 dprintf("ps2fs: Format sub: sub = %ld, sector start = %ld, ", sub, sector);
  78
  79                 // set the rest of the bitmap to the fragment
  80                 while (count-- && ((result=blockDev->transfer(fd, cache->u.bitmap, sub, sector++, 1, 1))>=0))
  81                         for (i=127; i>=0; i--)
  82                                 cache->u.bitmap[i]=fragment;
  83
  84                 dprintf("sector end = %ld\n", sector - 1);
  85
  86                 cacheAdd(cache);
  87         }
  88         return result;
  89 }
  90
  91 // Formats a partition and all sub-partitions with PFS
  92 int _format(block_device *blockDev, int fd, int zonesize, int fragment)
  93 {
  94         int result, result2;
  95         pfs_cache_t *clink, *cache;
  96         pfs_super_block *sb;
  97         int scale;
  98         u32 i, mainsize, subnumber = blockDev->getSubNumber(fd);
  99
 100         mainsize=blockDev->getSize(fd, 0);
 101         if(checkZoneSize(zonesize) == 0)
 102                 return -EINVAL;
 103
 104         scale = getScale(zonesize, 512);
 105
 106         if((clink=cacheAllocClean(&result)))
 107         {
 108                 sb = clink->u.superblock;
 109                 memset(sb, 0, metaSize);
 110                 sb->magic = PFS_SUPER_MAGIC;
 111                 sb->version = 3;
 112                 sb->unknown1 = 0x201;
 113                 sb->zone_size = zonesize;
 114                 sb->num_subs = subnumber;
 115                 sb->log.number = getBitmapBocks(scale, mainsize) + (0x2000 >> scale) + 1;
 116                 sb->log.count = 0x20000 / zonesize ? 0x20000 / zonesize : 1;
 117
 118                 dprintf("ps2fs: Format: log.number = %ld, log.count = %d\n", sb->log.number << scale, sb->log.count);
 119
 120                 sb->root.count = 1;
 121                 sb->root.number = sb->log.number + sb->log.count;
 122                 if((result = journalResetThis(blockDev, fd, sb->log.number<<scale)) >= 0)
 123                 {
 124                         if((cache = cacheAllocClean(&result2)))
 125                         {
 126                                 fillSelfAndParentDentries(cache, &sb->root, &sb->root);
 127                                 result2 = blockDev->transfer(fd, cache->u.dentry, 0, (sb->root.number+1) << scale,
 128                                                                                                 1 << blockSize, 1);
 129                                 if(result2 == 0)
 130                                 {
 131                                         // setup root directory
 132                                         inodeFill(cache, &sb->root, 0x11FF, 0, 0);
 133                                         cache->u.inode->data[1].subpart = 0;
 134                                         cache->u.inode->data[1].number = sb->root.number + 1;
 135                                         cache->u.inode->data[1].count = 1;
 136                                         cache->u.inode->checksum = inodeCheckSum(cache->u.inode);
 137
 138                                         result2=blockDev->transfer(fd, cache->u.inode, 0, sb->root.number << scale,
 139                                                                                                 1 << blockSize, 1);
 140                                 }
 141
 142                                 cacheAdd(cache);
 143                         }
 144
 145                         if((result = result2) >= 0)
 146                         {
 147                                 for (i=0; i < subnumber+1; i++)
 148                                         if((result=formatSub(blockDev, fd, i, i ? 1 : (0x2000 >> scale) +
 149                                                                                         sb->log.count*8, scale, fragment))<0)
 150                                                 break;
 151
 152                                 if((result == 0) && ((result = blockDev->transfer(fd, sb, 0, PFS_SUPER_BACKUP_SECTOR, 1, 1))==0))
 153                                         result = blockDev->transfer(fd, sb, 0, PFS_SUPER_SECTOR, 1, 1);
 154                         }
 155                 }
 156
 157                 cacheAdd(clink);
 158                 blockDev->flushCache(fd);
 159         }
 160         return result;
 161 }
 162
 163 // Formats sub partitions which are added to the main partition after it is initially
 164 // formatted with PFS
 165 int updateSuperBlock(pfs_mount_t *pfsMount, pfs_super_block *superblock, u32 sub)
 166 {
 167         u32 scale;
 168         u32 i;
 169         u32 count;
 170         int rv;
 171
 172         scale = getScale(superblock->zone_size, 512);
 173         count = superblock->num_subs + sub + 1;
 174
 175         for(i = superblock->num_subs + 1; i < count; i++)
 176         {
 177                 rv = formatSub(pfsMount->blockDev, pfsMount->fd, i, 1, scale, 0);
 178                 if(rv < 0)
 179                         return rv;
 180         }
 181
 182         superblock->num_subs = sub;
 183
 184         // Write superblock, then write backup
 185         rv = pfsMount->blockDev->transfer(pfsMount->fd, superblock, 0, PFS_SUPER_SECTOR, 1, IOCTL2_TMODE_WRITE);
 186         if(!rv)
 187                 rv = pfsMount->blockDev->transfer(pfsMount->fd, superblock, 0, PFS_SUPER_BACKUP_SECTOR, 1, IOCTL2_TMODE_WRITE);
 188
 189         pfsMount->blockDev->flushCache(pfsMount->fd);
 190
 191         return rv;
 192 }
 193
 194 int mountSuperBlock(pfs_mount_t *pfsMount)
 195 {
 196         int result;
 197         pfs_cache_t *clink;
 198         pfs_super_block *superblock;
 199         u32 sub;
 200         u32 i;
 201
 202
 203         // Get number of sub partitions attached to the main partition
 204         sub = pfsMount->blockDev->getSubNumber(pfsMount->fd);
 205
 206         // Allocate a cache entry for the superblock
 207         clink = cacheAllocClean(&result);
 208         if(!clink)
 209                 return result;
 210
 211         superblock = clink->u.superblock;
 212
 213         // Read the suprerblock from the main partition
 214         result = pfsMount->blockDev->transfer(pfsMount->fd, superblock, 0, PFS_SUPER_SECTOR, 1, IOCTL2_TMODE_READ);
 215         if(result) goto error;
 216
 217         if((superblock->magic != PFS_SUPER_MAGIC) || (superblock->version >= PFS_VERSION))
 218         {
 219                 printf("ps2fs: Error: Invalid magic/version\n");
 220                 cacheAdd(clink);
 221                 return -EIO;
 222         }
 223
 224         if(!checkZoneSize(superblock->zone_size))
 225                 result = -EIO;
 226
 227         if((superblock->fsckStat & FSCK_STAT_WRITE_ERROR) && (pfsMount->flags & FIO_ATTR_EXECUTABLE))
 228                 result = -EIO;
 229
 230         if(sub < superblock->num_subs)
 231         {
 232                 printf("ps2fs: Error: Filesystem larger than partition\n");
 233                 result = -EIO;
 234         }
 235
 236         if(result) goto error;
 237
 238         // If new subs have been added, update filesystem
 239         if(superblock->num_subs < sub)
 240         {
 241                 dprintf("ps2fs: New subs added, updating filesystem..\n");
 242                 result = updateSuperBlock(pfsMount, superblock, sub);
 243         }
 244
 245         if(result) goto error;
 246
 247         pfsMount->zsize = superblock->zone_size;
 248         pfsMount->sector_scale = getScale(pfsMount->zsize, 512);
 249         pfsMount->inode_scale = getScale(pfsMount->zsize, metaSize);
 250         pfsMount->num_subs = superblock->num_subs;
 251         memcpy(&pfsMount->root_dir, &superblock->root, sizeof(pfs_blockinfo));
 252         memcpy(&pfsMount->log, &superblock->log, sizeof(pfs_blockinfo));
 253         memcpy(&pfsMount->current_dir, &superblock->root, sizeof(pfs_blockinfo));
 254         pfsMount->total_sector = 0;
 255         pfsMount->uid = 0;
 256         pfsMount->gid = 0;
 257
 258         // Do a journal restore (in case of un-clean unmount)
 259         journalResetore(pfsMount);
 260
 261         // Calculate free space and total size
 262         for(i = 0; i < (pfsMount->num_subs + 1); i++)
 263         {
 264                 int free;
 265
 266                 pfsMount->total_sector += pfsMount->blockDev->getSize(pfsMount->fd, i) >> pfsMount->sector_scale;
 267
 268                 free = calcFreeZones(pfsMount, i);
 269                 pfsMount->free_zone[i] = free;
 270                 pfsMount->zfree += free;
 271         }
 272
 273 error:
 274         cacheAdd(clink);
 275         return result;
 276 }
 277