[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
ReiserFS support patch
|
From: |
Yura Umanets |
|
Subject: |
ReiserFS support patch |
|
Date: |
Sat, 12 Jan 2002 22:26:29 +0200 |
|
User-agent: |
Mozilla/5.0 (X11; U; Linux i686; en-US; rv:0.9.7) Gecko/20011221 |
Hi Andrew!
This is a ReiserFS support patch for parted-1.4.22
It implements: reiserfs_open, reiserfs_create, reiserfs_close,
reiserfs_resize, reiserfs_get_resize_constraint, reiserfs_check.
--
Yury Umanets
IT Engineer of Priocom Corp.
Phone: +380 44 2011959, ICQ: 55494590
diff -rupN ./parted-1.4.22/libparted/fs_reiserfs/Makefile.am
./parted-reiserfs-1.4.22/libparted/fs_reiserfs/Makefile.am
--- ./parted-1.4.22/libparted/fs_reiserfs/Makefile.am Sun Apr 8 01:04:38 2001
+++ ./parted-reiserfs-1.4.22/libparted/fs_reiserfs/Makefile.am Sat Jan 12
21:40:10 2002
@@ -1,6 +1,11 @@
partedincludedir = -I$(top_srcdir)/include
noinst_LTLIBRARIES = libreiserfs.la
-libreiserfs_la_SOURCES = reiserfs.c
+libreiserfs_la_SOURCES = reiserfs.c \
+ reiserfs_fs.c reiserfs_fs.h \
+ reiserfs_bm.c reiserfs_bm.h \
+ reiserfs_io.c reiserfs_io.h \
+ reiserfs_blk.c reiserfs_blk.h \
+ reiserfs_tools.c reiserfs_tools.h
INCLUDES = $(partedincludedir) @INTLINCS@
diff -rupN ./parted-1.4.22/libparted/fs_reiserfs/reiserfs.c
./parted-reiserfs-1.4.22/libparted/fs_reiserfs/reiserfs.c
--- ./parted-1.4.22/libparted/fs_reiserfs/reiserfs.c Wed Sep 19 00:02:40 2001
+++ ./parted-reiserfs-1.4.22/libparted/fs_reiserfs/reiserfs.c Sat Jan 12
22:19:18 2002
@@ -17,6 +17,13 @@
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
+/*
+ Added reiserfs_open, reiserfs_create, reiserfs_close, reiserfs_resize,
+ reiserfs_get_resize_constraint, reiserfs_check by Yury Umanets
(address@hidden)
+*/
+
+static const char _reiserfs_c[] = "$Id: reiserfs.c,v 1.55 2002/01/04 19:57:11
yumanets Exp $";
+
#include "config.h"
#include <parted/parted.h>
@@ -27,39 +34,46 @@
#include <parted/disk_mac.h>
#include <parted/disk_gpt.h>
-#include <libintl.h>
#if ENABLE_NLS
+# include <libintl.h>
# define _(String) dgettext (PACKAGE, String)
#else
# define _(String) (String)
-#endif /* ENABLE_NLS */
+#endif
#include <string.h>
-#define REISERFS_SIGNATURE "ReIsErFs"
-#define REISER2FS_SIGNATURE "ReIsEr2Fs"
+#include "reiserfs_fs.h"
+#include "reiserfs_io.h"
+#include "reiserfs_tools.h"
-static PedSector reiser_super_offset[] = {
- 128,
- 16, /* versions 3.5 - 3.5.11 */
- -1
-};
+static int reiser_super_offset[] = {128, 16, -1};
static int reiserfs_probe (const PedGeometry* geom);
static int reiserfs_clobber (PedGeometry* geom);
+
+static PedFileSystem* reiserfs_open (const PedGeometry *geom);
+static PedFileSystem* reiserfs_create (PedGeometry *geom);
+
+static int reiserfs_close (PedFileSystem* fs);
+static int reiserfs_check (PedFileSystem *fs);
+
+static int reiserfs_resize (PedFileSystem* fs, const PedGeometry* geom);
+static PedConstraint* reiserfs_get_resize_constraint (const PedFileSystem* fs);
+
static int reiserfs_set_system (const PedFileSystem* fs, PedPartition* part,
const PedDiskType* disk_type);
static PedFileSystemOps reiserfs_ops = {
probe: reiserfs_probe,
clobber: reiserfs_clobber,
- open: NULL,
- create: NULL,
- close: NULL,
- check: NULL,
+ open: reiserfs_open,
+ create: reiserfs_create,
+ close: reiserfs_close,
+ check: reiserfs_check,
copy: NULL,
- resize: NULL,
- get_resize_constraint: NULL,
+ resize: reiserfs_resize,
+ get_resize_constraint: reiserfs_get_resize_constraint,
set_system: reiserfs_set_system
};
@@ -84,38 +98,36 @@ ped_file_system_reiserfs_done ()
static int
reiserfs_probe (const PedGeometry* geom)
{
- char buf[512];
- int i;
-
- for (i=0; reiser_super_offset[i] != -1; i++) {
- if (reiser_super_offset[i] >= geom->length)
- continue;
- if (!ped_geometry_read (geom, buf, reiser_super_offset[i], 1))
- continue;
- if (strncmp (REISERFS_SIGNATURE, buf + 52,
- strlen (REISERFS_SIGNATURE)) == 0)
- return 1;
- if (strncmp (REISER2FS_SIGNATURE, buf + 52,
- strlen (REISER2FS_SIGNATURE)) == 0)
- return 1;
- }
- return 0;
+ struct reiserfs_super_block *sb;
+ char buff[512];
+ int i;
+
+ for (i = 0; reiser_super_offset[i] != -1; i++) {
+ if (reiser_super_offset[i] >= geom->length)
+ continue;
+ if (!ped_geometry_read (geom, buff, reiser_super_offset[i], 1))
+ continue;
+ sb = (struct reiserfs_super_block *)buff;
+ if (is_any_reiserfs_magic_string (sb->s_v1.s_magic))
+ return 1;
+ }
+ return 0;
}
static int
reiserfs_clobber (PedGeometry* geom)
{
- char buf[512];
- int i;
+ int i;
+ char buf[512];
- memset (buf, 0, 512);
- for (i=0; reiser_super_offset[i] != -1; i++) {
- if (reiser_super_offset[i] >= geom->length)
- continue;
- if (!ped_geometry_write (geom, buf, reiser_super_offset[i], 1))
- return 0;
- }
- return 1;
+ memset (buf, 0, 512);
+ for (i=0; reiser_super_offset[i] != -1; i++) {
+ if (reiser_super_offset[i] >= geom->length)
+ continue;
+ if (!ped_geometry_write (geom, buf, reiser_super_offset[i], 1))
+ return 0;
+ }
+ return 1;
}
static int
@@ -193,4 +205,183 @@ reiserfs_set_system (const PedFileSystem
}
return 0;
+}
+
+static PedFileSystem *reiserfs_open (const PedGeometry *geom) {
+ PedFileSystem *fs;
+ reiserfs_fs_t *fs_info;
+ struct reiserfs_io_handler *io_handler;
+ PedGeometry *fs_geom = ped_geometry_duplicate(geom);
+
+ io_handler = reiserfs_io_handler_create(fs_geom);
+ if (!io_handler) goto error;
+
+ fs_info = _reiserfs_fs_open(io_handler);
+ if (!fs_info) goto error_free_io_handler;
+
+ fs = (PedFileSystem*) ped_malloc (sizeof(PedFileSystem));
+ if (!fs) goto error_free_fs_info;
+
+ fs->type = &reiserfs_type;
+ fs->geom = fs_geom;
+ fs->type_specific = (void*) fs_info;
+
+ return fs;
+
+error_free_fs:
+ ped_free(fs);
+error_free_fs_info:
+ _reiserfs_fs_close(fs_info);
+error_free_io_handler:
+ reiserfs_io_handler_destroy(io_handler);
+error:
+ return NULL;
+}
+
+#define REISERFS_DEFAULT_JOURNAL_BLOCKS 8192
+
+static PedFileSystem* reiserfs_create(PedGeometry *geom) {
+ PedFileSystem *fs;
+ PedGeometry *fs_geom;
+ reiserfs_fs_t *fs_info;
+ struct reiserfs_io_handler *io_handler;
+
+ fs_geom = ped_geometry_duplicate(geom);
+
+ if (!(io_handler = reiserfs_io_handler_create(fs_geom)))
+ goto error;
+
+ if (!(fs_info = _reiserfs_fs_create(io_handler,
REISERFS_DEFAULT_BLOCK_SIZE, REISERFS_DEFAULT_JOURNAL_BLOCKS,
+ io_handler->ops->blocks(io_handler, REISERFS_DEFAULT_BLOCK_SIZE))))
+ goto error_free_fs;
+
+ if (!(fs = (PedFileSystem *)ped_malloc(sizeof(PedFileSystem))))
+ goto error_free_io_handler;
+
+ fs->type = &reiserfs_type;
+ fs->geom = fs_geom;
+
+ fs->type_specific = (void *)fs_info;
+
+ return fs;
+
+error_free_io_handler:
+ reiserfs_io_handler_destroy(io_handler);
+error_free_fs:
+ ped_free(fs);
+error:
+ return NULL;
+}
+
+static int reiserfs_close (PedFileSystem* fs) {
+ struct reiserfs_io_handler *io_handler = ((reiserfs_fs_t
*)fs->type_specific)->io_handler;
+
+ if (io_handler) reiserfs_io_handler_destroy(io_handler);
+ _reiserfs_fs_close(fs->type_specific);
+ ped_free(fs);
+ return 1;
+}
+
+static PedConstraint* reiserfs_get_resize_constraint (const PedFileSystem* fs)
{
+ reiserfs_fs_t *fs_info = (reiserfs_fs_t *)fs->type_specific;
+ PedDisk *disk = fs->geom->disk;
+ PedAlignment start_align;
+ PedGeometry start_sector;
+ PedGeometry full_disk;
+ PedSector min_size;
+
+ if (!ped_alignment_init (&start_align, fs->geom->start, 0))
+ return NULL;
+ if (!ped_geometry_init (&full_disk, disk, 0, disk->dev->length - 1))
+ return NULL;
+ if (!ped_geometry_init (&start_sector, disk, fs->geom->start, 1))
+ return NULL;
+
+ min_size = (fs_info->fs_super_bh->b_blocknr +
fs_info->fs_ondisk_sb->s_v1.sb_block_count -
+ fs_info->fs_ondisk_sb->s_v1.sb_free_blocks) * (fs_info->fs_blocksize /
PED_SECTOR_SIZE);
+
+ return ped_constraint_new (&start_align, ped_alignment_any,
+ &start_sector, &full_disk, min_size);
+}
+
+static int reiserfs_resize (PedFileSystem* fs, const PedGeometry *geom) {
+ reiserfs_fs_t *fs_info;
+ PedSector old_length = fs->geom->length;
+ unsigned long blocks;
+
+ if (fs->geom->disk->dev != geom->disk->dev) {
+ ped_exception_throw (PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+ _("Filesystem device isn't equals geometry device"));
+ return 0;
+ }
+
+ if (fs->geom->start != geom->start) {
+ ped_exception_throw (PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+ _("Sorry, can't move the start of reiserfs partitions yet"));
+ return 0;
+ }
+
+ fs_info = (reiserfs_fs_t *)fs->type_specific;
+
+ blocks = (unsigned long)(geom->length /
+ (fs_info->fs_blocksize / PED_SECTOR_SIZE)) -
+ fs_info->fs_super_bh->b_blocknr;
+
+ if (old_length > geom->length) {
+ if (!_reiserfs_fs_resize(fs_info, blocks))
+ goto error;
+
+ fs->geom->length = geom->length;
+ fs->geom->end = fs->geom->start + geom->length - 1;
+ } else {
+ fs->geom->length = geom->length;
+ fs->geom->end = fs->geom->start + geom->length - 1;
+
+ if (!_reiserfs_fs_resize(fs_info, blocks))
+ goto error;
+ }
+
+ return 1;
+
+error:
+ fs->geom->length = old_length;
+ fs->geom->end = fs->geom->start + old_length - 1;
+
+ return 0;
+}
+
+static int
+reiserfs_check (PedFileSystem *fs)
+{
+ reiserfs_fs_t *fs_info = (reiserfs_fs_t *)fs->type_specific;
+
+ if (!_reiserfs_fs_is_found(fs_info)) {
+ ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+ _("No reiserfs found"));
+ return 0;
+ }
+
+ if (!_reiserfs_bm_is_spread(fs_info)) {
+ ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+ _("Can't resize reiserfs in old format"));
+ return 0;
+ }
+
+ if (!_reiserfs_fs_is_consistent(fs_info)) {
+ ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+ _("Filesystem isn't consistent. Run reiserfsck --check first"));
+ return 0;
+ }
+
+ if (get_sb_state(fs_info->fs_ondisk_sb) != REISERFS_FS_VALID) {
+ ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+ _("Filesystem isn't in valid state"));
+ return 0;
+ }
+
+ ped_exception_throw (PED_EXCEPTION_INFORMATION, PED_EXCEPTION_OK,
+ _("The reiserfs filesystem passed a basic check. For a more "
+ "comprehensive check, use the reiserfsck --check"));
+
+ return 1;
}
diff -rupN ./parted-1.4.22/libparted/fs_reiserfs/reiserfs_blk.c
./parted-reiserfs-1.4.22/libparted/fs_reiserfs/reiserfs_blk.c
--- ./parted-1.4.22/libparted/fs_reiserfs/reiserfs_blk.c Thu Jan 1
03:00:00 1970
+++ ./parted-reiserfs-1.4.22/libparted/fs_reiserfs/reiserfs_blk.c Sat Jan
12 22:07:57 2002
@@ -0,0 +1,72 @@
+/*
+ reiserfs_blk.h -- buffer_head functions
+ Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/*
+ Writen by Yury Umanets (address@hidden)
+*/
+
+static const char _reiserfs_blk_c[] = "$Id: reiserfs_blk.h,v 1.55 2002/01/12
20:16:19 yumanets Exp $";
+
+#include <sys/types.h>
+
+#include <parted/parted.h>
+
+#include "reiserfs_blk.h"
+#include "reiserfs_io.h"
+
+struct buffer_head *_reiserfs_block_alloc(reiserfs_blk_t block, size_t size) {
+ struct buffer_head *bh_blk;
+
+ bh_blk = (struct buffer_head *)ped_malloc(sizeof(*bh_blk));
+ memset(bh_blk, 0, sizeof(*bh_blk));
+ bh_blk->b_data = ped_malloc(size);
+ memset(bh_blk->b_data, 0, size);
+
+ bh_blk->b_size = size;
+ bh_blk->b_blocknr = block;
+
+ return bh_blk;
+}
+
+void _reiserfs_block_free(struct buffer_head *bh_blk) {
+ if (bh_blk == 0)
+ return;
+ ped_free(bh_blk->b_data);
+ ped_free(bh_blk);
+}
+
+struct buffer_head *_reiserfs_block_read(void *io_handler, reiserfs_blk_t
block, size_t size) {
+ struct buffer_head *bh_blk;
+
+ bh_blk = _reiserfs_block_alloc(block, size);
+ if (!((struct reiserfs_io_handler *)io_handler)->ops->read(io_handler,
bh_blk->b_data, block, 1, size)) {
+ _reiserfs_block_free(bh_blk);
+ return 0;
+ }
+ return bh_blk;
+}
+
+int _reiserfs_block_write(void *io_handler, struct buffer_head *bh_blk) {
+
+ if (!((struct reiserfs_io_handler *)io_handler)->ops->write(io_handler,
bh_blk->b_data,
+ bh_blk->b_blocknr, 1, bh_blk->b_size))
+ return 0;
+
+ return 1;
+}
diff -rupN ./parted-1.4.22/libparted/fs_reiserfs/reiserfs_blk.h
./parted-reiserfs-1.4.22/libparted/fs_reiserfs/reiserfs_blk.h
--- ./parted-1.4.22/libparted/fs_reiserfs/reiserfs_blk.h Thu Jan 1
03:00:00 1970
+++ ./parted-reiserfs-1.4.22/libparted/fs_reiserfs/reiserfs_blk.h Sat Jan
12 22:03:35 2002
@@ -0,0 +1,43 @@
+/*
+ reiserfs_blk.h -- buffer_head functions
+ Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/*
+ Writen by Yury Umanets (address@hidden)
+*/
+
+
+#ifndef REISERFS_BLK_H
+#define REISERFS_BLK_H
+
+static const char _reiserfs_blk_h[] = "$Id: reiserfs_blk.h,v 1.55 2002/01/12
20:16:19 yumanets Exp $";
+
+typedef unsigned long reiserfs_blk_t;
+
+struct buffer_head {
+ reiserfs_blk_t b_blocknr;
+ size_t b_size;
+ char *b_data;
+};
+
+extern struct buffer_head *_reiserfs_block_alloc(reiserfs_blk_t block, size_t
size);
+extern void _reiserfs_block_free(struct buffer_head *bh_blk);
+extern struct buffer_head *_reiserfs_block_read(void *io_handler,
reiserfs_blk_t block, size_t size);
+extern int _reiserfs_block_write(void *io_handler, struct buffer_head *bh_blk);
+
+#endif
diff -rupN ./parted-1.4.22/libparted/fs_reiserfs/reiserfs_bm.c
./parted-reiserfs-1.4.22/libparted/fs_reiserfs/reiserfs_bm.c
--- ./parted-1.4.22/libparted/fs_reiserfs/reiserfs_bm.c Thu Jan 1 03:00:00 1970
+++ ./parted-reiserfs-1.4.22/libparted/fs_reiserfs/reiserfs_bm.c Sat Jan
12 21:25:53 2002
@@ -0,0 +1,422 @@
+/*
+ reiserfs_bm.c -- reiserfs bitmap stuff
+ Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/*
+ Some parts of this code are from original reiserfs code,
+ as found in the linux kernel. Writen by Yury Umanets (address@hidden)
+*/
+
+static const char _reiserfs_fs_c[] = "$Id: reiserfs_bm.c,v 1.55 2002/01/11
19:55:11 yumanets Exp $";
+
+#include <parted/parted.h>
+
+#include "reiserfs_fs.h"
+#include "reiserfs_tools.h"
+
+#if ENABLE_NLS
+# include <libintl.h>
+# define _(String) dgettext (PACKAGE, String)
+#else
+# define _(String) (String)
+#endif
+
+/*
+ Bitmap utils.
+ Mark given block as used.
+*/
+void _reiserfs_bm_set_bit(reiserfs_bm_t *bm, reiserfs_blk_t bit) {
+ if (test_bit (bit, bm->bm_map))
+ return;
+ set_bit(bit, bm->bm_map);
+ bm->bm_set_bits++;
+}
+
+/*
+ Mark given block as free
+*/
+void _reiserfs_bm_clear_bit(reiserfs_bm_t *bm, reiserfs_blk_t bit) {
+ if (!test_bit (bit, bm->bm_map))
+ return;
+ clear_bit (bit, bm->bm_map);
+ bm->bm_set_bits--;
+}
+
+/*
+ Check for block status
+*/
+int _reiserfs_bm_test_bit(reiserfs_bm_t *bm, reiserfs_blk_t bit) {
+ return test_bit(bit, bm->bm_map);
+}
+
+/*
+ Find free block
+*/
+int _reiserfs_bm_find_zero_bit(reiserfs_bm_t *bm, reiserfs_blk_t *start) {
+ reiserfs_blk_t bit = *start;
+
+ bit = find_next_zero_bit(bm->bm_map, bm->bm_bit_size, *start);
+
+ if (bit >= bm->bm_bit_size)
+ return 1;
+
+ *start = bit;
+ return 0;
+}
+
+/*
+ Generic bitmap functions.
+ Allocating and setting up reiserfs bitmap.
+*/
+void _reiserfs_bm_free(reiserfs_bm_t *bm);
+
+reiserfs_bm_t *_reiserfs_bm_alloc(reiserfs_blk_t blocks) {
+ reiserfs_bm_t *bm;
+
+ PED_ASSERT((blocks > 0), goto error);
+
+ if (!(bm = (reiserfs_bm_t *)ped_malloc(sizeof(*bm))))
+ goto error;
+
+ memset(bm, 0, sizeof(*bm));
+
+ bm->bm_bit_size = blocks;
+ bm->bm_byte_size = (blocks + 7) / 8;
+ bm->bm_set_bits = 0;
+
+ if (!(bm->bm_map = (char *)ped_malloc(bm->bm_byte_size)))
+ goto error_free_bm;
+
+ memset(bm->bm_map, 0, bm->bm_byte_size);
+ return bm;
+
+error_free_bm:
+ _reiserfs_bm_free(bm);
+error:
+ return NULL;
+}
+
+/*
+ Free given bitmap
+*/
+void _reiserfs_bm_free(reiserfs_bm_t *bm) {
+
+ PED_ASSERT(bm != NULL, return);
+
+ if (bm->bm_map) {
+ ped_free(bm->bm_map);
+ bm->bm_map = 0;
+ }
+ bm->bm_bit_size = 0;
+ bm->bm_byte_size = 0;
+ ped_free(bm);
+}
+
+/*
+ Fetching bitmap. File system must be
+ allocated and super block must be initialazed
+*/
+int _reiserfs_bm_fetch(reiserfs_fs_t *fs, reiserfs_bm_t *bm) {
+ char *p;
+ size_t left;
+ reiserfs_blk_t block;
+ struct buffer_head *bh_blk;
+ int i, last_byte_unused_bits;
+
+ PED_ASSERT(fs != NULL && bm != NULL && fs->fs_ondisk_sb != NULL, return 0);
+
+ p = bm->bm_map;
+ for (left = (get_sb_block_count (fs->fs_ondisk_sb) + 7) / 8,
+ block = fs->fs_super_bh->b_blocknr + 1; left > 0;
+ left -= (left < fs->fs_blocksize ? left : fs->fs_blocksize))
+ {
+ if (!(bh_blk = _reiserfs_block_read (fs->io_handler, block,
fs->fs_blocksize))) {
+ ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+ _("Reading block (%lu) failed"), block);
+ return 0;
+ }
+
+ memcpy (p, bh_blk->b_data,
+ (left < fs->fs_blocksize ? left : fs->fs_blocksize));
+ _reiserfs_block_free(bh_blk);
+ p += (left < fs->fs_blocksize ? left : fs->fs_blocksize);
+
+ /* Next bitmap block */
+ if (_reiserfs_bm_is_spread (fs))
+ block = (block / (fs->fs_blocksize * 8) + 1) * (fs->fs_blocksize *
8);
+ else
+ block++;
+ }
+
+ /*
+ On disk bitmap has bits out of SB_BLOCK_COUNT set to 1, where as
+ reiserfs_bm_t has those bits set to 0
+ */
+ last_byte_unused_bits = bm->bm_byte_size * 8 - bm->bm_bit_size;
+ for (i = 0; i < last_byte_unused_bits; i++)
+ clear_bit(bm->bm_bit_size + i, bm->bm_map);
+
+ bm->bm_set_bits = 0;
+
+ /*
+ Needed optimization
+ */
+ for (i = 0; i < (int)bm->bm_bit_size; i++) {
+ if (_reiserfs_bm_test_bit (bm, i))
+ bm->bm_set_bits++;
+ }
+
+ return 1;
+}
+
+/*
+ Flushing bitmap. File system must be initialized
+*/
+int _reiserfs_bm_flush(reiserfs_fs_t *fs, reiserfs_bm_t *bm) {
+ char *p;
+ size_t left;
+ reiserfs_blk_t block;
+ struct buffer_head *bh_blk;
+ int i, last_byte_unused_bits;
+
+ PED_ASSERT(fs && bm, return 0);
+
+ /*
+ Make sure that the device is big enough
+ */
+ if (!(bh_blk = _reiserfs_block_read (fs->io_handler, bm->bm_bit_size - 1,
fs->fs_blocksize))) {
+ ped_exception_throw(PED_EXCEPTION_WARNING, PED_EXCEPTION_IGNORE,
+ _("Reading block (%lu) failed"), bm->bm_bit_size - 1);
+ }
+ _reiserfs_block_free(bh_blk);
+
+ p = bm->bm_map;
+ for (left = bm->bm_byte_size, block = fs->fs_super_bh->b_blocknr + 1;
+ left > 0; left -= (left < fs->fs_blocksize ? left : fs->fs_blocksize))
+ {
+ /*
+ We read to make sure that filesystem
+ contains enough blocks
+ */
+ if (!(bh_blk = _reiserfs_block_alloc(block, fs->fs_blocksize))) {
+ ped_exception_throw(PED_EXCEPTION_WARNING, PED_EXCEPTION_IGNORE,
+ _("Allocating block (%lu) failed"), block);
+ return 0;
+ }
+ memset (bh_blk->b_data, 0xff, bh_blk->b_size);
+ memcpy (bh_blk->b_data, p, (left < fs->fs_blocksize ? left :
fs->fs_blocksize));
+ if (left == fs->fs_blocksize) {
+ /*
+ Set unused bits of last byte of the bitmap to 1
+ */
+ last_byte_unused_bits = bm->bm_byte_size * 8 - bm->bm_bit_size;
+ for (i = 0; i < last_byte_unused_bits; i ++)
+ set_bit ((bm->bm_bit_size % (fs->fs_blocksize * 8)) + i,
+ bh_blk->b_data);
+ }
+ if (!_reiserfs_block_write(fs->io_handler, bh_blk)) {
+ ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+ _("Writing block (%lu) failed"), bh_blk->b_blocknr);
+ _reiserfs_block_free(bh_blk);
+ return 0;
+ }
+ _reiserfs_block_free(bh_blk);
+ p += (left < fs->fs_blocksize ? left : fs->fs_blocksize);
+
+ /*
+ Next bitmap block
+ */
+ if (_reiserfs_bm_is_spread(fs))
+ block = (block / (fs->fs_blocksize * 8) + 1) * (fs->fs_blocksize *
8);
+ else
+ block++;
+
+ }
+
+ return 1;
+}
+
+/*
+ Open bitmap. Allocating and fetching it.
+ File system super block must be initalized
+*/
+reiserfs_bm_t *_reiserfs_bm_open (reiserfs_fs_t *fs) {
+ reiserfs_bm_t *bm;
+
+ PED_ASSERT(fs != NULL, return NULL);
+
+ if (fs->fs_bitmap2) {
+ ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+ _("Bitmap is initiaized already"));
+ goto error;
+ }
+
+ if(!(bm = _reiserfs_bm_alloc(get_sb_block_count(fs->fs_ondisk_sb)))) {
+ ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+ _("Couldn't allocate bitmap"));
+ goto error;
+ }
+
+ if (!_reiserfs_bm_fetch(fs, bm)) {
+ ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+ _("Couldn't fetch bitmap"));
+ goto error_free_bm;
+ }
+
+ fs->fs_bitmap2 = bm;
+ return bm;
+
+error_free_bm:
+ _reiserfs_bm_free(bm);
+error:
+ return NULL;
+}
+
+/*
+ Creating bitmap. File system must be initialized
+*/
+reiserfs_bm_t *_reiserfs_bm_create(reiserfs_fs_t *fs, reiserfs_blk_t blocks,
size_t block_size,
+ reiserfs_blk_t journal_blocks)
+{
+ reiserfs_bm_t *bm;
+ reiserfs_blk_t i, bmnr;
+ reiserfs_blk_t blk = REISERFS_DISK_OFFSET_IN_BYTES / block_size;
+
+ PED_ASSERT(fs != NULL, goto error);
+
+ if(!(bm = _reiserfs_bm_alloc(blocks))) {
+ ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+ _("Couldn't allocate bitmap"));
+ goto error;
+ }
+
+ /*
+ Marking skiped blocks used
+ */
+ for (i = 0; i < blk; i++)
+ _reiserfs_bm_set_bit(bm, i);
+
+ /*
+ Marking super block
+ */
+ _reiserfs_bm_set_bit(bm, i++);
+
+ /*
+ Marking first bitmap block
+ */
+ _reiserfs_bm_set_bit(bm, i++);
+
+ /*
+ Marking journal blocks
+ */
+ for (; i <= blk + 2 + journal_blocks; i++)
+ _reiserfs_bm_set_bit(bm, i);
+
+ /*
+ Make sure, that all journal blocks pointed by first bitmap
+ */
+ if (i >= block_size * 8)
+ goto error_free_bm;
+
+ /*
+ Make sure, that we still have some amount
+ (100 blocks) of free space
+ */
+ if (i + 100 > blocks) {
+ ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+ _("Size of file system is too small. It must be at least %lu
blocks"), i + 100 + 1);
+ goto error_free_bm;
+ }
+
+ /*
+ Marking root block as used
+ */
+ _reiserfs_bm_set_bit(bm, i);
+
+ /* Setting up other bitmap blocks */
+ bmnr = (blocks + (block_size * 8 - 1)) / (block_size * 8);
+
+ for (i = 1; i < PED_LE16_TO_CPU(fs->fs_ondisk_sb->s_v1.sb_bmap_nr); i++)
+ _reiserfs_bm_set_bit(bm, i * block_size * 8);
+
+ /*
+ Unused space of last bitmap is filled by 1
+ */
+ for (i = bmnr * fs->fs_ondisk_sb->s_v1.sb_blocksize * 8;
+ --i >= fs->fs_ondisk_sb->s_v1.sb_block_count; )
+ _reiserfs_bm_set_bit(bm, i);
+
+ fs->fs_bitmap2 = bm;
+ return bm;
+
+error_free_bm:
+ _reiserfs_bm_free(bm);
+error:
+ return NULL;
+}
+
+/*
+ Realloc bitmap corresponding to given blocks value
+*/
+int _reiserfs_bm_realloc(reiserfs_bm_t *bm, reiserfs_blk_t blocks) {
+ size_t bytes = ((blocks + 7) / 8), chunk;
+
+ PED_ASSERT(bm != NULL && blocks > 0, return 0);
+
+ if (bytes - bm->bm_byte_size == 0)
+ return 0;
+
+ if (bytes - bm->bm_byte_size > 0)
+ chunk = bytes - bm->bm_byte_size;
+ else
+ chunk = bm->bm_byte_size - bytes;
+
+ if (!(bm->bm_map = realloc(bm->bm_map, chunk)))
+ return 0;
+
+ bm->bm_byte_size = bytes;
+ bm->bm_bit_size = blocks;
+
+ return 1;
+}
+
+/*
+ Synchronizing bitmap
+*/
+int _reiserfs_bm_sync(reiserfs_fs_t *fs, reiserfs_bm_t *bm) {
+
+ PED_ASSERT(fs != NULL && bm != NULL, return 0);
+
+ if (!_reiserfs_bm_flush(fs, bm)) {
+ ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+ _("Couldn't synchronize bitmap"));
+ return 0;
+ }
+ return 1;
+}
+
+/*
+ Closing bitmap. Free all allocated memory
+*/
+void _reiserfs_bm_close(reiserfs_fs_t *fs, reiserfs_bm_t *bm) {
+
+ PED_ASSERT(fs != NULL, return);
+
+ _reiserfs_bm_free(bm);
+ fs->fs_bitmap2 = NULL;
+}
diff -rupN ./parted-1.4.22/libparted/fs_reiserfs/reiserfs_bm.h
./parted-reiserfs-1.4.22/libparted/fs_reiserfs/reiserfs_bm.h
--- ./parted-1.4.22/libparted/fs_reiserfs/reiserfs_bm.h Thu Jan 1 03:00:00 1970
+++ ./parted-reiserfs-1.4.22/libparted/fs_reiserfs/reiserfs_bm.h Sat Jan
12 21:39:30 2002
@@ -0,0 +1,49 @@
+/*
+ reiserfs_bm.h -- reiserfs bitmap stuff
+ Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/*
+ Some parts of this code are from original reiserfs code,
+ as found in the linux kernel. Writen by Yury Umanets (address@hidden)
+*/
+
+#ifndef REISERFS_BM_H
+#define REISERFS_BM_H
+
+static const char _reiserfs_bm_h[] = "$Id: reiserfs_fs.h,v 1.55 2002/01/11
19:56:19 yumanets Exp $";
+
+#include "reiserfs_fs.h"
+#include "reiserfs_blk.h"
+
+extern void _reiserfs_bm_set_bit (reiserfs_bm_t *bm, reiserfs_blk_t bit);
+extern void _reiserfs_bm_clear_bit (reiserfs_bm_t *bm, reiserfs_blk_t bit);
+extern int _reiserfs_bm_test_bit (reiserfs_bm_t *bm, reiserfs_blk_t bit);
+extern int _reiserfs_bm_find_zero_bit (reiserfs_bm_t *bm, reiserfs_blk_t
*start);
+
+extern reiserfs_bm_t *_reiserfs_bm_alloc(reiserfs_blk_t blocks);
+extern int _reiserfs_bm_realloc(reiserfs_bm_t *bm, reiserfs_blk_t blocks);
+extern void _reiserfs_bm_free(reiserfs_bm_t *bm);
+extern int _reiserfs_bm_fetch(reiserfs_fs_t *fs, reiserfs_bm_t *bm);
+extern int _reiserfs_bm_flush(reiserfs_fs_t *fs, reiserfs_bm_t *bm);
+extern reiserfs_bm_t *_reiserfs_bm_open (reiserfs_fs_t *fs);
+extern reiserfs_bm_t *_reiserfs_bm_create(reiserfs_fs_t *fs, reiserfs_blk_t
blocks,
+ size_t block_size, reiserfs_blk_t journal_blocks);
+extern int _reiserfs_bm_sync(reiserfs_fs_t *fs, reiserfs_bm_t *bm);
+extern void _reiserfs_bm_close(reiserfs_fs_t *fs, reiserfs_bm_t *bm);
+
+#endif
diff -rupN ./parted-1.4.22/libparted/fs_reiserfs/reiserfs_fs.c
./parted-reiserfs-1.4.22/libparted/fs_reiserfs/reiserfs_fs.c
--- ./parted-1.4.22/libparted/fs_reiserfs/reiserfs_fs.c Thu Jan 1 03:00:00 1970
+++ ./parted-reiserfs-1.4.22/libparted/fs_reiserfs/reiserfs_fs.c Sat Jan
12 21:38:59 2002
@@ -0,0 +1,877 @@
+/*
+ reiserfs_fs.c -- generic reiserfs stuff
+ Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/*
+ Some parts of this code are from original reiserfs code,
+ as found in the linux kernel. Writen by Yury Umanets (address@hidden)
+*/
+
+static const char _reiserfs_fs_c[] = "$Id: reiserfs_fs.c,v 1.55 2002/01/04
19:55:11 yumanets Exp $";
+
+#include <sys/stat.h>
+#include <unistd.h>
+#include <time.h>
+
+#include <parted/parted.h>
+
+#include "reiserfs_fs.h"
+#include "reiserfs_bm.h"
+#include "reiserfs_tools.h"
+
+#if ENABLE_NLS
+# include <libintl.h>
+# define _(String) dgettext (PACKAGE, String)
+#else
+# define _(String) (String)
+#endif
+
+#define _reiserfs_key_uniqueness get_key_uniqueness
+
+static struct key root_dir_key = {0, 0, {{0, 0},}};
+static struct key parent_root_dir_key = {0, 0, {{0, 0},}};
+
+static char *reiserfs_fs_state_names[] = {"undefined", "valid", "invalid"};
+
+static void _reiserfs_make_const_keys (void) {
+ set_key_dirid (&root_dir_key, REISERFS_ROOT_PARENT_OBJECTID);
+ set_key_objectid (&root_dir_key, REISERFS_ROOT_OBJECTID);
+
+ set_key_dirid (&parent_root_dir_key, 0);
+ set_key_objectid (&parent_root_dir_key, REISERFS_ROOT_PARENT_OBJECTID);
+}
+
+/*
+ Key functions.
+*/
+static int _reiserfs_uniqueness2type (__u32 uniqueness) {
+ switch (uniqueness) {
+ case V1_SD_UNIQUENESS: return KEY_TYPE_STAT_DATA;
+ case V1_INDIRECT_UNIQUENESS: return KEY_TYPE_INDIRECT;
+ case V1_DIRECT_UNIQUENESS: return KEY_TYPE_DIRECT;
+ case V1_DIRENTRY_UNIQUENESS: return KEY_TYPE_DIRENTRY;
+ }
+ return KEY_TYPE_UNKNOWN;
+}
+
+static __u32 _reiserfs_type2uniqueness (int type) {
+ switch (type) {
+ case KEY_TYPE_STAT_DATA: return V1_SD_UNIQUENESS;
+ case KEY_TYPE_INDIRECT: return V1_INDIRECT_UNIQUENESS;
+ case KEY_TYPE_DIRECT: return V1_DIRECT_UNIQUENESS;
+ case KEY_TYPE_DIRENTRY: return V1_DIRENTRY_UNIQUENESS;
+ }
+ return V1_UNKNOWN_UNIQUENESS;
+}
+
+#define V2_TYPE_MASK 0xf000000000000000LL
+
+static __u16 _reiserfs_key_type_v2 (const struct key *key) {
+ __u64 * p, tmp;
+
+ p = (__u64 *)(&(key->u.k2_offset_v2));
+ tmp = PED_LE64_TO_CPU (*p);
+ /* clear all bits but the ones the type is stored in */
+ tmp &= V2_TYPE_MASK;
+ /* type is stored in 4 highest bits */
+ tmp >>= 60;
+ return (__u16)tmp;
+}
+
+static int _reiserfs_key_format(const struct key *key) {
+ int type;
+
+ type = _reiserfs_key_type_v2 (key);
+
+ if (type == 0 || type == 15)
+ return KEY_FORMAT_1;
+
+ return KEY_FORMAT_2;
+}
+
+static int _reiserfs_key_type (const struct key *key) {
+ if (_reiserfs_key_format (key) == KEY_FORMAT_1)
+ return _reiserfs_uniqueness2type (_reiserfs_key_uniqueness (key));
+ return _reiserfs_key_type_v2 (key);
+}
+
+static int _reiserfs_journal_is_opened (reiserfs_fs_t *fs) {
+ return fs->fs_jh_bh ? 1 : 0;
+}
+
+static int _reiserfs_fs_is_newformat (reiserfs_fs_t *fs) {
+ return fs->fs_super_bh->b_blocknr != 2;
+}
+
+/*
+ Setting given state
+*/
+static int _reiserfs_fs_set_state(reiserfs_fs_t *fs, reiserfs_state_t state) {
+ set_sb_state(fs->fs_ondisk_sb, (int)state);
+ if (!_reiserfs_block_write(fs->io_handler, fs->fs_super_bh)) {
+ ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+ _("Couldn't set %s state. Writing (%lu) block failed"),
+ reiserfs_fs_state_names[state], fs->fs_super_bh->b_blocknr);
+ return 0;
+ }
+ return 1;
+}
+
+/*
+ Moving of the generic file system block
+*/
+static reiserfs_blk_t _reiserfs_block_move(reiserfs_fs_t *fs,
+ reiserfs_blk_t old_blk, reiserfs_blk_t new_blk)
+{
+ struct buffer_head *bh_old_blk, *bh_new_blk;
+
+ PED_ASSERT((old_blk < get_sb_block_count(fs->fs_ondisk_sb)), return 0);
+
+ if (!(bh_old_blk = _reiserfs_block_read(fs->io_handler, old_blk,
fs->fs_blocksize)))
+ return 0;
+
+ bh_new_blk = _reiserfs_block_alloc(new_blk, fs->fs_blocksize);
+ memcpy(bh_new_blk->b_data, bh_old_blk->b_data, bh_new_blk->b_size);
+
+ _reiserfs_bm_clear_bit(fs->fs_bitmap2, old_blk);
+ _reiserfs_bm_set_bit(fs->fs_bitmap2, new_blk);
+
+ _reiserfs_block_free(bh_old_blk);
+
+ if (!_reiserfs_block_write(fs->io_handler, bh_new_blk)) {
+ _reiserfs_block_free(bh_new_blk);
+ return 0;
+ }
+
+ _reiserfs_block_free(bh_new_blk);
+
+ return new_blk;
+}
+
+/*
+ Moving formated and unformated blocks.
+*/
+static reiserfs_blk_t _reiserfs_block_move_unformatted(reiserfs_fs_t *fs,
+ reiserfs_blk_t block, reiserfs_blk_t blocks)
+{
+ reiserfs_blk_t new_blk = 1;
+
+ /*
+ Checking whether block is inside
+ */
+ if (block < blocks)
+ return 0;
+
+ /*
+ Finding free block
+ */
+ _reiserfs_bm_find_zero_bit(fs->fs_bitmap2, &new_blk);
+ if (new_blk == 0 || new_blk >= blocks)
+ return 0;
+
+ return _reiserfs_block_move(fs, block, new_blk);
+}
+
+static reiserfs_blk_t _reiserfs_block_move_formatted(reiserfs_fs_t *fs,
+ reiserfs_blk_t block, reiserfs_blk_t blocks)
+{
+ int i, j;
+ struct buffer_head *bh_blk;
+ struct item_head *ih;
+ reiserfs_blk_t new_blk = 1;
+
+ if (!(bh_blk = _reiserfs_block_read(fs->io_handler, block,
fs->fs_blocksize))) {
+ ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+ _("Couldn't move formated block. Reading block (%lu) failed"),
block);
+ return 0;
+ }
+
+ if (is_leaf_node (bh_blk)) {
+ /*
+ This is a leaf node. The small files lives directly in them.
+ And the big files, so called unformated blocks are chinden of
+ the leaves. Leaves references them. The unformated blocks are
+ files data. We move them here.
+ */
+ for (i = 0; i < B_NR_ITEMS(bh_blk); i++) {
+ ih = B_N_PITEM_HEAD(bh_blk, i);
+ if (is_indirect_ih(ih)) {
+ __u32 * indirect;
+
+ indirect = (__u32 *)B_I_PITEM (bh_blk, ih);
+ for (j = 0; j < (int)I_UNFM_NUM(ih); j++) {
+ reiserfs_blk_t unfm_blk;
+
+ if (indirect [j] == 0)
+ continue;
+
+ if ((unfm_blk = _reiserfs_block_move_unformatted(fs,
+ PED_LE32_TO_CPU (indirect [j]), blocks)))
+ indirect [j] = PED_CPU_TO_LE32(unfm_blk);
+ }
+ }
+ }
+ } else if (is_internal_node (bh_blk)) {
+
+ /*
+ This is an internal node. Internals nodes contains
+ other internals nodes and leaves. In all cases we
+ make recursive call to moving all children.
+ */
+
+ for (i = 0; i <= B_NR_ITEMS(bh_blk); i++) {
+ reiserfs_blk_t moved_blk;
+ if ((moved_blk = _reiserfs_block_move_formatted(fs,
+ get_dc_child_blocknr (B_N_CHILD (bh_blk, i)), blocks)))
+ set_dc_child_blocknr (B_N_CHILD (bh_blk, i), moved_blk);
+ }
+
+ } else {
+ ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+ _("Couldn't move formated block. Block (%lu) has invalid format"),
block);
+ return 0;
+ }
+
+ if (!_reiserfs_block_write(fs->io_handler, bh_blk)) {
+ ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+ _("Can't move formated block (%lu). Writing failed"),
+ bh_blk->b_blocknr);
+ _reiserfs_block_free(bh_blk);
+ return 0;
+ }
+ _reiserfs_block_free(bh_blk);
+
+ /*
+ Checking whether block is inside
+ */
+ if (block < blocks)
+ return 0;
+
+ /*
+ Finding free block
+ */
+ _reiserfs_bm_find_zero_bit(fs->fs_bitmap2, &new_blk);
+ if (new_blk == 0 || new_blk >= blocks)
+ return 0;
+
+ return _reiserfs_block_move(fs, block, new_blk);
+}
+
+static int _reiserfs_fs_shrink(reiserfs_fs_t *fs, reiserfs_blk_t blocks) {
+ reiserfs_blk_t new_root_blk;
+ reiserfs_blk_t bmap_new_blknr;
+
+ bmap_new_blknr = (blocks - 1) / (8 * fs->fs_blocksize) + 1;
+
+ /* is shrinking possible ? */
+ if (get_sb_block_count(fs->fs_ondisk_sb) - blocks >
get_sb_free_blocks(fs->fs_ondisk_sb) +
+ get_sb_bmap_nr(fs->fs_ondisk_sb) - bmap_new_blknr)
+ {
+ ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+ _("Can't shrink filesystem. Too many blocks already allocated"));
+ return 0;
+ }
+
+ if ((new_root_blk = _reiserfs_block_move_formatted(fs,
get_sb_root_block(fs->fs_ondisk_sb), blocks)))
+ set_sb_root_block (fs->fs_ondisk_sb, new_root_blk);
+
+ /*
+ Shrinking bitmap
+ */
+ fs->fs_bitmap2->bm_bit_size = blocks;
+ fs->fs_bitmap2->bm_byte_size = (blocks + 7) / 8;
+
+ set_sb_free_blocks (fs->fs_ondisk_sb, get_sb_free_blocks(fs->fs_ondisk_sb)
-
+ (get_sb_block_count(fs->fs_ondisk_sb) - blocks) +
(get_sb_bmap_nr(fs->fs_ondisk_sb) - bmap_new_blknr));
+ set_sb_block_count (fs->fs_ondisk_sb, blocks);
+ set_sb_bmap_nr (fs->fs_ondisk_sb, bmap_new_blknr);
+
+ return 1;
+}
+
+static int _reiserfs_fs_expand(reiserfs_fs_t *fs, reiserfs_blk_t blocks) {
+
+ reiserfs_blk_t i;
+ struct reiserfs_super_block *sb;
+ reiserfs_blk_t bmap_new_blknr, bmap_old_blknr;
+
+ sb = fs->fs_ondisk_sb;
+
+ if (!_reiserfs_bm_realloc(fs->fs_bitmap2, blocks)) {
+ ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+ _("Can't expand bitmap"));
+ return 0;
+ }
+
+ /*
+ Computing bitmap blocks count in new fs. One bit in bitmap
+ points to big extent which consists of 8 reiserfs blocks.
+ Default it is 4096 * 8. In my case (14795376k hdd and one
+ big reiserfs partition) bitmap is about 113 blocks. It is
+ about 3Mb of address information.
+ */
+ bmap_old_blknr = get_sb_bmap_nr(sb);
+ bmap_new_blknr = (blocks - 1) / (fs->fs_blocksize * 8) + 1;
+
+ /*
+ Updating super block buffer
+ */
+ set_sb_free_blocks(sb, get_sb_free_blocks(sb) + (blocks -
get_sb_block_count(sb)) -
+ (bmap_new_blknr - bmap_old_blknr));
+ set_sb_block_count(sb, blocks);
+ set_sb_bmap_nr(sb, bmap_new_blknr);
+
+ /*
+ Mark new bitmap blocks as used
+ */
+
+ for (i = bmap_old_blknr; i < bmap_new_blknr; i++)
+ _reiserfs_bm_set_bit (fs->fs_bitmap2, i * fs->fs_blocksize * 8);
+
+ return 1;
+}
+
+static void _reiserfs_fs_free (reiserfs_fs_t *fs) {
+ if (fs->fs_jh_bh) {
+ _reiserfs_block_free(fs->fs_jh_bh);
+ fs->fs_jh_bh = 0;
+ }
+
+ _reiserfs_bm_close(fs, fs->fs_bitmap2);
+
+ if (fs->fs_super_bh) {
+ _reiserfs_block_free(fs->fs_super_bh);
+ fs->fs_super_bh = 0;
+ }
+
+ ped_free(fs);
+}
+
+static int _reiserfs_journal_open(reiserfs_fs_t *fs) {
+ struct buffer_head *bh_blk;
+ struct reiserfs_super_block *sb;
+
+ sb = fs->fs_ondisk_sb;
+
+ if (!(bh_blk = _reiserfs_block_read (fs->io_handler,
get_jp_journal_1st_block(sb_jp(sb)) +
+ get_jp_journal_size (sb_jp (sb)), fs->fs_blocksize)))
+ return 0;
+
+ fs->fs_jh_bh = bh_blk;
+ return 1;
+}
+
+/* Public functions */
+reiserfs_fs_t *_reiserfs_fs_open (struct reiserfs_io_handler *io_handler) {
+ int i;
+ reiserfs_fs_t *fs;
+ struct reiserfs_super_block *sb;
+ struct buffer_head *bh_blk;
+ int super_offset[] = {16, 2, -1};
+
+ /*
+ Convert root dir key and parent root dir key to little
+ endian format
+ */
+ _reiserfs_make_const_keys();
+
+ fs = (reiserfs_fs_t *)ped_malloc(sizeof(*fs));
+ memset(fs, 0, sizeof(*fs));
+
+ fs->io_handler = io_handler;
+
+ for (i = 0; super_offset[i] != -1; i++) {
+ if (!(bh_blk = _reiserfs_block_read (fs->io_handler, super_offset[i],
+ REISERFS_DEFAULT_BLOCK_SIZE)))
+ {
+ ped_exception_throw(PED_EXCEPTION_WARNING, PED_EXCEPTION_IGNORE,
+ _("Can't read block %d\n"), i);
+ } else {
+ sb = (struct reiserfs_super_block *)bh_blk->b_data;
+
+ if (is_any_reiserfs_magic_string ((const char *)sb->s_v1.s_magic)) {
+ /*
+ Making some check to make sure that super block looks
+ correctly. I mean, that fs block count must be less device
+ block count.
+ */
+ if (get_sb_block_count(sb) <=
io_handler->ops->blocks(io_handler, get_sb_block_size(sb)))
+ goto found;
+
+ ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+ _("Super block has invalid block count"));
+ }
+
+ /*
+ Reiserfs signature isn't found at the
+ reiserfs_super_offset[i]-th 4k block
+ */
+ _reiserfs_block_free(bh_blk);
+ }
+ }
+
+ goto error_free_fs;
+
+found:
+ fs->fs_version = get_sb_version(sb);
+ fs->fs_blocksize = get_sb_block_size(sb);
+ fs->fs_super_bh = bh_blk;
+ fs->fs_ondisk_sb = sb;
+
+ if (!_reiserfs_journal_open(fs))
+ goto error_free_fs;
+
+ if (!_reiserfs_bm_open(fs))
+ goto error_free_journal;
+
+ return fs;
+
+error_free_journal:
+ _reiserfs_block_free(fs->fs_jh_bh);
+error_free_fs:
+ ped_free(fs);
+error:
+ return NULL;
+}
+
+static struct buffer_head *_reiserfs_sb_create(size_t block_size,
reiserfs_blk_t journal_blocks,
+ reiserfs_blk_t blocks)
+{
+ __u32 *oids;
+ reiserfs_blk_t blk;
+ struct reiserfs_super_block *sb;
+ struct buffer_head *super_bh_blk, **bm_bh_blks;
+
+ blk = REISERFS_DISK_OFFSET_IN_BYTES / block_size;
+
+ super_bh_blk = _reiserfs_block_alloc(blk, block_size);
+ sb = (struct reiserfs_super_block *)super_bh_blk->b_data;
+
+ memset(sb, 0, block_size);
+
+ sb->s_v1.sb_block_count = PED_CPU_TO_LE32(blocks);
+ sb->s_v1.sb_bmap_nr = PED_CPU_TO_LE16((blocks + (block_size * 8 - 1)) /
(block_size * 8));
+
+ /*
+ Used blocks are: blk-s skipped, super block,
+ bitmap blocks, journal, root block.
+ */
+ sb->s_v1.sb_free_blocks = PED_CPU_TO_LE32(blocks - blk - 1 -
journal_blocks - 1
+ - PED_LE16_TO_CPU (sb->s_v1.sb_bmap_nr) - 1);
+
+ /*
+ Root block is after skipped (super_block), super block (1), first
+ bitmap(1), journal (journal_size), journal header(1)
+ */
+ sb->s_v1.sb_root_block = PED_CPU_TO_LE32(blk + 1 + 1 + journal_blocks + 1);
+
+ sb->s_v1.sb_version = PED_CPU_TO_LE16(REISERFS_FORMAT_3_6);
+ sb->s_v1.sb_blocksize = PED_CPU_TO_LE16(block_size);
+ sb->s_v1.sb_state = PED_CPU_TO_LE16(REISERFS_FS_VALID);
+ sb->s_v1.sb_tree_height = PED_CPU_TO_LE16(2);
+ sb->s_v1.sb_journal.jp_journal_dev = PED_CPU_TO_LE32(0);
+ sb->s_v1.sb_journal.jp_journal_size = PED_CPU_TO_LE32(journal_blocks);
+ sb->s_v1.sb_journal.jp_journal_trans_max = PED_CPU_TO_LE32(0);
+ sb->s_v1.sb_journal.jp_journal_block_count = PED_CPU_TO_LE32(0);
+ sb->s_v1.sb_journal.jp_journal_max_batch = PED_CPU_TO_LE32(0);
+ sb->s_v1.sb_journal.jp_journal_max_commit_age = PED_CPU_TO_LE32(0);
+ sb->s_v1.sb_journal.jp_journal_max_trans_age = PED_CPU_TO_LE32(0);
+ memcpy (sb->s_v1.s_magic, REISER2FS_SUPER_MAGIC_STRING,
+ sizeof (REISER2FS_SUPER_MAGIC_STRING));
+ /*
+ Using R5 hash as recomended in reiserfsprogs
+ */
+ sb->s_v1.sb_hash_function_code = PED_CPU_TO_LE32(3);
+
+ oids = (__u32 *)(sb + 1);
+ oids[0] = PED_CPU_TO_LE32(1);
+ oids[1] = PED_CPU_TO_LE32(REISERFS_ROOT_OBJECTID + 1);
+
+ sb->s_v1.sb_oid_cursize = PED_CPU_TO_LE16 (2);
+ sb->s_v1.sb_oid_maxsize = PED_CPU_TO_LE16 ((block_size - SB_SIZE) /
+ sizeof (__u32) / 2 * 2);
+
+ sb->s_v1.sb_journal.jp_journal_1st_block =
PED_CPU_TO_LE32(super_bh_blk->b_blocknr + 2);
+
+ return super_bh_blk;
+}
+
+/*
+ Compose directory item containing "." and ".." entries
+*/
+static inline void make_empty_dir_item (char * body, __u32 dirid, __u32 objid,
+ __u32 par_dirid, __u32 par_objid)
+{
+ struct reiserfs_de_head *deh;
+
+ memset (body, 0, EMPTY_DIR_SIZE);
+ deh = (struct reiserfs_de_head *)body;
+
+ /*
+ Direntry header of "."
+ */
+ deh[0].deh2_offset = PED_CPU_TO_LE32(DOT_OFFSET);
+ deh[0].deh2_dir_id = PED_CPU_TO_LE32(dirid);
+ deh[0].deh2_objectid = PED_CPU_TO_LE32(objid);
+ deh[0].deh2_location = PED_CPU_TO_LE16(EMPTY_DIR_SIZE - ROUND_UP(strlen
(".")));
+ deh[0].deh2_state = 0;
+ mark_de_visible(&(deh[0]));
+
+ /*
+ Direntry header of ".."
+ */
+ deh[1].deh2_offset = PED_CPU_TO_LE32(DOT_DOT_OFFSET);
+
+ /*
+ Key of ".." for the root directory
+ */
+ deh[1].deh2_dir_id = PED_CPU_TO_LE32(par_dirid);
+ deh[1].deh2_objectid = PED_CPU_TO_LE32(par_objid);
+ deh[1].deh2_location =
PED_CPU_TO_LE16(PED_LE16_TO_CPU(deh[0].deh2_location) -
+ ROUND_UP(strlen ("..")));
+ deh[1].deh2_state = 0;
+ mark_de_visible(&(deh[1]));
+
+ /*
+ Copy ".." and "."
+ */
+ memcpy(body + deh[0].deh2_location, ".", 1);
+ memcpy(body + deh[1].deh2_location, "..", 2);
+}
+
+/*
+ Form the root block of the tree (the block head, the item head, the
+ root directory)
+*/
+static struct buffer_head *_reiserfs_root_create(reiserfs_fs_t *fs) {
+ char *rb;
+ struct reiserfs_super_block *sb = fs->fs_ondisk_sb;
+ struct buffer_head *root_bh_blk;
+ struct block_head *blkh;
+ struct item_head *ih;
+ struct stat_data *sd;
+ struct key maxkey = {0xffffffff, 0xffffffff, {{0xffffffff, 0xffffffff}, }};
+
+ PED_ASSERT(fs != NULL, return NULL);
+
+ root_bh_blk =
_reiserfs_block_alloc(PED_LE32_TO_CPU(sb->s_v1.sb_root_block),
+ fs->fs_super_bh->b_size);
+ rb = root_bh_blk->b_data;
+
+ /*
+ First item is stat data item of root directory
+ */
+ ih = (struct item_head *)(rb + BLKH_SIZE);
+ ih_version(ih) = PED_CPU_TO_LE16(ITEM_VERSION_2);
+ ih->ih_key.k2_dir_id = PED_CPU_TO_LE32(REISERFS_ROOT_PARENT_OBJECTID);
+ ih->ih_key.k2_objectid = PED_CPU_TO_LE32(REISERFS_ROOT_OBJECTID);
+
+ if (ih_version(ih) == ITEM_VERSION_1)
+ set_key_offset_v1(&ih->ih_key, SD_OFFSET);
+ else
+ ih->ih_key.u.k2_offset_v2.k_offset = PED_CPU_TO_LE64(SD_OFFSET);
+
+ if (ih_version(ih) == ITEM_VERSION_1)
+ set_key_uniqueness(&ih->ih_key,
_reiserfs_type2uniqueness(KEY_TYPE_STAT_DATA));
+ else
+ ih->ih_key.u.k2_offset_v2.k_type = PED_CPU_TO_LE16(KEY_TYPE_STAT_DATA);
+
+ ih->ih2_item_len = PED_CPU_TO_LE16 (SD_SIZE);
+ ih->ih2_item_location =
PED_CPU_TO_LE16(PED_LE16_TO_CPU(sb->s_v1.sb_blocksize) -
+ SD_SIZE);
+ set_ih_free_space(ih, MAX_US_INT);
+
+ /*
+ Fill new stat data
+ */
+ sd = (struct stat_data *)(rb + ih->ih2_item_location);
+ sd->sd_mode = PED_CPU_TO_LE16(S_IFDIR + 0755);
+ sd->sd_nlink = PED_CPU_TO_LE16(3);
+ sd->sd_uid = PED_CPU_TO_LE32(getuid());
+ sd->sd_gid = PED_CPU_TO_LE32(getgid());
+ sd->sd_size = PED_CPU_TO_LE64(EMPTY_DIR_SIZE);
+ sd->sd_atime = sd->sd_ctime = sd->sd_mtime = PED_CPU_TO_LE32(time(NULL));
+ sd->u.sd_rdev = PED_CPU_TO_LE32(0);
+
+ /*
+ Second item is root directory item,
+ containing "." and ".."
+ */
+ ih++;
+ ih_version(ih) = PED_CPU_TO_LE16(ITEM_VERSION_1);
+ ih->ih_key.k2_dir_id = PED_CPU_TO_LE32(REISERFS_ROOT_PARENT_OBJECTID);
+ ih->ih_key.k2_objectid = PED_CPU_TO_LE32(REISERFS_ROOT_OBJECTID);
+
+ if (ih_version(ih) == ITEM_VERSION_1)
+ set_key_offset_v1(&ih->ih_key, DOT_OFFSET);
+ else
+ ih->ih_key.u.k2_offset_v2.k_offset = PED_CPU_TO_LE64(DOT_OFFSET);
+
+ if (ih_version(ih) == ITEM_VERSION_1)
+ set_key_uniqueness(&ih->ih_key,
_reiserfs_type2uniqueness(KEY_TYPE_DIRENTRY));
+ else
+ ih->ih_key.u.k2_offset_v2.k_type = PED_CPU_TO_LE16(KEY_TYPE_DIRENTRY);
+
+ ih->ih2_item_len = PED_CPU_TO_LE16(DEH_SIZE * 2 + ROUND_UP(strlen (".")) +
+ ROUND_UP(strlen ("..")));
+ ih->ih2_item_location =
PED_CPU_TO_LE16(PED_LE16_TO_CPU((ih-1)->ih2_item_location) -
+ PED_LE16_TO_CPU(ih->ih2_item_len));
+ ih->u.ih2_entry_count = PED_CPU_TO_LE32(2);
+
+ /*
+ Compose item itself
+ */
+ make_empty_dir_item(rb + ih->ih2_item_location,
REISERFS_ROOT_PARENT_OBJECTID,
+ REISERFS_ROOT_OBJECTID, 0, REISERFS_ROOT_PARENT_OBJECTID);
+
+ /*
+ Block head
+ */
+ blkh = (struct block_head *)rb;
+ blkh->blk2_level = PED_CPU_TO_LE16 (REISERFS_DISK_LEAF_LEVEL);
+ blkh->blk2_nr_item = PED_CPU_TO_LE16 (2);
+ blkh->blk2_free_space = PED_CPU_TO_LE16
(PED_LE32_TO_CPU(sb->s_v1.sb_blocksize) - BLKH_SIZE -
+ 2 * IH_SIZE - SD_SIZE - PED_LE16_TO_CPU(ih->ih2_item_len));
+
+ return root_bh_blk;
+}
+
+/*
+ Initializing journal. Writes to device
+*/
+static int _reiserfs_journal_init(reiserfs_fs_t *fs, reiserfs_blk_t start,
+ reiserfs_blk_t len)
+{
+ reiserfs_blk_t i;
+ struct buffer_head *bh_blk;
+
+ for (i = 0; i < len; i++) {
+ bh_blk = _reiserfs_block_alloc(start + i, fs->fs_blocksize);
+ memset(bh_blk->b_data, 0, fs->fs_blocksize);
+ if (!_reiserfs_block_write(fs->io_handler, bh_blk)) {
+ _reiserfs_block_free(bh_blk);
+ return 0;
+ }
+ _reiserfs_block_free(bh_blk);
+ }
+
+ if (!(bh_blk = _reiserfs_block_read (fs->io_handler,
get_jp_journal_1st_block(sb_jp(fs->fs_ondisk_sb)) +
+ get_jp_journal_size (sb_jp (fs->fs_ondisk_sb)), fs->fs_blocksize)))
+ return 0;
+
+ fs->fs_jh_bh = bh_blk;
+
+ return 1;
+}
+
+/*
+ Disables other fs and old versions of reiserfs
+ (super block lie at 2-th 4096 block). Wtrites to device too
+*/
+static int _reiserfs_fs_disable_other(reiserfs_fs_t *fs) {
+ struct buffer_head *bh_blk;
+
+ /*
+ Discard vfat/msods (0-th 512 byte sector)
+ and ext2 (1-st 1024 byte block)
+ */
+ bh_blk = _reiserfs_block_alloc(0, 2048);
+ memset (bh_blk->b_data, 0, 2048);
+ if (!_reiserfs_block_write(fs->io_handler, bh_blk)) {
+ _reiserfs_block_free(bh_blk);
+ return 0;
+ }
+ _reiserfs_block_free(bh_blk);
+
+ /*
+ Discard super block of reiserfs of old
+ format (8-th 1024 byte block)
+ */
+ bh_blk = _reiserfs_block_alloc(8, 1024);
+ memset(bh_blk->b_data, 0, 1024);
+ if (!_reiserfs_block_write(fs->io_handler, bh_blk)) {
+ _reiserfs_block_free(bh_blk);
+ return 0;
+ }
+ _reiserfs_block_free(bh_blk);
+ return 1;
+}
+
+reiserfs_fs_t *_reiserfs_fs_create (struct reiserfs_io_handler *io_handler,
+ size_t block_size, reiserfs_blk_t journal_blocks, reiserfs_blk_t blocks)
+{
+ struct buffer_head *super_bh_blk, *root_bh_blk;
+ reiserfs_fs_t *fs;
+
+ if (block_size < PED_SECTOR_SIZE) {
+ ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+ _("Block size is too small (%d)"), block_size);
+ return NULL;
+ }
+
+ if (block_size > REISERFS_DISK_OFFSET_IN_BYTES) {
+ ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+ _("Block size is too big (%d)"), block_size);
+ return NULL;
+ }
+
+ if (!(fs = (reiserfs_fs_t *)ped_malloc(sizeof(*fs))))
+ return NULL;
+
+ memset(fs, 0, sizeof(*fs));
+ fs->io_handler = io_handler;
+ fs->fs_version = REISERFS_FORMAT_3_6;
+
+ /* Creating super */
+ if (!(super_bh_blk = _reiserfs_sb_create(block_size, journal_blocks,
blocks))) {
+ ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+ _("Couldn't create super block"));
+ goto error_free_fs;
+ }
+
+ fs->fs_super_bh = super_bh_blk;
+ fs->fs_ondisk_sb = (struct reiserfs_super_block *)super_bh_blk->b_data;
+ fs->fs_blocksize = block_size;
+
+ /*
+ Creating bitmap and setting it up
+ */
+ if (!_reiserfs_bm_create(fs, blocks, block_size, journal_blocks)) {
+ ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+ _("Couldn't create bitmap"));
+ goto error_free_super;
+ }
+
+ /*
+ Creating root
+ */
+ if (!(root_bh_blk = _reiserfs_root_create(fs))) {
+ ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+ _("Couldn't create root block"));
+ goto error_free_bitmap;
+ }
+
+ /* Disabling other fs and older versions of reiserfs */
+ if (!_reiserfs_fs_disable_other(fs)) {
+ ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+ _("Couldn't disable other filesystems"));
+ goto error_free_root;
+ }
+
+ /* Writing initialized journal to disk */
+ if (!_reiserfs_journal_init(fs,
fs->fs_ondisk_sb->s_v1.sb_journal.jp_journal_1st_block,
+ fs->fs_ondisk_sb->s_v1.sb_journal.jp_journal_size))
+ {
+ ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+ _("Couldn't initialize journal"));
+ goto error_free_root;
+ }
+
+ /* Writing root block */
+ if (!_reiserfs_block_write(fs->io_handler, root_bh_blk)) {
+ ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+ _("Couldn't write root block"));
+ goto error_free_root;
+ }
+
+ /* Writing super block */
+ if (!_reiserfs_block_write(fs->io_handler, super_bh_blk)) {
+ ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+ _("Couldn't write super block"));
+ goto error_free_root;
+ }
+
+ /* Synchronizing bitmap */
+ if (!_reiserfs_bm_sync(fs, fs->fs_bitmap2)) {
+ ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+ _("Couldn't synchronize bitmap"));
+ goto error_free_root;
+ }
+
+ return fs;
+
+error_free_root:
+ _reiserfs_block_free(root_bh_blk);
+error_free_super:
+ _reiserfs_block_free(super_bh_blk);
+error_free_bitmap:
+ _reiserfs_bm_free(fs->fs_bitmap2);
+error_free_fs:
+ ped_free(fs);
+error:
+ return NULL;
+}
+
+void _reiserfs_fs_close (reiserfs_fs_t *fs) {
+ _reiserfs_fs_free(fs);
+}
+
+int _reiserfs_fs_is_consistent (reiserfs_fs_t *fs) {
+ if (!_reiserfs_journal_is_opened (fs)) {
+ ped_exception_throw(PED_EXCEPTION_WARNING, PED_EXCEPTION_IGNORE,
+ _("Standart journal not opened"));
+ return 0;
+ }
+
+ if (get_sb_fsck_state (fs->fs_ondisk_sb) != REISERFS_FS_CONSISTENT)
+ return 0;
+
+ return 1;
+}
+
+int _reiserfs_fs_is_found (reiserfs_fs_t *fs) {
+ return (fs->fs_blocksize == 0) ? 0 : 1;
+}
+
+int _reiserfs_bm_is_spread(reiserfs_fs_t *fs) {
+ return fs->fs_super_bh->b_blocknr != 2;
+}
+
+int _reiserfs_fs_resize(reiserfs_fs_t *fs, reiserfs_blk_t blocks) {
+
+ if (get_sb_state(fs->fs_ondisk_sb) != REISERFS_FS_VALID) {
+ ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+ _("Filesystem isn't in valid state"));
+ return 0;
+ }
+
+ if (blocks > fs->io_handler->ops->blocks(fs->io_handler,
fs->fs_blocksize)) {
+ ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+ _("Device is too small for %d blocks"), blocks);
+ return 0;
+ }
+
+ if (blocks == get_sb_block_count(fs->fs_ondisk_sb)) {
+ ped_exception_throw(PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+ _("New size is the same as previous one"));
+ return 0;
+ }
+
+ _reiserfs_fs_set_state(fs, REISERFS_FS_INVALID);
+
+ if (!(blocks > get_sb_block_count(fs->fs_ondisk_sb) ?
+ _reiserfs_fs_expand(fs, blocks) : _reiserfs_fs_shrink(fs, blocks)))
+ return 0;
+
+ if (!_reiserfs_bm_sync(fs, fs->fs_bitmap2))
+ return 0;
+
+ _reiserfs_fs_set_state(fs, REISERFS_FS_VALID);
+
+ return 1;
+}
diff -rupN ./parted-1.4.22/libparted/fs_reiserfs/reiserfs_fs.h
./parted-reiserfs-1.4.22/libparted/fs_reiserfs/reiserfs_fs.h
--- ./parted-1.4.22/libparted/fs_reiserfs/reiserfs_fs.h Thu Jan 1 03:00:00 1970
+++ ./parted-reiserfs-1.4.22/libparted/fs_reiserfs/reiserfs_fs.h Sat Jan
12 21:59:16 2002
@@ -0,0 +1,549 @@
+/*
+ reiserfs_fs.h -- generic reiserfs stuff
+ Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/*
+ Some parts of this code are from original reiserfs code,
+ as found in the linux kernel. Writen by Yury Umanets (address@hidden)
+*/
+
+#ifndef REISERFS_FS_H
+#define REISERFS_FS_H
+
+static const char _reiserfs_fs_h[] = "$Id: reiserfs_fs.h,v 1.55 2002/01/04
19:56:19 yumanets Exp $";
+
+#include <parted/endian.h>
+#include <parted/parted.h>
+
+#include "reiserfs_io.h"
+#include "reiserfs_blk.h"
+
+#define _ROUND_UP(x,n) (((x)+(n)-1u) & ~((n)-1u))
+#define ROUND_UP(x) _ROUND_UP(x,8LL)
+
+#define REISERFS_DISK_OFFSET_IN_BYTES 64 * 1024
+
+/*
+ Older and newer versions of the reiserfs
+*/
+#define REISERFS_FORMAT_3_5 0
+#define REISERFS_FORMAT_3_6 2
+
+/*
+ Max tree height in current version of the reiserfs,
+ but the grub-0.90 thinks tree height is 7
+*/
+#define REISERFS_TREE_MAX_HEIGHT 5
+
+/*
+ All operations which performed on fs mark fs as error first
+ and when operation is done mark it as valid again. So if operation
+ has failed we will have invalid file system and will needed
+ to reiserfsck it
+*/
+
+/*
+ Init key (id and parent id) for the tree root
+*/
+#define REISERFS_ROOT_OBJECTID 2
+#define REISERFS_ROOT_PARENT_OBJECTID 1
+
+/*
+ Tree levels
+*/
+#define REISERFS_FREE_LEVEL 0
+#define REISERFS_DISK_LEAF_LEVEL 1
+
+
+/*
+ Default block size. Needed by _reiserfs_fs_open
+ to read the super block and in other cases
+*/
+#define REISERFS_DEFAULT_BLOCK_SIZE 4096
+
+#define B_N_CHILD(p_s_bh,n_pos) \
+ ((struct disk_child *)((p_s_bh)->b_data + BLKH_SIZE + B_NR_ITEMS(p_s_bh) *\
+ KEY_SIZE + DC_SIZE * (n_pos)))
+
+#define MAX_CHILD_SIZE(blocksize) ((blocksize) - BLKH_SIZE)
+#define MAX_FREE_SPACE(blocksize) MAX_CHILD_SIZE(blocksize)
+
+#define B_CHILD_SIZE(cur) \
+ (MAX_CHILD_SIZE(cur->b_size)-(B_FREE_SPACE(cur)))
+
+#define B_I_PITEM(bh,ih) \
+ ((bh)->b_data + get_ih_location(ih))
+
+#define V1_SD_UNIQUENESS 0
+#define V1_DIRENTRY_UNIQUENESS 500
+#define V1_DIRECT_UNIQUENESS 0xffffffff
+#define V1_INDIRECT_UNIQUENESS 0xfffffffe
+#define V1_UNKNOWN_UNIQUENESS 555
+
+#define KEY_TYPE_STAT_DATA 0
+#define KEY_TYPE_INDIRECT 1
+#define KEY_TYPE_DIRECT 2
+#define KEY_TYPE_DIRENTRY 3
+#define KEY_TYPE_UNKNOWN 15
+
+#define KEY_FORMAT_1 0
+#define KEY_FORMAT_2 1
+
+#define KEY_IS_STAT_DATA_KEY(p_s_key) \
+ (_reiserfs_key_type (p_s_key) == KEY_TYPE_STAT_DATA)
+#define KEY_IS_DIRECTORY_KEY(p_s_key) \
+ (_reiserfs_key_type (p_s_key) == KEY_TYPE_DIRENTRY)
+#define KEY_IS_DIRECT_KEY(p_s_key) \
+ (_reiserfs_key_type (p_s_key) == KEY_TYPE_DIRECT)
+#define KEY_IS_INDIRECT_KEY(p_s_key) \
+ (_reiserfs_key_type (p_s_key) == KEY_TYPE_INDIRECT)
+
+#define is_indirect_key(key) KEY_IS_INDIRECT_KEY(key)
+#define is_direct_key(key) KEY_IS_DIRECT_KEY(key)
+#define is_direntry_key(key) KEY_IS_DIRECTORY_KEY(key)
+#define is_stat_data_key(key) KEY_IS_STAT_DATA_KEY(key)
+
+#define I_IS_STAT_DATA_ITEM(p_s_ih) \
+ KEY_IS_STAT_DATA_KEY(&((p_s_ih)->ih_key))
+#define I_IS_DIRECTORY_ITEM(p_s_ih) \
+ KEY_IS_DIRECTORY_KEY(&((p_s_ih)->ih_key))
+#define I_IS_DIRECT_ITEM(p_s_ih) \
+ KEY_IS_DIRECT_KEY(&((p_s_ih)->ih_key))
+#define I_IS_INDIRECT_ITEM(p_s_ih) \
+ KEY_IS_INDIRECT_KEY(&((p_s_ih)->ih_key))
+
+#define is_indirect_ih(ih) I_IS_INDIRECT_ITEM(ih)
+#define is_direct_ih(ih) I_IS_DIRECT_ITEM(ih)
+#define is_direntry_ih(ih) I_IS_DIRECTORY_ITEM(ih)
+#define is_stat_data_ih(ih) I_IS_STAT_DATA_ITEM(ih)
+
+#define B_N_PITEM_HEAD(bh, item_num) \
+ ((struct item_head * )((bh)->b_data + BLKH_SIZE) + (item_num))
+
+#define B_BLK_HEAD(p_s_bh) \
+ ((struct block_head *)((p_s_bh)->b_data))
+
+#define B_NR_ITEMS(bh) get_blkh_nr_items (B_BLK_HEAD(bh))
+#define B_LEVEL(bh) get_blkh_level (B_BLK_HEAD(bh))
+#define B_FREE_SPACE(bh) get_blkh_free_space (B_BLK_HEAD(bh))
+
+#define is_leaf_node(bh) is_leaf_block_head ((bh)->b_data)
+#define is_internal_node(bh) is_internal_block_head ((bh)->b_data)
+
+#define get_leXX(xx,p,field) \
+ (PED_LE##xx##_TO_CPU ((p)->##field))
+#define set_leXX(xx,p,field,val) \
+ do { (p)->##field = PED_CPU_TO_LE##xx(val); } while (0)
+
+#define get_le16(p,field) get_leXX (16, p, field)
+#define set_le16(p,field,val) set_leXX (16, p, field, val)
+
+#define get_le32(p,field) get_leXX (32, p, field)
+#define set_le32(p,field,val) set_leXX (32, p, field, val)
+
+#define get_le64(p,field) get_leXX (64, p, field)
+#define set_le64(p,field,val) set_leXX (64, p, field, val)
+
+struct block_head {
+ __u16 blk2_level;
+ __u16 blk2_nr_item;
+ __u16 blk2_free_space;
+ __u16 blk_reserved;
+ __u32 reserved[4];
+};
+
+#define BLKH_SIZE (sizeof(struct block_head))
+
+#define get_blkh_level(blkh) get_le16 (blkh, blk2_level)
+#define set_blkh_level(blkh,val) set_le16 (blkh, blk2_level, val)
+
+#define get_blkh_nr_items(blkh) get_le16 (blkh, blk2_nr_item)
+#define set_blkh_nr_items(blkh,val) set_le16 (blkh, blk2_nr_item, val)
+
+#define get_blkh_free_space(blkh) get_le16 (blkh, blk2_free_space)
+#define set_blkh_free_space(blkh,val) set_le16 (blkh, blk2_free_space, val)
+
+#define is_leaf_block_head(buf) \
+ (get_blkh_level ((struct block_head *)(buf)) == REISERFS_DISK_LEAF_LEVEL)
+#define is_internal_block_head(buf) \
+ ((get_blkh_level (((struct block_head *)(buf))) >
REISERFS_DISK_LEAF_LEVEL) && \
+ (get_blkh_level (((struct block_head *)(buf))) <=
REISERFS_TREE_MAX_HEIGHT))
+
+struct offset_v1 {
+ __u32 k_offset;
+ __u32 k_uniqueness;
+} __attribute__ ((__packed__));
+
+struct offset_v2 {
+ __u64 k_offset: 60;
+ __u64 k_type: 4;
+} __attribute__ ((__packed__));
+
+struct key {
+ __u32 k2_dir_id;
+ __u32 k2_objectid;
+
+ union {
+ struct offset_v1 k2_offset_v1;
+ struct offset_v2 k2_offset_v2;
+ } __attribute__ ((__packed__)) u;
+
+} __attribute__ ((__packed__));
+
+#define get_key_dirid(k) get_le32 (k, k2_dir_id)
+#define set_key_dirid(k,val) set_le32 (k, k2_dir_id, val)
+
+#define get_key_objectid(k) get_le32 (k, k2_objectid)
+#define set_key_objectid(k,val) set_le32 (k, k2_objectid, val)
+
+#define get_key_offset_v1(k) get_le32 (k, u.k2_offset_v1.k_offset)
+#define set_key_offset_v1(k,val) set_le32 (k, u.k2_offset_v1.k_offset, val)
+
+#define get_key_uniqueness(k) get_le32 (k, u.k2_offset_v1.k_uniqueness)
+#define set_key_uniqueness(k,val) set_le32 (k, u.k2_offset_v1.k_uniqueness,
val)
+
+#define KEY_SIZE (sizeof(struct key))
+#define SHORT_KEY_SIZE (sizeof(__u32) + sizeof(__u32))
+
+#define UNFM_P_SIZE sizeof(__u32)
+#define I_UNFM_NUM(p_s_ih) (get_ih_item_len(p_s_ih) / UNFM_P_SIZE)
+
+struct item_head {
+ struct key ih_key;
+
+ union {
+ __u16 ih2_free_space;
+ __u16 ih2_entry_count;
+ } __attribute__ ((__packed__)) u;
+
+ __u16 ih2_item_len;
+ __u16 ih2_item_location;
+ __u16 ih_version;
+} __attribute__ ((__packed__));
+
+#define IH_SIZE (sizeof(struct item_head))
+
+#define get_ih_entry_count(ih) get_le16 (ih, u.ih2_entry_count)
+#define set_ih_entry_count(ih,val) set_le16 (ih, u.ih2_entry_count, val)
+
+#define get_ih_free_space(ih) get_le16 (ih, u.ih2_free_space)
+#define set_ih_free_space(ih,val) set_le16 (ih, u.ih2_free_space, 0)
+
+#define get_ih_item_len(ih) get_le16 (ih, ih2_item_len)
+#define set_ih_item_len(ih,val) set_le16 (ih, ih2_item_len, val)
+
+#define get_ih_location(ih) get_le16 (ih, ih2_item_location)
+#define set_ih_location(ih,val) set_le16 (ih, ih2_item_location, val)
+
+#define ih_version(ih) get_le16(ih, ih_version)
+
+#define ITEM_VERSION_1 0
+#define ITEM_VERSION_2 1
+
+struct stat_data_v1 {
+ __u16 sd_mode;
+ __u16 sd_nlink;
+ __u16 sd_uid;
+ __u16 sd_gid;
+ __u32 sd_size;
+ __u32 sd_atime;
+ __u32 sd_mtime;
+ __u32 sd_ctime;
+
+ union {
+ __u32 sd_rdev;
+ __u32 sd_blocks;
+ } __attribute__ ((__packed__)) u;
+ __u32 sd_first_direct_byte;
+} __attribute__ ((__packed__));
+
+#define SD_V1_SIZE (sizeof(struct stat_data_v1))
+
+/*
+ This is used to check sd_size of stat data v1
+*/
+#define MAX_FILE_SIZE_V1 0x7fffffff
+
+#define NO_BYTES_IN_DIRECT_ITEM 0xffffffff
+
+/*
+ Stat Data on disk (reiserfs version of UFS disk inode minus the
+ address blocks)
+*/
+struct stat_data {
+ __u16 sd_mode;
+ __u16 sd_attrs;
+ __u32 sd_nlink;
+ __u64 sd_size;
+ __u32 sd_uid;
+ __u32 sd_gid;
+ __u32 sd_atime;
+ __u32 sd_mtime;
+ __u32 sd_ctime;
+ __u32 sd_blocks;
+ union {
+ __u32 sd_rdev;
+ } __attribute__ ((__packed__)) u;
+} __attribute__ ((__packed__));
+
+#define SD_SIZE (sizeof(struct stat_data))
+
+#define stat_data_v1(ih) (get_ih_key_format (ih) == KEY_FORMAT_1)
+
+#define SD_OFFSET 0
+#define DOT_OFFSET 1
+#define DOT_DOT_OFFSET 2
+
+struct journal_params {
+ __u32 jp_journal_1st_block;
+ __u32 jp_journal_dev;
+ __u32 jp_journal_size;
+ __u32 jp_journal_trans_max;
+ __u32 jp_journal_block_count;
+ __u32 jp_journal_max_batch;
+ __u32 jp_journal_max_commit_age;
+ __u32 jp_journal_max_trans_age;
+};
+
+struct reiserfs_journal_header {
+ __u32 jh_last_flush_trans_id;
+ __u32 jh_first_unflushed_offset;
+ __u32 jh_mount_id;
+ struct journal_params jh_journal;
+ __u32 jh_max_trans_age;
+};
+
+#define get_jp_journal_1st_block(jp) get_le32 (jp, jp_journal_1st_block)
+#define set_jp_journal_1st_block(jp,val) set_le32 (jp, jp_journal_1st_block,
val)
+
+#define get_jp_journal_dev(jp) get_le32 (jp, jp_journal_dev)
+#define set_jp_journal_dev(jp,val) set_le32 (jp, jp_journal_dev, val)
+
+#define get_jp_journal_size(jp) get_le32 (jp, jp_journal_size)
+#define set_jp_journal_size(jp,val) set_le32 (jp, jp_journal_size, val)
+
+#define get_jp_journal_max_trans_len(jp) get_le32 (jp, jp_journal_trans_max)
+#define set_jp_journal_max_trans_len(jp,val) set_le32 (jp,
jp_journal_trans_max, val)
+
+#define get_jp_journal_magic(jp) get_le32 (jp, jp_journal_magic)
+#define set_jp_journal_magic(jp,val) set_le32 (jp, jp_journal_magic, val)
+
+#define get_jp_journal_max_batch(jp) get_le32 (jp, jp_journal_max_batch)
+#define set_jp_journal_max_batch(jp,val) set_le32 (jp, jp_journal_max_batch,
val)
+
+#define get_jp_journal_max_commit_age(jp) get_le32 (jp,
jp_journal_max_commit_age)
+#define set_jp_journal_max_commit_age(jp,val) set_le32 (jp,
jp_journal_max_commit_age, val)
+
+#define get_jh_mount_id(jh) get_le32 (jh, jh_mount_id)
+#define set_jh_mount_id(jh,val) set_le32 (jh, jh_mount_id, val)
+
+#define get_jh_last_flushed(jh) get_le32 (jh, jh_last_flush_trans_id)
+#define set_jh_last_flushed(jh,val) set_le32 (jh, jh_last_flush_trans_id, val)
+
+#define get_jh_replay_start_offset(jh) get_le32 (jh, jh_first_unflushed_offset)
+#define set_jh_replay_start_offset(jh,val) set_le32 (jh,
jh_first_unflushed_offset, val)
+
+#define get_jh_max_trans_age(jh) get_le32 (jh, jh_max_trans_age)
+#define set_jh_max_trans_age(jh,val) set_le32 (jh, jh_max_trans_age, val)
+
+#define bh_desc(bh) ((struct reiserfs_journal_desc *)((bh)->b_data))
+#define bh_commit(bh) ((struct reiserfs_journal_commit *)((bh)->b_data))
+
+/*
+ Disk child pointer. The pointer from an internal node of the tree
+ to a node that is on disk.
+*/
+struct disk_child {
+ __u32 dc2_block_number;
+ __u16 dc2_size;
+ __u16 dc2_reserved;
+};
+
+#define DC_SIZE (sizeof(struct disk_child))
+
+#define get_dc_child_blocknr(dc) get_le32 (dc, dc2_block_number)
+#define set_dc_child_blocknr(dc,val) set_le32 (dc, dc2_block_number, val)
+
+#define get_dc_child_size(dc) get_le16 (dc, dc2_size)
+#define set_dc_child_size(dc,val) set_le16 (dc, dc2_size, val)
+
+struct reiserfs_super_block_v1 {
+ __u32 sb_block_count;
+ __u32 sb_free_blocks;
+ __u32 sb_root_block;
+
+ struct journal_params sb_journal;
+
+// __u32 sb_mountid;
+ __u16 sb_blocksize;
+ __u16 sb_oid_maxsize;
+ __u16 sb_oid_cursize;
+ __u16 sb_state;
+ char s_magic[10];
+ __u16 sb_fsck_state;
+ __u32 sb_hash_function_code;
+ __u16 sb_tree_height;
+ __u16 sb_bmap_nr;
+ __u16 sb_version;
+ __u16 sb_reserved_for_journal;
+} __attribute__ ((__packed__));
+
+#define SB_SIZE_V1 (sizeof(struct reiserfs_super_block_v1))
+#define sb_jp(sb) (&((sb)->s_v1.sb_journal))
+
+/*
+ Structure of super block on disk
+*/
+struct reiserfs_super_block {
+ struct reiserfs_super_block_v1 s_v1;
+ char sb_mnt_version[16];
+ char sb_mkfs_version[16];
+ char sb_fsck_version[16];
+ char sb_unused[204-16-16-16-SB_SIZE_V1];
+};
+
+#define SB_SIZE (sizeof(struct reiserfs_super_block))
+
+#define get_sb_block_count(sb) get_le32 (sb, s_v1.sb_block_count)
+#define set_sb_block_count(sb,val) set_le32 (sb, s_v1.sb_block_count, val)
+
+#define get_sb_free_blocks(sb) get_le32 (sb, s_v1.sb_free_blocks)
+#define set_sb_free_blocks(sb,val) set_le32 (sb, s_v1.sb_free_blocks, val)
+
+#define get_sb_root_block(sb) get_le32 (sb,s_v1.sb_root_block)
+#define set_sb_root_block(sb,val) set_le32 (sb, s_v1.sb_root_block, val)
+
+#define get_sb_mount_id(sb) get_le32 (sb,s_v1.sb_mountid)
+#define set_sb_mount_id(sb,val) set_le32 (sb, s_v1.sb_mountid, val)
+
+#define get_sb_block_size(sb) get_le16 (sb, s_v1.sb_blocksize)
+#define set_sb_block_size(sb,val) set_le16 (sb, s_v1.sb_blocksize, val)
+
+#define get_sb_oid_maxsize(sb) get_le16 (sb, s_v1.sb_oid_maxsize)
+#define set_sb_oid_maxsize(sb,val) set_le16 (sb, s_v1.sb_oid_maxsize, val)
+
+#define get_sb_oid_cursize(sb) get_le16 (sb, s_v1.sb_oid_cursize)
+#define set_sb_oid_cursize(sb,val) set_le16 (sb, s_v1.sb_oid_cursize, val)
+
+#define get_sb_state(sb) get_le16 (sb, s_v1.sb_state)
+#define set_sb_state(sb,val) set_le16 (sb, s_v1.sb_state, val)
+
+#define get_sb_fsck_state(sb) get_le16 (sb, s_v1.sb_fsck_state)
+#define set_sb_fsck_state(sb,val) set_le16 (sb, s_v1.sb_fsck_state, val)
+
+#define get_sb_hash_code(sb) get_le32 (sb, s_v1.sb_hash_function_code)
+#define set_sb_hash_code(sb,val) set_le32 (sb, s_v1.sb_hash_function_code, val)
+
+#define get_sb_tree_height(sb) get_le16 (sb, s_v1.sb_tree_height)
+#define set_sb_tree_height(sb,val) set_le16 (sb, s_v1.sb_tree_height, val)
+
+#define get_sb_bmap_nr(sb) get_le16 (sb, s_v1.sb_bmap_nr)
+#define set_sb_bmap_nr(sb,val) set_le16 (sb, s_v1.sb_bmap_nr, val)
+
+#define get_sb_version(sb) get_le16 (sb, s_v1.sb_version)
+#define set_sb_version(sb,val) set_le16 (sb, s_v1.sb_version, val)
+
+#define get_sb_reserved_for_journal(sb) get_le16 (sb,
s_v1.sb_reserved_for_journal)
+#define set_sb_reserved_for_journal(sb,val) set_le16 (sb,
s_v1.sb_reserved_for_journal, val)
+
+#define journal_is_relocated(sb) get_jp_journal_dev(sb_jp (sb))
+
+struct reiserfs_bm {
+ size_t bm_byte_size;
+ reiserfs_blk_t bm_bit_size;
+ reiserfs_blk_t bm_set_bits;
+ char *bm_map;
+};
+
+typedef struct reiserfs_bm reiserfs_bm_t;
+
+struct reiserfs_fs {
+ size_t fs_blocksize;
+ int fs_version;
+ struct buffer_head *fs_super_bh;
+ struct reiserfs_super_block *fs_ondisk_sb;
+
+ reiserfs_bm_t *fs_bitmap2;
+ struct buffer_head *fs_jh_bh;
+
+ struct reiserfs_io_handler *io_handler;
+};
+
+typedef struct reiserfs_fs reiserfs_fs_t;
+
+struct reiserfs_de_head {
+ __u32 deh2_offset;
+ __u32 deh2_dir_id;
+ __u32 deh2_objectid;
+ __u16 deh2_location;
+ __u16 deh2_state;
+} __attribute__ ((__packed__));
+
+#define DEH_SIZE sizeof(struct reiserfs_de_head)
+
+#define EMPTY_DIR_SIZE \
+ (DEH_SIZE * 2 + ROUND_UP (strlen (".")) + ROUND_UP (strlen ("..")))
+
+/*
+ Old format directories have this size when empty
+*/
+#define EMPTY_DIR_SIZE_V1 (DEH_SIZE * 2 + 3)
+
+#define get_deh_offset(deh) get_le32 (deh, deh2_offset)
+#define set_deh_offset(deh,val) set_le32 (deh, deh2_offset, val)
+
+#define get_deh_dirid(deh) get_le32 (deh, deh2_dir_id)
+#define set_deh_dirid(deh,val) set_le32 (deh, deh2_dir_id, val)
+
+#define get_deh_objectid(deh) get_le32 (deh, deh2_objectid)
+#define set_deh_objectid(deh,val) set_le32 (deh, deh2_objectid, val)
+
+#define get_deh_location(deh) get_le16 (deh, deh2_location)
+#define set_deh_location(deh,val) set_le16 (deh, deh2_location, val)
+
+#define get_deh_state(deh) get_le16 (deh, deh2_state)
+#define set_deh_state(deh,val) set_le16 (deh, deh2_state, val)
+
+#define DEH_Visible 2
+
+#define mark_de_visible(deh) \
+ set_bit(DEH_Visible, &((deh)->deh2_state))
+
+#define B_I_DEH(bh,ih) \
+ ((struct reiserfs_de_head *)(B_I_PITEM(bh,ih)))
+
+#define REISERFS_MAX_NAME_LEN(block_size) \
+ (block_size - BLKH_SIZE - IH_SIZE - DEH_SIZE)
+
+typedef enum {
+ REISERFS_FS_VALID = 1,
+ REISERFS_FS_INVALID = 2,
+ REISERFS_FS_CONSISTENT = 0xfaa0
+} reiserfs_state_t;
+
+extern reiserfs_fs_t *_reiserfs_fs_open (struct reiserfs_io_handler
*io_handler);
+extern reiserfs_fs_t *_reiserfs_fs_create (struct reiserfs_io_handler
*io_handler,
+ size_t block_size, reiserfs_blk_t journal_blocks, reiserfs_blk_t blocks);
+extern void _reiserfs_fs_close (reiserfs_fs_t *fs);
+extern int _reiserfs_fs_resize(reiserfs_fs_t *fs, reiserfs_blk_t blocks);
+
+extern int _reiserfs_fs_is_consistent (reiserfs_fs_t *fs);
+extern int _reiserfs_fs_is_found (reiserfs_fs_t *fs);
+extern int _reiserfs_bm_is_spread(reiserfs_fs_t *fs);
+
+#endif
diff -rupN ./parted-1.4.22/libparted/fs_reiserfs/reiserfs_io.c
./parted-reiserfs-1.4.22/libparted/fs_reiserfs/reiserfs_io.c
--- ./parted-1.4.22/libparted/fs_reiserfs/reiserfs_io.c Thu Jan 1 03:00:00 1970
+++ ./parted-reiserfs-1.4.22/libparted/fs_reiserfs/reiserfs_io.c Sat Jan
12 22:02:03 2002
@@ -0,0 +1,80 @@
+/*
+ reiserfs_io.c -- parted device i/o abstraction code
+ Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/*
+ Writen by Yury Umanets (address@hidden)
+*/
+
+static const char _reiserfs_io_c[] = "$Id: reiserfs_io.c,v 1.55 2002/01/04
20:15:19 yumanets Exp $";
+
+#include <parted/parted.h>
+
+#include "reiserfs_io.h"
+
+static reiserfs_blk_t _reiserfs_blocks(struct reiserfs_io_handler *io_handler,
+ size_t block_size)
+{
+ reiserfs_blk_t k = block_size / PED_SECTOR_SIZE;
+ return (io_handler->geom->length) / k;
+}
+
+static int _reiserfs_read(struct reiserfs_io_handler *io_handler, void *buff,
+ reiserfs_blk_t block, reiserfs_blk_t count, size_t block_size)
+{
+ reiserfs_blk_t k = block_size / PED_SECTOR_SIZE;
+ PedSector block_pos = (PedSector)(block*k);
+ PedSector block_count = (PedSector)(count*k);
+
+ return ped_geometry_read(io_handler->geom, buff, block_pos, block_count);
+}
+
+static int _reiserfs_write(struct reiserfs_io_handler *io_handler, void *buff,
+ reiserfs_blk_t block, reiserfs_blk_t count, size_t block_size)
+{
+ reiserfs_blk_t k = block_size / PED_SECTOR_SIZE;
+ PedSector block_pos = (PedSector)(block*k);
+ PedSector block_count = (PedSector)(count*k);
+
+ return ped_geometry_write((PedGeometry *)io_handler->geom, buff,
block_pos, block_count);
+}
+
+static int _reiserfs_sync(struct reiserfs_io_handler *io_handler) {
+ return ped_geometry_sync((PedGeometry *)io_handler->geom);
+}
+
+static struct reiserfs_io_ops ops = {
+ blocks: _reiserfs_blocks,
+ read: _reiserfs_read,
+ write: _reiserfs_write,
+ sync: _reiserfs_sync
+};
+
+struct reiserfs_io_handler *reiserfs_io_handler_create(const PedGeometry
*geom) {
+ struct reiserfs_io_handler *io_handler =
+ (struct reiserfs_io_handler *)ped_malloc(sizeof(*io_handler));
+
+ io_handler->ops = &ops;
+ io_handler->geom = geom;
+
+ return io_handler;
+}
+
+void reiserfs_io_handler_destroy(struct reiserfs_io_handler *io_handler) {
+ ped_free(io_handler);
+}
diff -rupN ./parted-1.4.22/libparted/fs_reiserfs/reiserfs_io.h
./parted-reiserfs-1.4.22/libparted/fs_reiserfs/reiserfs_io.h
--- ./parted-1.4.22/libparted/fs_reiserfs/reiserfs_io.h Thu Jan 1 03:00:00 1970
+++ ./parted-reiserfs-1.4.22/libparted/fs_reiserfs/reiserfs_io.h Sat Jan
12 22:00:41 2002
@@ -0,0 +1,54 @@
+/*
+ reiserfs_io.h -- parted device i/o abstraction code
+ Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/*
+ Writen by Yury Umanets (address@hidden)
+*/
+
+
+#ifndef REISERFS_IO_H
+#define REISERFS_IO_H
+
+static const char _reiserfs_io_h[] = "$Id: reiserfs_io.h,v 1.55 2002/01/04
20:16:19 yumanets Exp $";
+
+#include <parted/parted.h>
+
+#include "reiserfs_blk.h"
+
+struct reiserfs_io_handler;
+
+struct reiserfs_io_ops {
+ reiserfs_blk_t (*blocks)(struct reiserfs_io_handler *io_handler,
+ size_t block_size);
+ int (*read)(struct reiserfs_io_handler *io_handler, void *buff,
+ reiserfs_blk_t block, reiserfs_blk_t count, size_t block_size);
+ int (*write)(struct reiserfs_io_handler *io_handler, void *buff,
+ reiserfs_blk_t block, reiserfs_blk_t count, size_t block_size);
+ int (*sync)(struct reiserfs_io_handler *io_handler);
+};
+
+struct reiserfs_io_handler {
+ const PedGeometry *geom;
+ struct reiserfs_io_ops *ops;
+};
+
+extern struct reiserfs_io_handler *reiserfs_io_handler_create(const
PedGeometry *geom);
+extern void reiserfs_io_handler_destroy(struct reiserfs_io_handler
*io_handler);
+
+#endif
diff -rupN ./parted-1.4.22/libparted/fs_reiserfs/reiserfs_tools.c
./parted-reiserfs-1.4.22/libparted/fs_reiserfs/reiserfs_tools.c
--- ./parted-1.4.22/libparted/fs_reiserfs/reiserfs_tools.c Thu Jan 1
03:00:00 1970
+++ ./parted-reiserfs-1.4.22/libparted/fs_reiserfs/reiserfs_tools.c Sat Jan
12 18:25:27 2002
@@ -0,0 +1,261 @@
+/*
+ reiserfs_tools.c -- reiserfs tools
+ Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/*
+ Some parts of this code are from original reiserfs code,
+ as found in the reiserfs-progs-3.x.0k-pre10.
+ Writen by Yury Umanets (address@hidden)
+*/
+
+static const char _reiserfs_tools_c[] = "$Id: reiserfs_tools.c,v 1.55
2002/01/04 20:17:19 yumanets Exp $";
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <parted/parted.h>
+#include <parted/endian.h>
+
+#include "reiserfs_tools.h"
+
+#if ENABLE_NLS
+# include <libintl.h>
+# define _(String) dgettext (PACKAGE, String)
+#else
+# define _(String) (String)
+#endif
+
+/* Bits manipulations and endianess functions */
+static inline int le_set_bit (int nr, void * addr) {
+ __u8 * p, mask;
+ int retval;
+
+ p = (__u8 *)addr;
+ p += nr >> 3;
+ mask = 1 << (nr & 0x7);
+ /*cli();*/
+ retval = (mask & *p) != 0;
+ *p |= mask;
+ /*sti();*/
+ return retval;
+}
+
+static inline int le_clear_bit (int nr, void * addr) {
+ __u8 * p, mask;
+ int retval;
+
+ p = (__u8 *)addr;
+ p += nr >> 3;
+ mask = 1 << (nr & 0x7);
+ /*cli();*/
+ retval = (mask & *p) != 0;
+ *p &= ~mask;
+ /*sti();*/
+ return retval;
+}
+
+static inline int le_test_bit(int nr, const void * addr) {
+ __u8 * p, mask;
+
+ p = (__u8 *)addr;
+ p += nr >> 3;
+ mask = 1 << (nr & 0x7);
+ return ((mask & *p) != 0);
+}
+
+static inline int le_find_first_zero_bit (const void *vaddr, unsigned size) {
+ const __u8 *p = vaddr, *addr = vaddr;
+ int res;
+
+ if (!size)
+ return 0;
+
+ size = (size >> 3) + ((size & 0x7) > 0);
+ while (*p++ == 255) {
+ if (--size == 0)
+ return (p - addr) << 3;
+ }
+
+ --p;
+ for (res = 0; res < 8; res++)
+ if (!test_bit (res, p))
+ break;
+ return (p - addr) * 8 + res;
+}
+
+static inline int le_find_next_zero_bit (const void *vaddr, unsigned size,
unsigned offset) {
+ const __u8 *addr = vaddr;
+ const __u8 *p = addr + (offset >> 3);
+ int bit = offset & 7, res;
+
+ if (offset >= size)
+ return size;
+
+ if (bit) {
+ /* Look for zero in first char */
+ for (res = bit; res < 8; res++)
+ if (!test_bit (res, p))
+ return (p - addr) * 8 + res;
+ p++;
+ }
+ /* No zero yet, search remaining full bytes for a zero */
+ res = find_first_zero_bit (p, size - 8 * (p - addr));
+ return (p - addr) * 8 + res;
+}
+
+static inline int be_set_bit (int nr, void * addr) {
+ __u8 mask = 1 << (nr & 0x7);
+ __u8 *p = (__u8 *) addr + (nr >> 3);
+ __u8 old = *p;
+
+ *p |= mask;
+
+ return (old & mask) != 0;
+}
+
+static inline int be_clear_bit (int nr, void * addr) {
+ __u8 mask = 1 << (nr & 0x07);
+ __u8 *p = (unsigned char *) addr + (nr >> 3);
+ __u8 old = *p;
+
+ *p = *p & ~mask;
+ return (old & mask) != 0;
+}
+
+static inline int be_test_bit(int nr, const void * addr) {
+ const __u8 *ADDR = (__const__ __u8 *) addr;
+
+ return ((ADDR[nr >> 3] >> (nr & 0x7)) & 1) != 0;
+}
+
+static inline int be_find_first_zero_bit (const void *vaddr, unsigned size) {
+ return find_next_zero_bit( vaddr, size, 0 );
+}
+
+static inline unsigned long ffz(unsigned long word) {
+ unsigned long result = 0;
+
+ while(word & 1) {
+ result++;
+ word >>= 1;
+ }
+ return result;
+}
+
+/* stolen from linux/include/asm-mips/bitops.h:ext2_find_next_zero_bit()
+ * the bitfield is assumed to be little endian, which is the case here,
+ * since we're reading/writing from the disk in LE order */
+static inline int be_find_next_zero_bit (const void *vaddr, unsigned size,
unsigned offset) {
+ __u32 *p = ((__u32 *) vaddr) + (offset >> 5);
+ __u32 result = offset & ~31UL;
+ __u32 tmp;
+
+ if (offset >= size)
+ return size;
+ size -= result;
+ offset &= 31UL;
+ if (offset) {
+ tmp = *(p++);
+ tmp |= PED_SWAP32(~0UL >> (32-offset));
+ if (size < 32)
+ goto found_first;
+ if (~tmp)
+ goto found_middle;
+ size -= 32;
+ result += 32;
+ }
+ while (size & ~31UL) {
+ if (~(tmp = *(p++)))
+ goto found_middle;
+ result += 32;
+ size -= 32;
+ }
+ if (!size)
+ return result;
+ tmp = *p;
+
+found_first:
+// return result + ffz(swab32(tmp) | (~0UL << size));
+ return result + ffz(PED_SWAP32(tmp) | (~0UL << size));
+found_middle:
+// return result + ffz(swab32(tmp));
+ return result + ffz(PED_SWAP32(tmp));
+}
+
+inline int set_bit (int nr, void * addr) {
+#ifndef WORDS_BIGENDIAN
+ return le_set_bit( nr, addr );
+#else
+ return be_set_bit( nr, addr );
+#endif
+ return 0;
+}
+
+inline int clear_bit (int nr, void * addr) {
+#ifndef WORDS_BIGENDIAN
+ return le_clear_bit( nr, addr );
+#else
+ return be_clear_bit( nr, addr );
+#endif
+ return 0;
+}
+
+inline int test_bit(int nr, const void * addr) {
+#ifndef WORDS_BIGENDIAN
+ return le_test_bit( nr, addr );
+#else
+ return be_test_bit( nr, addr );
+#endif
+ return 0;
+}
+
+inline int find_first_zero_bit (const void *vaddr, unsigned size) {
+#ifndef WORDS_BIGENDIAN
+ return le_find_first_zero_bit( vaddr, size );
+#else
+ return be_find_first_zero_bit( vaddr, size );
+#endif
+ return 0;
+}
+
+inline int find_next_zero_bit (const void *vaddr, unsigned size, unsigned
offset) {
+#ifndef WORDS_BIGENDIAN
+ return le_find_next_zero_bit( vaddr, size, offset );
+#else
+ return be_find_next_zero_bit( vaddr, size, offset );
+#endif
+ return 0;
+}
+
+/* Signature checking functions */
+int is_reiserfs_3_5_magic_string (const char *s_magic) {
+ return (!strncmp (s_magic, REISERFS_SUPER_MAGIC_STRING,
+ strlen (REISERFS_SUPER_MAGIC_STRING)));
+}
+
+int is_reiserfs_3_6_magic_string (const char *s_magic) {
+ return (!strncmp (s_magic, REISER2FS_SUPER_MAGIC_STRING,
+ strlen (REISER2FS_SUPER_MAGIC_STRING)));
+}
+
+int is_any_reiserfs_magic_string (const char *s_magic) {
+ if (is_reiserfs_3_5_magic_string (s_magic) ||
+ is_reiserfs_3_6_magic_string (s_magic))
+ return 1;
+ return 0;
+}
diff -rupN ./parted-1.4.22/libparted/fs_reiserfs/reiserfs_tools.h
./parted-reiserfs-1.4.22/libparted/fs_reiserfs/reiserfs_tools.h
--- ./parted-1.4.22/libparted/fs_reiserfs/reiserfs_tools.h Thu Jan 1
03:00:00 1970
+++ ./parted-reiserfs-1.4.22/libparted/fs_reiserfs/reiserfs_tools.h Sat Jan
12 18:25:27 2002
@@ -0,0 +1,45 @@
+/*
+ reiserfs_tools.h -- reiserfs tools
+ Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/*
+ Some parts of this code are from original reiserfs code,
+ as found in the reiserfs-progs-3.x.0k-pre10.
+ Writen by Yury Umanets (address@hidden)
+*/
+
+#ifndef REISERFS_TOOLS_H
+#define REISERFS_TOOLS_H
+
+static const char _reiserfs_tools_h[] = "$Id: reiserfs_tools.h,v 1.55
2002/01/04 20:19:21 yumanets Exp $";
+
+extern inline int set_bit (int nr, void *addr);
+extern inline int clear_bit (int nr, void *addr);
+extern inline int test_bit(int nr, const void *addr);
+extern inline int find_first_zero_bit (const void *vaddr, unsigned size);
+extern inline int find_next_zero_bit (const void *vaddr, unsigned size,
unsigned offset);
+
+/* Signatures checking function */
+#define REISERFS_SUPER_MAGIC_STRING "ReIsErFs"
+#define REISER2FS_SUPER_MAGIC_STRING "ReIsEr2Fs"
+
+extern int is_reiserfs_3_5_magic_string (const char *s_magic);
+extern int is_reiserfs_3_6_magic_string (const char *s_magic);
+extern int is_any_reiserfs_magic_string (const char *s_magic);
+
+#endif
diff -rupN ./parted-1.4.22/po/ru.po ./parted-reiserfs-1.4.22/po/ru.po
--- ./parted-1.4.22/po/ru.po Sun Dec 30 02:55:37 2001
+++ ./parted-reiserfs-1.4.22/po/ru.po Sat Jan 12 21:42:28 2002
@@ -103,12 +103,12 @@ msgstr "ped_device_new() îÅÐÏÄÄÅÒÖÉ×ÁÅÍ
#: libparted/device.c:825
#, c-format
msgid "Error opening %s: %s"
-msgstr ""
+msgstr "ïÛÉÂËÁ ÐÒÉ ÏÔËÒÙÔÉÉ %s: %s"
#: libparted/device.c:835
#, c-format
msgid "Unable to open %s read-write (%s). %s has been opened read-only."
-msgstr ""
+msgstr "îÅ ÍÏÇÕ ÏÔËÒÙÔØ %s ÎÁ ÞÔÅÎÉÅ-ÚÁÐÉÓØ (%s). %s ÏÔËÒÙÔ ÎÁ ÞÔÅÎÉÅ"
#: libparted/device.c:878
msgid ""
@@ -119,6 +119,12 @@ msgid ""
"rescue disk, and reinstall your boot loader from the rescue disk. Read "
"section 4 of the Parted User documentation for more information."
msgstr ""
+"ñÄÒÏ ÓÉÓÔÅÍÙ ÎÅ ÓÍÏÇÌÏ ÐÅÒÅÞÉÔÁÔØ ÔÁÂÌÉÃÕ ÒÁÚÄÅÌÏ×. üÔÏ ÚÎÁÞÉÔ, ÞÔÏ ×ÁÍ
ÎÅÏÂÈÏÄÉÍÏ "
+"ÐÅÒÅÚÁÇÒÕÚÉÔØ ×ÁÛ ËÏÍÐØÀÔÅÒ ÐÅÒÅÄ ÔÅÍ ËÁË ÐÏÄÌÀÞÁÔØ ËÁËÉÅ-ÌÉÂÏ
ÍÏÄÉÆÉÃÉÒÏ×ÁÎÎÙÅ ÒÁÚÄÅÌÙ. "
+"÷ÁÍ ÔÁËÖÅ ÎÅÏÂÈÏÄÉÍÏ ÐÅÒÅÉÎÓÔÁÌÉÒÏ×ÁÔØ ÚÁÇÒÕÚÞÉË ÓÉÓÔÅÍÙ ÐÅÒÅÄ ÔÅÍ ËÁË ×Ù
ÐÅÒÅÇÒÕÚÉÔÅ "
+"×ÁÛ ËÏÍÐØÀÔÅÒ (ÜÔÏ ÍÏÖÅÔ ÐÏÔÒÅÂÏ×ÁÔØ ÐÏÄËÌÀÞÅÎÉÑ ÍÏÄÉÆÉÃÉÒÏ×ÁÎÎÙÈ ÒÁÚÄÅÌÏ×).
îÅ×ÏÚÍÏÖÎÏ "
+"ÓÄÅÌÁÔØ É ÔÏ É ÄÒÕÇÏÅ ÏÄÎÏ×ÒÅÍÅÎÎÏ, ÐÏÜÔÏÍÕ ÎÁÉÂÏÌÅÅ ÐÒÁ×ÉÌØÎÏ ÂÙÌÏ ÂÙ
ÐÅÒÅÉÎÓÔÁÌÉÒÏ×ÁÔØ "
+"ÚÁÇÒÕÚÞÉË ÚÁÇÚÕÚÉ×ÛÉÓØ ÉÚ Á×ÁÒÉÊÎÏÇÏ ÄÉÓËÁ. óÍÏÔÒÉÔÅ ÓÅËÃÉÀ 4 × Parted User
ÄÏËÕÍÅÎÔÁÃÉÉ."
#: libparted/device.c:895
#, c-format
@@ -136,6 +142,8 @@ msgid ""
"You should reinstall your boot loader before rebooting. Read section 4 of "
"the Parted User documentation for more information."
msgstr ""
+"÷ÁÍ ÓÌÅÄÕÅÔ ÐÅÒÅÉÎÓÔÁÌÉÒÏ×ÁÔØ ×ÁÛ ÓÉÓÔÅÍÎÙÊ ÚÁÇÒÕÚÞÉË ÐÅÒÅÄ ÐÅÒÅÇÒÕÚËÏÊ
ËÏÍÐØÀÔÅÒÁ. "
+"óÍÏÔÒÉÔÅ ÓÅËÃÉÀ 4 × Parted User ÄÏËÕÍÅÎÔÁÃÉÉ."
#: libparted/device.c:1006 libparted/device.c:1112
#, c-format
@@ -232,24 +240,28 @@ msgid ""
"have the correct BIOS geometry. It is safe to ignore,but ignoring may cause "
"(fixable) problems with some boot loaders."
msgstr ""
+"îÅ ÍÏÇÕ ËÏÒÒÅËÔÎÏ ×ÙÒÏ×ÎÑÔØ ÒÁÚÄÅÌ. üÔÏ ÍÏÖÅÔ ÏÚÎÁÞÁÔØ, ÞÔÏ ÄÒÕÇÁÑ ÐÒÏÇÒÁÍÍÁ
ÓÆÏÒÍÉÒÏ×ÁÌÁ "
+"ÎÅËÏÒÅÔÎÕÀ ÔÁÂÌÉÃÕ ÒÁÚÄÅÌÏ×, ÐÏÔÏÍÕ ÞÔÏ ÏÎÁ ÎÅ ÉÍÅÅÔ ËÏÒÒÅÔÎÙÈ
BIOS-ÐÁÒÁÍÅÔÒÏ×. üÔÏ ÓÏÏÂÝÅÎÉÅ "
+"ÍÏÖÎÏ ÐÒÏÉÇÎÏÒÉÒÏ×ÁÔØ, ÎÏ ÜÔÏ ÍÏÖÅÔ ÐÒÉ×ÅÓÔÉ Ë (ÕÓÔÒÁÎÉÍÙÍ) ÐÒÏÂÌÅÍÁÍ Ó
ÎÅËÏÔÏÒÙÍÉ ÓÉÓÔÅÍÎÙÊÍÉ "
+"ÚÁÇÒÕÚÞÉËÁÍÉ."
#: libparted/disk_gpt.c:520
msgid "GUID Partition Table Header Signature is wrong: "
-msgstr ""
+msgstr "GUID Partition Table Header Signature ÎÅ ×ÅÒÎÁ: "
#: libparted/disk_gpt.c:521
msgid " should be "
-msgstr ""
+msgstr " ÄÏÌÖÅÎ ÂÙÔØ "
#: libparted/disk_gpt.c:534
#, c-format
msgid "GPT Header CRC check failed, %x should be %x."
-msgstr ""
+msgstr "GPT Header CRC ÐÒÏ×ÅÒËÁ ÎÅ ÕÄÁÌÁÓØ, %x ÄÏÌÖÅÎ ÂÙÔØ %x."
#: libparted/disk_gpt.c:562
#, c-format
msgid "GPT Partition Entry Array CRC check failed, %x should be %x."
-msgstr ""
+msgstr "GPT Partition Entry Array CRC ÐÒÏ×ÅÒËÁ ÎÅ ÕÄÁÌÁÓØ, %x ÄÏÌÖÅÎ ÂÙÔØ %x."
#: libparted/disk_gpt.c:841
msgid ""
@@ -262,6 +274,14 @@ msgid ""
"No will assume that the MBR is correct, and erase the GPT information.\n"
"Ignore will assume that the MBR is correct, but not change the disk."
msgstr ""
+"üÔÏÔ ÄÉÓË ÓÏÄÅÒÖÉÔ ËÏÒÒÅËÔÎÕÀ Primary É Alternate GUID Partition Table
ÔÁÂÌÉÃÙ ÎÏ "
+"Protective MBR ÎÅËÏÒÒÅËÔÅÎ. üÔÏ ÍÏÖÅÔ ÏÚÎÁÞÁÔØ, ÞÔÏ ÄÉÓË ÉÍÅÅÔ GPT ÒÁÚÄÅÌÙ,
ÎÏ ÂÙÌÁ "
+"ÐÒÉÍÅÎÅÎÁ ÓÔÁÒÁÑ ÐÒÏÇÒÁÍÍÁ ÄÌÑ ÒÁÚÂÉ×ËÉ ÄÉÓËÁ, ËÏÔÏÒÁÑ ÓÏÈÒÁÎÉÌÁ ÔÁÂÌÉÃÕ
ÒÁÚÄÅÌÏ× × MBR "
+"×ÉÄÅ.\n"
+"ëÁËÉÅ ÄÁÎÎÙÅ Ñ×ÌÑÀÔÓÑ ÐÒÁ×ÉÌØÎÙÍÉ?\n"
+"õÔ×ÅÒÄÉÔÅÌØÎÙÊ ÏÔ×ÅÔ ÂÕÄÅÔ ÏÚÎÁÞÁÔØ, ÞÔÏ ×Ù ×ÙÂÒÁÌÉ GPT É ÐÅÒÅÚÁÐÉÓØ PMBR.\n"
+"ïÔÒÉÃÁÔÅÌØÎÙÊ - ×ÙÂÏÒ MBR É ÕÄÁÌÅÎÉÅ GPT.\n"
+"éÇÎÏÒÉÒÏ×ÁÎÉÅ ÖÅ ÂÕÄÅÔ ÚÎÁÞÉÔØ, ÞÔÏ MBR ËÏÒÒÅËÔÅÎ É ÎÉËÁËÉÈ ÉÚÍÅÎÅÎÉÊ ÓÄÅÌÁÎÏ
ÎÅ ÂÕÄÅÔ."
#: libparted/disk_gpt.c:855
msgid ""
@@ -275,6 +295,13 @@ msgid ""
"No will assume that the MBR is correct, and erase the GPT information.\n"
"Ignore will assume that the MBR is correct, but not change the disk."
msgstr ""
+"üÔÏÔ ÄÉÓË ÓÏÄÅÒÖÉÔ ËÏÒÒÅËÔÎÕÀ Alternate GUID Partition Table ÔÁÂÌÉÃÕ, ÎÏ
Primary "
+"GPT É Protective MBR ÎÅËÏÒÒÅËÔÎÙ. üÔÏ ÏÚÎÁÞÁÅÔ, ÞÔÏ ÄÉÓË ÉÍÅÅÔ GPT, ÎÏ ÄÌÑ
ÅÇÏ ÒÁÚÂÉ×ËÉ "
+"ÉÓÐÏÌØÚÏ×ÁÌÁÓØ ÓÔÁÒÁÑ ÐÒÏÇÒÁÍÍÁ, ËÏÔÏÒÁÑ ÓÏÈÒÁÎÉÌÁ ÔÁÂÌÉÃÕ ÒÁÚÄÅÌÏ× × MBR
ÆÏÒÍÁÔÅ.\n"
+"ëÁËÉÅ ÄÁÎÎÙÅ ËÏÒÒÅËÔÎÙ? GPT ÉÌÉ MBR?\n"
+"õÔ×ÅÒÄÉÔÅÌØÎÙÊ ÏÔ×ÅÔ ÂÕÄÅÔ ÏÚÎÁÞÁÔØ, ÞÔÏ ×Ù ×ÙÂÒÁÌÉ GPT É ÐÅÒÅÚÁÐÉÓØ PMBR É
Primary GPT.\n"
+"ïÔÒÉÃÁÔÅÌØÎÙÊ - ×ÙÂÏÒ MBR É ÕÄÁÌÅÎÉÅ GPT.\n"
+"éÇÎÏÒÉÒÏ×ÁÎÉÅ ÖÅ ÂÕÄÅÔ ÚÎÁÞÉÔØ, ÞÔÏ MBR ËÏÒÒÅËÔÅÎ É ÎÉËÁËÉÈ ÉÚÍÅÎÅÎÉÊ ÓÄÅÌÁÎÏ
ÎÅ ÂÕÄÅÔ."
#: libparted/disk_gpt.c:871
msgid ""
@@ -288,6 +315,13 @@ msgid ""
"No will assume that the MBR is correct, and erase the GPT information.\n"
"Ignore will assume that the MBR is correct, but not change the disk.\n"
msgstr ""
+"üÔÏÔ ÄÉÓË ÓÏÄÅÒÖÉÔ ËÏÒÒÅËÔÎÕÀ Partition Table ÔÁÂÌÉÃÕ, ÎÏ Alternate "
+"GPT É Protective MBR ÎÅËÏÒÒÅËÔÎÙ. üÔÏ ÏÚÎÁÞÁÅÔ, ÞÔÏ ÄÉÓË ÉÍÅÅÔ GPT ÒÁÚÄÅÌÙ,
ÎÏ ÄÌÑ ÅÇÏ "
+"ÒÁÚÂÉ×ËÉ ÉÓÐÏÌØÚÏ×ÁÌÁÓØ ÓÔÁÒÁÑ ÐÒÏÇÒÁÍÍÁ, ËÏÔÏÒÁÑ ÓÏÈÒÁÎÉÌÁ ÔÁÂÌÉÃÕ ÒÁÚÄÅÌÏ×
× MBR ÆÏÒÍÁÔÅ.\n"
+"ëÁËÉÅ ÄÁÎÎÙÅ ËÏÒÒÅËÔÎÙ? GPT ÉÌÉ MBR?\n"
+"õÔ×ÅÒÄÉÔÅÌØÎÙÊ ÏÔ×ÅÔ ÂÕÄÅÔ ÏÚÎÁÞÁÔØ, ÞÔÏ ×Ù ×ÙÂÒÁÌÉ GPT É ÐÅÒÅÚÁÐÉÓØ PMBR É
Alternate GPT.\n"
+"ïÔÒÉÃÁÔÅÌØÎÙÊ - ×ÙÂÏÒ MBR É ÕÄÁÌÅÎÉÅ GPT.\n"
+"éÇÎÏÒÉÒÏ×ÁÎÉÅ ÖÅ ÂÕÄÅÔ ÚÎÁÞÉÔØ, ÞÔÏ MBR ËÏÒÒÅËÔÅÎ É ÎÉËÁËÉÈ ÉÚÍÅÎÅÎÉÊ ÓÄÅÌÁÎÏ
ÎÅ ÂÕÄÅÔ.\n"
#: libparted/disk.c:1362 libparted/disk_gpt.c:1393
msgid "The new partition overlaps with another partition."
@@ -296,26 +330,26 @@ msgstr "îÏ×ÙÊ ÒÁÚÄÅÌ ÐÅÒÅËÒÙ×ÁÅÔÓÑ Ó ÄÒÕ
#: libparted/disk_mac.c:209
#, c-format
msgid "Invalid signature %x for Mac disk labels."
-msgstr ""
+msgstr "îÅËÏÒÒÅÔÎÁÑ ÓÉÇÎÁÔÕÒÁ %x ÄÌÑ Mac disk labels."
#: libparted/disk_mac.c:257
#, c-format
msgid "%s is too small for a Mac disk label!"
-msgstr ""
+msgstr "%s ÓÌÉÛËÏÍ ÍÁÌÅÎØËÉÊ ÄÌÑ Mac disk label!"
#: libparted/disk_mac.c:321
msgid "Partition map has no partition map entry!"
-msgstr ""
+msgstr "ëÁÒÔÁ ÒÁÚÄÅÌÏ× ÎÅ ÉÍÅÅÔ ÜÌÅÍÅÎÔÏ×!"
#: libparted/disk_mac.c:540
#, c-format
msgid "Partition %d has an invalid signature %x."
-msgstr ""
+msgstr "òÁÚÄÅÌ %d ÉÍÅÅÔ ÎÅËÏÒÒÅËÔÎÕÀ ÓÉÇÎÁÔÕÒÕ %x."
#: libparted/disk_mac.c:556
#, c-format
msgid "Partition %d has an invalid length of 0 bytes!"
-msgstr ""
+msgstr "òÁÚÄÅÌ %d ÉÍÅÅÔ ÎÅËÏÒÒÅËÔÎÕÀ ÄÌÉÎÕ × 0 ÂÁÊÔ!"
#: libparted/disk_mac.c:581
#, fuzzy
@@ -467,6 +501,10 @@ msgid ""
"either shrink the partition you are trying to copy, or copy to a bigger "
"partition."
msgstr ""
+"ëÏÐÉÒÏ×ÁÎÉÅ ÆÁÊÌÏ×ÏÊ ÓÉÓÔÅÍÙ ÅÝÅ ÎÅ ÒÅÁÌÉÚÏ×ÁÎÏ ÄÌÑ %s. "
+"ïÄÎÁËÏ, ÉÚÍÅÎÅÎÉÅ ÚÁÒÍÅÒÏ× ÒÅÁÌÉÚÏ×ÁÎÏ. ôÁËÉÍ ÏÂÒÁÚÏÍ, ÆÁÊÌÏ×ÁÑ ÓÉÓÔÅÍÁ ÍÏÖÅÔ
"
+"ÂÙÔØ ÓËÏÐÉÒÏ×ÁÎÁ ÅÓÌÉ ÎÏ×ÙÊ ÒÁÚÄÅÌ ÂÏÌØÛÅ ÞÅÍ ÓÔÁÒÙÊ. ôÁË ÞÔÏ ×Ù ÍÏÖÅÔÅ
ÕÍÅÎØÛÉÔØ "
+"ÔÏÔ ÒÁÚÄÅÌ, ËÏÔÏÒÙÊ ×Ù ÐÙÔÁÅÔÅÓØ ÓËÏÐÉÒÏ×ÁÔØ ÉÌÉ ÓËÏÐÉÒÏ×ÁÔØ ÅÇÏ ÎÁ ÂÏÌØÛÉÊ
ÒÁÚÄÅÌ."
#: libparted/filesys.c:366
#, fuzzy, c-format
@@ -487,7 +525,7 @@ msgstr "îÅÔ get_min_size() ÄÌÑ %s!"
#: libparted/disk.c:745 libparted/filesys.c:422
#, c-format
msgid "The %s file system code doesn't support %s disk labels."
-msgstr ""
+msgstr "ëÏÄ ÆÁÊÌÏ×ÏÊ ÓÉÓÔÅÍÙ %s ÎÅ ÐÏÄÄÅÒÖÉ×ÁÅÔ %s ÍÅÔËÉ ÄÉÓËÁ."
#: libparted/disk.c:136
#, c-format
@@ -621,7 +659,7 @@ msgstr ""
#: libparted/disk.c:1817
#, c-format
msgid "Unknown flag partition flag, %d."
-msgstr ""
+msgstr "îÅÉÚ×ÅÓÔÎÙÊ ÆÌÁÇ ÒÁÚÄÅÌÁ %d."
#: libparted/exception.c:45
msgid "Information"
@@ -940,7 +978,7 @@ msgstr "ïÛÉÂËÁ ÚÁÐÉÓÉ × ËÏÒÎÅ×ÏÊ ËÁÔÁÌÏÇ
#: libparted/fs_fat/resize.c:445
msgid "If leave your file system as FAT16, then you will have no problems."
-msgstr ""
+msgstr "åÓÌÉ ÏÓÔÁ×ÉÔØ ×ÁÛÕ ÆÁÊÌÏ×ÕÀ ÓÉÓÔÅÍÕ ËÁË FAT16, ×Ù ÎÅ ÂÕÄÅÔÅ ÉÍÅÔØ
ÎÉËÁËÉÈ ÎÅÐÒÉÑÔÎÏÓÔÅÊ."
#: libparted/fs_fat/resize.c:448
msgid ""
@@ -948,12 +986,16 @@ msgid ""
"you must re-install the MS Windows boot loader. If you want to do this, you "
"should consult the Parted manual (or your distribution's manual)."
msgstr ""
+"åÓÌÉ ×Ù ÐÒÅÏÂÒÁÚÕÅÔÅ × FAT16 É MS Windows ÕÓÔÁÎÏ×ÌÅÎÁ ÎÁ ÜÔÏÍ ÒÁÚÄÅÌÅ, ÔÏ "
+"×Ù ÄÏÌÖÎÙ ÐÅÒÅÉÎÓÔÁÌÉÒÏ×ÁÔØ ÓÉÓÔÅÍÎÙÊ ÚÁÇÒÕÚÞÉË MS Windows. åÓÌÉ ×Ù ÈÏÔÉÔÅ
ÓÄÅÌÁÔØ ÜÔÏ "
+"×Ù ÄÏÌÖÎÙ ÏÚÎÁËÏÍÉÔØÓÑ Ó Parted ÄÏËÕÍÅÎÔÁÃÉÅÊ (ÉÌÉ ÄÏËÕÍÅÎÔÁÃÉÅÊ ÉÚ ÎÁÂÏÒÁ
×ÁÛÅÇÏ ÄÉÓÔÒÉÂÕÔÉ×Á)."
#: libparted/fs_fat/resize.c:456
msgid ""
"If you leave your file system as FAT32, then you will not introduce any new "
"problems."
msgstr ""
+"åÓÌÉ ×Ù ÏÓÔÁ×ÉÔÅ ÎÁ ×ÁÛÅÊ ÆÁÊÌÏ×ÏÊ ÓÉÓÔÅÍÅ FAT32, ×Ù ÎÅ ÂÕÄÅÔÅ ÉÍÅÔØ
ÎÅÐÒÉÑÔÎÏÓÔÅÊ."
#: libparted/fs_fat/resize.c:460
msgid ""
@@ -963,6 +1005,11 @@ msgid ""
"converting to FAT32 will make the file system unreadable by MS DOS, MS "
"Windows 95a, and MS Windows NT."
msgstr ""
+"åÓÌÉ ×Ù ÐÒÅÏÂÒÁÚÕÅÔÅ × FAT32 É MS Windows ÕÓÔÁÎÏ×ÌÅÎÁ ÎÁ ÜÔÏÍ ÒÁÚÄÅÌÅ, ÔÏ "
+"×Ù ÄÏÌÖÎÙ ÐÅÒÅÉÎÓÔÁÌÉÒÏ×ÁÔØ ÓÉÓÔÅÍÎÙÊ ÚÁÇÒÕÚÞÉË MS Windows. åÓÌÉ ×Ù ÈÏÔÉÔÅ
ÓÄÅÌÁÔØ ÜÔÏ "
+"×Ù ÄÏÌÖÎÙ ÏÚÎÁËÏÍÉÔØÓÑ Ó Parted ÄÏËÕÍÅÎÔÁÃÉÅÊ (ÉÌÉ ÄÏËÕÍÅÎÔÁÃÉÅÊ ÉÚ ÎÁÂÏÒÁ
×ÁÛÅÇÏ ÄÉÓÔÒÉÂÕÔÉ×Á). "
+"ðÏÓÌÅ ÐÒÅÏÂÒÁÚÏ×ÁÎÉÑ ÆÁÊÌÏ×ÏÊ ÓÉÓÔÅÍÙ × FAT32, MS DOS, MS Windows 95a, É
×ÏÚÍÏÖÎÏ MS Windows NT "
+"ÎÅ ÓÍÏÇÕÔ Ó ÎÅÊ ÒÁÂÏÔÁÔØ."
#: libparted/fs_fat/resize.c:474
#, c-format
@@ -971,7 +1018,7 @@ msgstr ""
#: libparted/fs_fat/resize.c:475
msgid "Would you like to use FAT32?"
-msgstr ""
+msgstr "èÏÔÉÔÅ ÌÉ ×Ù ÉÓÐÏÌØÚÏ×ÁÔØ FAT32?"
#: libparted/fs_fat/resize.c:502 libparted/fs_fat/resize.c:518
#, c-format
@@ -982,11 +1029,13 @@ msgstr ""
msgid ""
"The file system can only be resized to this size by converting to FAT16."
msgstr ""
+"òÁÚÍÅÒ ÆÁÊÌÏ×ÏÊ ÓÉÓÔÅÍÙ ÍÏÖÅÔ ÂÙÔØ ÉÚÍÅÎÅÎ ÄÏ ÜÔÏÊ ×ÅÌÉÞÉÎÙ ÐÒÉ ËÏÎ×ÅÒÔÁÃÉÉ ×
FAT16."
#: libparted/fs_fat/resize.c:519
msgid ""
"The file system can only be resized to this size by converting to FAT32."
msgstr ""
+"òÁÚÍÅÒ ÆÁÊÌÏ×ÏÊ ÓÉÓÔÅÍÙ ÍÏÖÅÔ ÂÙÔØ ÉÚÍÅÎÅÎ ÄÏ ÜÔÏÊ ×ÅÌÉÞÉÎÙ ÐÒÉ ËÏÎ×ÅÒÔÁÃÉÉ ×
FAT32."
#: libparted/fs_fat/resize.c:532
msgid ""
@@ -1110,7 +1159,7 @@ msgstr "ïÛÉÂËÁ × FAT: ËÌÁÓÔÅÒ %d ÉÍÅÅÔ Ó
#: libparted/fs_fat/count.c:195
#, c-format
msgid "%s is %dk, but it has is %d clusters (%dk)."
-msgstr ""
+msgstr "%s %dk, ÎÏ ÏÎ ÉÍÅÅÔ %d ËÌÁÓÔÅÒÏ× (%dk)."
#: libparted/fs_fat/table.c:136
#, c-format
@@ -1295,6 +1344,8 @@ msgid ""
"You requested to create a partition at %.3f-%.3fMb. The closest Parted can "
"manage is %.3f-%.3fMb."
msgstr ""
+"÷Ù ÈÏÔÉÔÅ ÓÏÚÄÁÔØ ÒÁÚÄÅÌ ÄÉÓËÁ ÒÁÚÍÅÒÁÍÉ %.3f-%.3fMb. Parted ÍÏÖÅÔ ÕÐÒÁ×ÌÑÔØ
ÏÂÌÁÓÔØÀ "
+"%.3f-%.3fMb"
#: parted/parted.c:619
#, fuzzy
@@ -1314,6 +1365,8 @@ msgid ""
"You requested to move the partition to %.3f-%.3fMb. The closest Parted can "
"manage is %.3f-%.3fMb."
msgstr ""
+"÷Ù ÈÏÔÉÔÅ ÐÅÒÅÍÅÓÔÉÔØ ÒÁÚÄÅÌ ÄÉÓËÁ × %.3f-%.3fMb. Parted ÍÏÖÅÔ ÕÐÒÁ×ÌÑÔØ
ÏÂÌÁÓÔØÀ "
+"%.3f-%.3fMb"
#: parted/parted.c:752
#, fuzzy, c-format
@@ -1323,15 +1376,15 @@ msgstr "çÅÏÍÅÔÒÉÑ ÄÉÓËÁ: 1-%d, %dk ÃÉÌÉÎ
#: parted/parted.c:755
#, c-format
msgid "Disk label type: %s\n"
-msgstr ""
+msgstr "Disk label ÔÉÐ: %s\n"
#: parted/parted.c:762
msgid "Minor Start End "
-msgstr ""
+msgstr "îÏÍÅÒ îÁÞÁÌÏ ëÏÎÅà "
#: parted/parted.c:764
msgid "Type "
-msgstr ""
+msgstr "ôÉÐ "
#: parted/parted.c:765
#, fuzzy
@@ -1340,11 +1393,11 @@ msgstr "æÁÊÌÏ×ÁÑ ÓÉÓÔÅÍÁ ÐÏÌÎÁ!"
#: parted/parted.c:767
msgid "Name "
-msgstr ""
+msgstr "éÍÑ "
#: parted/parted.c:768
msgid "Flags"
-msgstr ""
+msgstr "æÌÁÇÉ"
#: parted/parted.c:884
#, c-format
@@ -1352,6 +1405,8 @@ msgid ""
"You requested to resize the partition to %.3f-%.3fMb. The closest Parted can "
"manage is %.3f-%.3fMb."
msgstr ""
+"÷Ù ÈÏÔÉÔÅ ÉÚÍÅÎÉÔØ ÚÁÚÍÅÒÙ ÒÁÚÄÅÌÁ ÎÁ %.3f-%.3fMb. Parted ÍÏÖÅÔ ÕÐÒÁ×ÌÑÔØ
ÏÂÌÁÓÔØÀ "
+"%.3f-%.3fMb"
#: parted/parted.c:1086
msgid "check"
@@ -1493,7 +1548,7 @@ msgstr ""
#: parted/parted.c:1207
msgid "select DEVICE choose the device to edit"
-msgstr ""
+msgstr "select õóôòïêóô÷ï ×ÙÂÒÁÔØ ÕÓÔÒÏÊÓÔ×Ï ÄÌÑ
ÒÅÄÁËÔÉÒÏ×ÁÎÉÑ"
#: parted/parted.c:1212
msgid "set"
- ReiserFS support patch,
Yura Umanets <=