GitHub-Mirror/linux-bl808
2
0
Fork 0
mirror of https://github.com/Fishwaldo/linux-bl808.git synced 2025-06-17 20:25:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

reiserfs: run scripts/Lindent on reiserfs code

Browse source 
This was a pure indentation change, using:

	scripts/Lindent fs/reiserfs/*.c include/linux/reiserfs_*.h

to make reiserfs match the regular Linux indentation style.  As Jeff
Mahoney <jeffm@suse.com> writes:

 The ReiserFS code is a mix of a number of different coding styles, sometimes
 different even from line-to-line. Since the code has been relatively stable
 for quite some time and there are few outstanding patches to be applied, it
 is time to reformat the code to conform to the Linux style standard outlined
 in Documentation/CodingStyle.

 This patch contains the result of running scripts/Lindent against
 fs/reiserfs/*.c and include/linux/reiserfs_*.h. There are places where the
 code can be made to look better, but I'd rather keep those patches separate
 so that there isn't a subtle by-hand hand accident in the middle of a huge
 patch. To be clear: This patch is reformatting *only*.

 A number of patches may follow that continue to make the code more consistent
 with the Linux coding style.

 Hans wasn't particularly enthusiastic about these patches, but said he
 wouldn't really oppose them either.

Signed-off-by: Linus Torvalds <torvalds@osdl.org>
This commit is contained in:
Linus Torvalds 2005-07-12 20:21:28 -07:00
parent 7fa94c8868
commit bd4c625c06
30 changed files with 23428 additions and 21662 deletions
Download patch file Download diff file Expand all files Collapse all files

606
fs/reiserfs/bitmap.c
View file

File diff suppressed because it is too large Load diff

184
fs/reiserfs/dir.c
View file

@ -14,8 +14,9 @@
extern struct reiserfs_key MIN_KEY; extern struct reiserfs_key MIN_KEY;
static int reiserfs_readdir (struct file *, void *, filldir_t); static int reiserfs_readdir(struct file *, void *, filldir_t);
static int reiserfs_dir_fsync(struct file *filp, struct dentry *dentry, int datasync) ; static int reiserfs_dir_fsync(struct file *filp, struct dentry *dentry,
int datasync);
struct file_operations reiserfs_dir_operations = { struct file_operations reiserfs_dir_operations = {
.read = generic_read_dir, .read = generic_read_dir,
@ -24,54 +25,58 @@ struct file_operations reiserfs_dir_operations = {
.ioctl = reiserfs_ioctl, .ioctl = reiserfs_ioctl,
}; };
static int reiserfs_dir_fsync(struct file *filp, struct dentry *dentry, int datasync) { static int reiserfs_dir_fsync(struct file *filp, struct dentry *dentry,
int datasync)
{
struct inode *inode = dentry->d_inode; struct inode *inode = dentry->d_inode;
int err; int err;
reiserfs_write_lock(inode->i_sb); reiserfs_write_lock(inode->i_sb);
err = reiserfs_commit_for_inode(inode) ; err = reiserfs_commit_for_inode(inode);
reiserfs_write_unlock(inode->i_sb) ; reiserfs_write_unlock(inode->i_sb);
if (err < 0) if (err < 0)
return err; return err;
return 0; return 0;
} }
#define store_ih(where,what) copy_item_head (where, what) #define store_ih(where,what) copy_item_head (where, what)
// //
static int reiserfs_readdir (struct file * filp, void * dirent, filldir_t filldir) static int reiserfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
{ {
struct inode *inode = filp->f_dentry->d_inode; struct inode *inode = filp->f_dentry->d_inode;
struct cpu_key pos_key; /* key of current position in the directory (key of directory entry) */ struct cpu_key pos_key; /* key of current position in the directory (key of directory entry) */
INITIALIZE_PATH (path_to_entry); INITIALIZE_PATH(path_to_entry);
struct buffer_head * bh; struct buffer_head *bh;
int item_num, entry_num; int item_num, entry_num;
const struct reiserfs_key * rkey; const struct reiserfs_key *rkey;
struct item_head * ih, tmp_ih; struct item_head *ih, tmp_ih;
int search_res; int search_res;
char * local_buf; char *local_buf;
loff_t next_pos; loff_t next_pos;
char small_buf[32] ; /* avoid kmalloc if we can */ char small_buf[32]; /* avoid kmalloc if we can */
struct reiserfs_dir_entry de; struct reiserfs_dir_entry de;
int ret = 0; int ret = 0;
reiserfs_write_lock(inode->i_sb); reiserfs_write_lock(inode->i_sb);
reiserfs_check_lock_depth(inode->i_sb, "readdir") ; reiserfs_check_lock_depth(inode->i_sb, "readdir");
/* form key for search the next directory entry using f_pos field of /* form key for search the next directory entry using f_pos field of
file structure */ file structure */
make_cpu_key (&pos_key, inode, (filp->f_pos) ? (filp->f_pos) : DOT_OFFSET, make_cpu_key(&pos_key, inode,
TYPE_DIRENTRY, 3); (filp->f_pos) ? (filp->f_pos) : DOT_OFFSET, TYPE_DIRENTRY,
next_pos = cpu_key_k_offset (&pos_key); 3);
next_pos = cpu_key_k_offset(&pos_key);
/* reiserfs_warning (inode->i_sb, "reiserfs_readdir 1: f_pos = %Ld", filp->f_pos);*/ /* reiserfs_warning (inode->i_sb, "reiserfs_readdir 1: f_pos = %Ld", filp->f_pos); */
path_to_entry.reada = PATH_READA; path_to_entry.reada = PATH_READA;
while (1) { while (1) {
research: research:
/* search the directory item, containing entry with specified key */ /* search the directory item, containing entry with specified key */
search_res = search_by_entry_key (inode->i_sb, &pos_key, &path_to_entry, &de); search_res =
search_by_entry_key(inode->i_sb, &pos_key, &path_to_entry,
&de);
if (search_res == IO_ERROR) { if (search_res == IO_ERROR) {
// FIXME: we could just skip part of directory which could // FIXME: we could just skip part of directory which could
// not be read // not be read
@ -82,68 +87,81 @@ static int reiserfs_readdir (struct file * filp, void * dirent, filldir_t filldi
bh = de.de_bh; bh = de.de_bh;
item_num = de.de_item_num; item_num = de.de_item_num;
ih = de.de_ih; ih = de.de_ih;
store_ih (&tmp_ih, ih); store_ih(&tmp_ih, ih);
/* we must have found item, that is item of this directory, */ /* we must have found item, that is item of this directory, */
RFALSE( COMP_SHORT_KEYS (&(ih->ih_key), &pos_key), RFALSE(COMP_SHORT_KEYS(&(ih->ih_key), &pos_key),
"vs-9000: found item %h does not match to dir we readdir %K", "vs-9000: found item %h does not match to dir we readdir %K",
ih, &pos_key); ih, &pos_key);
RFALSE( item_num > B_NR_ITEMS (bh) - 1, RFALSE(item_num > B_NR_ITEMS(bh) - 1,
"vs-9005 item_num == %d, item amount == %d", "vs-9005 item_num == %d, item amount == %d",
item_num, B_NR_ITEMS (bh)); item_num, B_NR_ITEMS(bh));
/* and entry must be not more than number of entries in the item */ /* and entry must be not more than number of entries in the item */
RFALSE( I_ENTRY_COUNT (ih) < entry_num, RFALSE(I_ENTRY_COUNT(ih) < entry_num,
"vs-9010: entry number is too big %d (%d)", "vs-9010: entry number is too big %d (%d)",
entry_num, I_ENTRY_COUNT (ih)); entry_num, I_ENTRY_COUNT(ih));
if (search_res == POSITION_FOUND || entry_num < I_ENTRY_COUNT (ih)) { if (search_res == POSITION_FOUND
|| entry_num < I_ENTRY_COUNT(ih)) {
/* go through all entries in the directory item beginning from the entry, that has been found */ /* go through all entries in the directory item beginning from the entry, that has been found */
struct reiserfs_de_head * deh = B_I_DEH (bh, ih) + entry_num; struct reiserfs_de_head *deh =
B_I_DEH(bh, ih) + entry_num;
for (; entry_num < I_ENTRY_COUNT (ih); entry_num ++, deh ++) { for (; entry_num < I_ENTRY_COUNT(ih);
entry_num++, deh++) {
int d_reclen; int d_reclen;
char * d_name; char *d_name;
off_t d_off; off_t d_off;
ino_t d_ino; ino_t d_ino;
if (!de_visible (deh)) if (!de_visible(deh))
/* it is hidden entry */ /* it is hidden entry */
continue; continue;
d_reclen = entry_length (bh, ih, entry_num); d_reclen = entry_length(bh, ih, entry_num);
d_name = B_I_DEH_ENTRY_FILE_NAME (bh, ih, deh); d_name = B_I_DEH_ENTRY_FILE_NAME(bh, ih, deh);
if (!d_name[d_reclen - 1]) if (!d_name[d_reclen - 1])
d_reclen = strlen (d_name); d_reclen = strlen(d_name);
if (d_reclen > REISERFS_MAX_NAME(inode->i_sb->s_blocksize)){ if (d_reclen >
REISERFS_MAX_NAME(inode->i_sb->
s_blocksize)) {
/* too big to send back to VFS */ /* too big to send back to VFS */
continue ; continue;
} }
/* Ignore the .reiserfs_priv entry */ /* Ignore the .reiserfs_priv entry */
if (reiserfs_xattrs (inode->i_sb) && if (reiserfs_xattrs(inode->i_sb) &&
!old_format_only(inode->i_sb) && !old_format_only(inode->i_sb) &&
filp->f_dentry == inode->i_sb->s_root && filp->f_dentry == inode->i_sb->s_root &&
REISERFS_SB(inode->i_sb)->priv_root && REISERFS_SB(inode->i_sb)->priv_root &&
REISERFS_SB(inode->i_sb)->priv_root->d_inode && REISERFS_SB(inode->i_sb)->priv_root->d_inode
deh_objectid(deh) == le32_to_cpu (INODE_PKEY(REISERFS_SB(inode->i_sb)->priv_root->d_inode)->k_objectid)) { && deh_objectid(deh) ==
le32_to_cpu(INODE_PKEY
(REISERFS_SB(inode->i_sb)->
priv_root->d_inode)->
k_objectid)) {
continue; continue;
} }
d_off = deh_offset (deh); d_off = deh_offset(deh);
filp->f_pos = d_off ; filp->f_pos = d_off;
d_ino = deh_objectid (deh); d_ino = deh_objectid(deh);
if (d_reclen <= 32) { if (d_reclen <= 32) {
local_buf = small_buf ; local_buf = small_buf;
} else { } else {
local_buf = reiserfs_kmalloc(d_reclen, GFP_NOFS, inode->i_sb) ; local_buf =
reiserfs_kmalloc(d_reclen, GFP_NOFS,
inode->i_sb);
if (!local_buf) { if (!local_buf) {
pathrelse (&path_to_entry); pathrelse(&path_to_entry);
ret = -ENOMEM ; ret = -ENOMEM;
goto out; goto out;
} }
if (item_moved (&tmp_ih, &path_to_entry)) { if (item_moved(&tmp_ih, &path_to_entry)) {
reiserfs_kfree(local_buf, d_reclen, inode->i_sb) ; reiserfs_kfree(local_buf,
d_reclen,
inode->i_sb);
goto research; goto research;
} }
} }
@ -151,56 +169,59 @@ static int reiserfs_readdir (struct file * filp, void * dirent, filldir_t filldi
// buffer (local_buf) because filldir will block if // buffer (local_buf) because filldir will block if
// user space buffer is swapped out. At that time // user space buffer is swapped out. At that time
// entry can move to somewhere else // entry can move to somewhere else
memcpy (local_buf, d_name, d_reclen); memcpy(local_buf, d_name, d_reclen);
if (filldir (dirent, local_buf, d_reclen, d_off, d_ino, if (filldir
(dirent, local_buf, d_reclen, d_off, d_ino,
DT_UNKNOWN) < 0) { DT_UNKNOWN) < 0) {
if (local_buf != small_buf) { if (local_buf != small_buf) {
reiserfs_kfree(local_buf, d_reclen, inode->i_sb) ; reiserfs_kfree(local_buf,
d_reclen,
inode->i_sb);
} }
goto end; goto end;
} }
if (local_buf != small_buf) { if (local_buf != small_buf) {
reiserfs_kfree(local_buf, d_reclen, inode->i_sb) ; reiserfs_kfree(local_buf, d_reclen,
inode->i_sb);
} }
// next entry should be looked for with such offset // next entry should be looked for with such offset
next_pos = deh_offset (deh) + 1; next_pos = deh_offset(deh) + 1;
if (item_moved (&tmp_ih, &path_to_entry)) { if (item_moved(&tmp_ih, &path_to_entry)) {
goto research; goto research;
} }
} /* for */ } /* for */
} }
if (item_num != B_NR_ITEMS (bh) - 1) if (item_num != B_NR_ITEMS(bh) - 1)
// end of directory has been reached // end of directory has been reached
goto end; goto end;
/* item we went through is last item of node. Using right /* item we went through is last item of node. Using right
delimiting key check is it directory end */ delimiting key check is it directory end */
rkey = get_rkey (&path_to_entry, inode->i_sb); rkey = get_rkey(&path_to_entry, inode->i_sb);
if (! comp_le_keys (rkey, &MIN_KEY)) { if (!comp_le_keys(rkey, &MIN_KEY)) {
/* set pos_key to key, that is the smallest and greater /* set pos_key to key, that is the smallest and greater
that key of the last entry in the item */ that key of the last entry in the item */
set_cpu_key_k_offset (&pos_key, next_pos); set_cpu_key_k_offset(&pos_key, next_pos);
continue; continue;
} }
if ( COMP_SHORT_KEYS (rkey, &pos_key)) { if (COMP_SHORT_KEYS(rkey, &pos_key)) {
// end of directory has been reached // end of directory has been reached
goto end; goto end;
} }
/* directory continues in the right neighboring block */ /* directory continues in the right neighboring block */
set_cpu_key_k_offset (&pos_key, le_key_k_offset (KEY_FORMAT_3_5, rkey)); set_cpu_key_k_offset(&pos_key,
le_key_k_offset(KEY_FORMAT_3_5, rkey));
} /* while */ } /* while */
end: end:
filp->f_pos = next_pos; filp->f_pos = next_pos;
pathrelse (&path_to_entry); pathrelse(&path_to_entry);
reiserfs_check_path(&path_to_entry) ; reiserfs_check_path(&path_to_entry);
out: out:
reiserfs_write_unlock(inode->i_sb); reiserfs_write_unlock(inode->i_sb);
return ret; return ret;
@ -209,67 +230,68 @@ static int reiserfs_readdir (struct file * filp, void * dirent, filldir_t filldi
/* compose directory item containing "." and ".." entries (entries are /* compose directory item containing "." and ".." entries (entries are
not aligned to 4 byte boundary) */ not aligned to 4 byte boundary) */
/* the last four params are LE */ /* the last four params are LE */
void make_empty_dir_item_v1 (char * body, __le32 dirid, __le32 objid, void make_empty_dir_item_v1(char *body, __le32 dirid, __le32 objid,
__le32 par_dirid, __le32 par_objid) __le32 par_dirid, __le32 par_objid)
{ {
struct reiserfs_de_head * deh; struct reiserfs_de_head *deh;
memset (body, 0, EMPTY_DIR_SIZE_V1); memset(body, 0, EMPTY_DIR_SIZE_V1);
deh = (struct reiserfs_de_head *)body; deh = (struct reiserfs_de_head *)body;
/* direntry header of "." */ /* direntry header of "." */
put_deh_offset( &(deh[0]), DOT_OFFSET ); put_deh_offset(&(deh[0]), DOT_OFFSET);
/* these two are from make_le_item_head, and are are LE */ /* these two are from make_le_item_head, and are are LE */
deh[0].deh_dir_id = dirid; deh[0].deh_dir_id = dirid;
deh[0].deh_objectid = objid; deh[0].deh_objectid = objid;
deh[0].deh_state = 0; /* Endian safe if 0 */ deh[0].deh_state = 0; /* Endian safe if 0 */
put_deh_location( &(deh[0]), EMPTY_DIR_SIZE_V1 - strlen( "." )); put_deh_location(&(deh[0]), EMPTY_DIR_SIZE_V1 - strlen("."));
mark_de_visible(&(deh[0])); mark_de_visible(&(deh[0]));
/* direntry header of ".." */ /* direntry header of ".." */
put_deh_offset( &(deh[1]), DOT_DOT_OFFSET); put_deh_offset(&(deh[1]), DOT_DOT_OFFSET);
/* key of ".." for the root directory */ /* key of ".." for the root directory */
/* these two are from the inode, and are are LE */ /* these two are from the inode, and are are LE */
deh[1].deh_dir_id = par_dirid; deh[1].deh_dir_id = par_dirid;
deh[1].deh_objectid = par_objid; deh[1].deh_objectid = par_objid;
deh[1].deh_state = 0; /* Endian safe if 0 */ deh[1].deh_state = 0; /* Endian safe if 0 */
put_deh_location( &(deh[1]), deh_location( &(deh[0]) ) - strlen( ".." ) ); put_deh_location(&(deh[1]), deh_location(&(deh[0])) - strlen(".."));
mark_de_visible(&(deh[1])); mark_de_visible(&(deh[1]));
/* copy ".." and "." */ /* copy ".." and "." */
memcpy (body + deh_location( &(deh[0]) ), ".", 1); memcpy(body + deh_location(&(deh[0])), ".", 1);
memcpy (body + deh_location( &(deh[1]) ), "..", 2); memcpy(body + deh_location(&(deh[1])), "..", 2);
} }
/* compose directory item containing "." and ".." entries */ /* compose directory item containing "." and ".." entries */
void make_empty_dir_item (char * body, __le32 dirid, __le32 objid, void make_empty_dir_item(char *body, __le32 dirid, __le32 objid,
__le32 par_dirid, __le32 par_objid) __le32 par_dirid, __le32 par_objid)
{ {
struct reiserfs_de_head * deh; struct reiserfs_de_head *deh;
memset (body, 0, EMPTY_DIR_SIZE); memset(body, 0, EMPTY_DIR_SIZE);
deh = (struct reiserfs_de_head *)body; deh = (struct reiserfs_de_head *)body;
/* direntry header of "." */ /* direntry header of "." */
put_deh_offset( &(deh[0]), DOT_OFFSET ); put_deh_offset(&(deh[0]), DOT_OFFSET);
/* these two are from make_le_item_head, and are are LE */ /* these two are from make_le_item_head, and are are LE */
deh[0].deh_dir_id = dirid; deh[0].deh_dir_id = dirid;
deh[0].deh_objectid = objid; deh[0].deh_objectid = objid;
deh[0].deh_state = 0; /* Endian safe if 0 */ deh[0].deh_state = 0; /* Endian safe if 0 */
put_deh_location( &(deh[0]), EMPTY_DIR_SIZE - ROUND_UP( strlen( "." ) ) ); put_deh_location(&(deh[0]), EMPTY_DIR_SIZE - ROUND_UP(strlen(".")));
mark_de_visible(&(deh[0])); mark_de_visible(&(deh[0]));
/* direntry header of ".." */ /* direntry header of ".." */
put_deh_offset( &(deh[1]), DOT_DOT_OFFSET ); put_deh_offset(&(deh[1]), DOT_DOT_OFFSET);
/* key of ".." for the root directory */ /* key of ".." for the root directory */
/* these two are from the inode, and are are LE */ /* these two are from the inode, and are are LE */
deh[1].deh_dir_id = par_dirid; deh[1].deh_dir_id = par_dirid;
deh[1].deh_objectid = par_objid; deh[1].deh_objectid = par_objid;
deh[1].deh_state = 0; /* Endian safe if 0 */ deh[1].deh_state = 0; /* Endian safe if 0 */
put_deh_location( &(deh[1]), deh_location( &(deh[0])) - ROUND_UP( strlen( ".." ) ) ); put_deh_location(&(deh[1]),
deh_location(&(deh[0])) - ROUND_UP(strlen("..")));
mark_de_visible(&(deh[1])); mark_de_visible(&(deh[1]));
/* copy ".." and "." */ /* copy ".." and "." */
memcpy (body + deh_location( &(deh[0]) ), ".", 1); memcpy(body + deh_location(&(deh[0])), ".", 1);
memcpy (body + deh_location( &(deh[1]) ), "..", 2); memcpy(body + deh_location(&(deh[1])), "..", 2);
} }

1850
fs/reiserfs/do_balan.c
View file

File diff suppressed because it is too large Load diff

824
fs/reiserfs/file.c
View file

File diff suppressed because it is too large Load diff

1595
fs/reiserfs/fix_node.c
View file

File diff suppressed because it is too large Load diff

125
fs/reiserfs/hashes.c
View file

@ -22,7 +22,6 @@
#include <asm/types.h> #include <asm/types.h>
#include <asm/bug.h> #include <asm/bug.h>
#define DELTA 0x9E3779B9 #define DELTA 0x9E3779B9
#define FULLROUNDS 10 /* 32 is overkill, 16 is strong crypto */ #define FULLROUNDS 10 /* 32 is overkill, 16 is strong crypto */
#define PARTROUNDS 6 /* 6 gets complete mixing */ #define PARTROUNDS 6 /* 6 gets complete mixing */
@ -48,10 +47,9 @@
h1 += b1; \ h1 += b1; \
} while(0) } while(0)
u32 keyed_hash(const signed char *msg, int len) u32 keyed_hash(const signed char *msg, int len)
{ {
u32 k[] = { 0x9464a485, 0x542e1a94, 0x3e846bff, 0xb75bcfc3}; u32 k[] = { 0x9464a485, 0x542e1a94, 0x3e846bff, 0xb75bcfc3 };
u32 h0 = k[0], h1 = k[1]; u32 h0 = k[0], h1 = k[1];
u32 a, b, c, d; u32 a, b, c, d;
@ -60,27 +58,20 @@ u32 keyed_hash(const signed char *msg, int len)
// assert(len >= 0 && len < 256); // assert(len >= 0 && len < 256);
pad = (u32)len | ((u32)len << 8); pad = (u32) len | ((u32) len << 8);
pad |= pad << 16; pad |= pad << 16;
while(len >= 16) while (len >= 16) {
{ a = (u32) msg[0] |
a = (u32)msg[ 0] | (u32) msg[1] << 8 | (u32) msg[2] << 16 | (u32) msg[3] << 24;
(u32)msg[ 1] << 8 | b = (u32) msg[4] |
(u32)msg[ 2] << 16| (u32) msg[5] << 8 | (u32) msg[6] << 16 | (u32) msg[7] << 24;
(u32)msg[ 3] << 24; c = (u32) msg[8] |
b = (u32)msg[ 4] | (u32) msg[9] << 8 |
(u32)msg[ 5] << 8 | (u32) msg[10] << 16 | (u32) msg[11] << 24;
(u32)msg[ 6] << 16| d = (u32) msg[12] |
(u32)msg[ 7] << 24; (u32) msg[13] << 8 |
c = (u32)msg[ 8] | (u32) msg[14] << 16 | (u32) msg[15] << 24;
(u32)msg[ 9] << 8 |
(u32)msg[10] << 16|
(u32)msg[11] << 24;
d = (u32)msg[12] |
(u32)msg[13] << 8 |
(u32)msg[14] << 16|
(u32)msg[15] << 24;
TEACORE(PARTROUNDS); TEACORE(PARTROUNDS);
@ -88,65 +79,43 @@ u32 keyed_hash(const signed char *msg, int len)
msg += 16; msg += 16;
} }
if (len >= 12) if (len >= 12) {
{ a = (u32) msg[0] |
a = (u32)msg[ 0] | (u32) msg[1] << 8 | (u32) msg[2] << 16 | (u32) msg[3] << 24;
(u32)msg[ 1] << 8 | b = (u32) msg[4] |
(u32)msg[ 2] << 16| (u32) msg[5] << 8 | (u32) msg[6] << 16 | (u32) msg[7] << 24;
(u32)msg[ 3] << 24; c = (u32) msg[8] |
b = (u32)msg[ 4] | (u32) msg[9] << 8 |
(u32)msg[ 5] << 8 | (u32) msg[10] << 16 | (u32) msg[11] << 24;
(u32)msg[ 6] << 16|
(u32)msg[ 7] << 24;
c = (u32)msg[ 8] |
(u32)msg[ 9] << 8 |
(u32)msg[10] << 16|
(u32)msg[11] << 24;
d = pad; d = pad;
for(i = 12; i < len; i++) for (i = 12; i < len; i++) {
{
d <<= 8; d <<= 8;
d |= msg[i]; d |= msg[i];
} }
} } else if (len >= 8) {
else if (len >= 8) a = (u32) msg[0] |
{ (u32) msg[1] << 8 | (u32) msg[2] << 16 | (u32) msg[3] << 24;
a = (u32)msg[ 0] | b = (u32) msg[4] |
(u32)msg[ 1] << 8 | (u32) msg[5] << 8 | (u32) msg[6] << 16 | (u32) msg[7] << 24;
(u32)msg[ 2] << 16|
(u32)msg[ 3] << 24;
b = (u32)msg[ 4] |
(u32)msg[ 5] << 8 |
(u32)msg[ 6] << 16|
(u32)msg[ 7] << 24;
c = d = pad; c = d = pad;
for(i = 8; i < len; i++) for (i = 8; i < len; i++) {
{
c <<= 8; c <<= 8;
c |= msg[i]; c |= msg[i];
} }
} } else if (len >= 4) {
else if (len >= 4) a = (u32) msg[0] |
{ (u32) msg[1] << 8 | (u32) msg[2] << 16 | (u32) msg[3] << 24;
a = (u32)msg[ 0] |
(u32)msg[ 1] << 8 |
(u32)msg[ 2] << 16|
(u32)msg[ 3] << 24;
b = c = d = pad; b = c = d = pad;
for(i = 4; i < len; i++) for (i = 4; i < len; i++) {
{
b <<= 8; b <<= 8;
b |= msg[i]; b |= msg[i];
} }
} } else {
else
{
a = b = c = d = pad; a = b = c = d = pad;
for(i = 0; i < len; i++) for (i = 0; i < len; i++) {
{
a <<= 8; a <<= 8;
a |= msg[i]; a |= msg[i];
} }
@ -155,40 +124,44 @@ u32 keyed_hash(const signed char *msg, int len)
TEACORE(FULLROUNDS); TEACORE(FULLROUNDS);
/* return 0;*/ /* return 0;*/
return h0^h1; return h0 ^ h1;
} }
/* What follows in this file is copyright 2000 by Hans Reiser, and the /* What follows in this file is copyright 2000 by Hans Reiser, and the
* licensing of what follows is governed by reiserfs/README */ * licensing of what follows is governed by reiserfs/README */
u32 yura_hash (const signed char *msg, int len) u32 yura_hash(const signed char *msg, int len)
{ {
int j, pow; int j, pow;
u32 a, c; u32 a, c;
int i; int i;
for (pow=1,i=1; i < len; i++) pow = pow * 10; for (pow = 1, i = 1; i < len; i++)
pow = pow * 10;
if (len == 1) if (len == 1)
a = msg[0]-48; a = msg[0] - 48;
else else
a = (msg[0] - 48) * pow; a = (msg[0] - 48) * pow;
for (i=1; i < len; i++) { for (i = 1; i < len; i++) {
c = msg[i] - 48; c = msg[i] - 48;
for (pow=1,j=i; j < len-1; j++) pow = pow * 10; for (pow = 1, j = i; j < len - 1; j++)
pow = pow * 10;
a = a + c * pow; a = a + c * pow;
} }
for (; i < 40; i++) { for (; i < 40; i++) {
c = '0' - 48; c = '0' - 48;
for (pow=1,j=i; j < len-1; j++) pow = pow * 10; for (pow = 1, j = i; j < len - 1; j++)
pow = pow * 10;
a = a + c * pow; a = a + c * pow;
} }
for (; i < 256; i++) { for (; i < 256; i++) {
c = i; c = i;
for (pow=1,j=i; j < len-1; j++) pow = pow * 10; for (pow = 1, j = i; j < len - 1; j++)
pow = pow * 10;
a = a + c * pow; a = a + c * pow;
} }
@ -196,10 +169,10 @@ u32 yura_hash (const signed char *msg, int len)
return a; return a;
} }
u32 r5_hash (const signed char *msg, int len) u32 r5_hash(const signed char *msg, int len)
{ {
u32 a=0; u32 a = 0;
while(*msg) { while (*msg) {
a += *msg << 4; a += *msg << 4;
a += *msg >> 4; a += *msg >> 4;
a *= 11; a *= 11;

926
fs/reiserfs/ibalance.c
View file

File diff suppressed because it is too large Load diff

1755
fs/reiserfs/inode.c
View file

File diff suppressed because it is too large Load diff

99
fs/reiserfs/ioctl.c
View file

@ -9,7 +9,7 @@
#include <linux/pagemap.h> #include <linux/pagemap.h>
#include <linux/smp_lock.h> #include <linux/smp_lock.h>
static int reiserfs_unpack (struct inode * inode, struct file * filp); static int reiserfs_unpack(struct inode *inode, struct file *filp);
/* /*
** reiserfs_ioctl - handler for ioctl for inode ** reiserfs_ioctl - handler for ioctl for inode
@ -19,16 +19,16 @@ static int reiserfs_unpack (struct inode * inode, struct file * filp);
** 2) REISERFS_IOC_[GS]ETFLAGS, REISERFS_IOC_[GS]ETVERSION ** 2) REISERFS_IOC_[GS]ETFLAGS, REISERFS_IOC_[GS]ETVERSION
** 3) That's all for a while ... ** 3) That's all for a while ...
*/ */
int reiserfs_ioctl (struct inode * inode, struct file * filp, unsigned int cmd, int reiserfs_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
unsigned long arg) unsigned long arg)
{ {
unsigned int flags; unsigned int flags;
switch (cmd) { switch (cmd) {
case REISERFS_IOC_UNPACK: case REISERFS_IOC_UNPACK:
if( S_ISREG( inode -> i_mode ) ) { if (S_ISREG(inode->i_mode)) {
if (arg) if (arg)
return reiserfs_unpack (inode, filp); return reiserfs_unpack(inode, filp);
else else
return 0; return 0;
} else } else
@ -36,51 +36,54 @@ int reiserfs_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
/* following two cases are taken from fs/ext2/ioctl.c by Remy /* following two cases are taken from fs/ext2/ioctl.c by Remy
Card (card@masi.ibp.fr) */ Card (card@masi.ibp.fr) */
case REISERFS_IOC_GETFLAGS: case REISERFS_IOC_GETFLAGS:
if (!reiserfs_attrs (inode->i_sb)) if (!reiserfs_attrs(inode->i_sb))
return -ENOTTY; return -ENOTTY;
flags = REISERFS_I(inode) -> i_attrs; flags = REISERFS_I(inode)->i_attrs;
i_attrs_to_sd_attrs( inode, ( __u16 * ) &flags ); i_attrs_to_sd_attrs(inode, (__u16 *) & flags);
return put_user(flags, (int __user *) arg); return put_user(flags, (int __user *)arg);
case REISERFS_IOC_SETFLAGS: { case REISERFS_IOC_SETFLAGS:{
if (!reiserfs_attrs (inode->i_sb)) if (!reiserfs_attrs(inode->i_sb))
return -ENOTTY; return -ENOTTY;
if (IS_RDONLY(inode)) if (IS_RDONLY(inode))
return -EROFS; return -EROFS;
if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER)) if ((current->fsuid != inode->i_uid)
&& !capable(CAP_FOWNER))
return -EPERM; return -EPERM;
if (get_user(flags, (int __user *) arg)) if (get_user(flags, (int __user *)arg))
return -EFAULT; return -EFAULT;
if ( ( ( flags ^ REISERFS_I(inode) -> i_attrs) & ( REISERFS_IMMUTABLE_FL | REISERFS_APPEND_FL)) && if (((flags ^ REISERFS_I(inode)->
!capable( CAP_LINUX_IMMUTABLE ) ) i_attrs) & (REISERFS_IMMUTABLE_FL |
REISERFS_APPEND_FL))
&& !capable(CAP_LINUX_IMMUTABLE))
return -EPERM; return -EPERM;
if( ( flags & REISERFS_NOTAIL_FL ) && if ((flags & REISERFS_NOTAIL_FL) &&
S_ISREG( inode -> i_mode ) ) { S_ISREG(inode->i_mode)) {
int result; int result;
result = reiserfs_unpack( inode, filp ); result = reiserfs_unpack(inode, filp);
if( result ) if (result)
return result; return result;
} }
sd_attrs_to_i_attrs( flags, inode ); sd_attrs_to_i_attrs(flags, inode);
REISERFS_I(inode) -> i_attrs = flags; REISERFS_I(inode)->i_attrs = flags;
inode->i_ctime = CURRENT_TIME_SEC; inode->i_ctime = CURRENT_TIME_SEC;
mark_inode_dirty(inode); mark_inode_dirty(inode);
return 0; return 0;
} }
case REISERFS_IOC_GETVERSION: case REISERFS_IOC_GETVERSION:
return put_user(inode->i_generation, (int __user *) arg); return put_user(inode->i_generation, (int __user *)arg);
case REISERFS_IOC_SETVERSION: case REISERFS_IOC_SETVERSION:
if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER)) if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
return -EPERM; return -EPERM;
if (IS_RDONLY(inode)) if (IS_RDONLY(inode))
return -EROFS; return -EROFS;
if (get_user(inode->i_generation, (int __user *) arg)) if (get_user(inode->i_generation, (int __user *)arg))
return -EFAULT; return -EFAULT;
inode->i_ctime = CURRENT_TIME_SEC; inode->i_ctime = CURRENT_TIME_SEC;
mark_inode_dirty(inode); mark_inode_dirty(inode);
@ -95,63 +98,65 @@ int reiserfs_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
** Function try to convert tail from direct item into indirect. ** Function try to convert tail from direct item into indirect.
** It set up nopack attribute in the REISERFS_I(inode)->nopack ** It set up nopack attribute in the REISERFS_I(inode)->nopack
*/ */
static int reiserfs_unpack (struct inode * inode, struct file * filp) static int reiserfs_unpack(struct inode *inode, struct file *filp)
{ {
int retval = 0; int retval = 0;
int index ; int index;
struct page *page ; struct page *page;
struct address_space *mapping ; struct address_space *mapping;
unsigned long write_from ; unsigned long write_from;
unsigned long blocksize = inode->i_sb->s_blocksize ; unsigned long blocksize = inode->i_sb->s_blocksize;
if (inode->i_size == 0) { if (inode->i_size == 0) {
REISERFS_I(inode)->i_flags |= i_nopack_mask; REISERFS_I(inode)->i_flags |= i_nopack_mask;
return 0 ; return 0;
} }
/* ioctl already done */ /* ioctl already done */
if (REISERFS_I(inode)->i_flags & i_nopack_mask) { if (REISERFS_I(inode)->i_flags & i_nopack_mask) {
return 0 ; return 0;
} }
reiserfs_write_lock(inode->i_sb); reiserfs_write_lock(inode->i_sb);
/* we need to make sure nobody is changing the file size beneath /* we need to make sure nobody is changing the file size beneath
** us ** us
*/ */
down(&inode->i_sem) ; down(&inode->i_sem);
write_from = inode->i_size & (blocksize - 1) ; write_from = inode->i_size & (blocksize - 1);
/* if we are on a block boundary, we are already unpacked. */ /* if we are on a block boundary, we are already unpacked. */
if ( write_from == 0) { if (write_from == 0) {
REISERFS_I(inode)->i_flags |= i_nopack_mask; REISERFS_I(inode)->i_flags |= i_nopack_mask;
goto out ; goto out;
} }
/* we unpack by finding the page with the tail, and calling /* we unpack by finding the page with the tail, and calling
** reiserfs_prepare_write on that page. This will force a ** reiserfs_prepare_write on that page. This will force a
** reiserfs_get_block to unpack the tail for us. ** reiserfs_get_block to unpack the tail for us.
*/ */
index = inode->i_size >> PAGE_CACHE_SHIFT ; index = inode->i_size >> PAGE_CACHE_SHIFT;
mapping = inode->i_mapping ; mapping = inode->i_mapping;
page = grab_cache_page(mapping, index) ; page = grab_cache_page(mapping, index);
retval = -ENOMEM; retval = -ENOMEM;
if (!page) { if (!page) {
goto out ; goto out;
} }
retval = mapping->a_ops->prepare_write(NULL, page, write_from, write_from) ; retval =
mapping->a_ops->prepare_write(NULL, page, write_from, write_from);
if (retval) if (retval)
goto out_unlock ; goto out_unlock;
/* conversion can change page contents, must flush */ /* conversion can change page contents, must flush */
flush_dcache_page(page) ; flush_dcache_page(page);
retval = mapping->a_ops->commit_write(NULL, page, write_from, write_from) ; retval =
mapping->a_ops->commit_write(NULL, page, write_from, write_from);
REISERFS_I(inode)->i_flags |= i_nopack_mask; REISERFS_I(inode)->i_flags |= i_nopack_mask;
out_unlock: out_unlock:
unlock_page(page) ; unlock_page(page);
page_cache_release(page) ; page_cache_release(page);
out: out:
up(&inode->i_sem) ; up(&inode->i_sem);
reiserfs_write_unlock(inode->i_sb); reiserfs_write_unlock(inode->i_sb);
return retval; return retval;
} }

477
fs/reiserfs/item_ops.c
View file

@ -14,99 +14,92 @@
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
// stat data functions // stat data functions
// //
static int sd_bytes_number (struct item_head * ih, int block_size) static int sd_bytes_number(struct item_head *ih, int block_size)
{ {
return 0; return 0;
} }
static void sd_decrement_key (struct cpu_key * key) static void sd_decrement_key(struct cpu_key *key)
{ {
key->on_disk_key.k_objectid --; key->on_disk_key.k_objectid--;
set_cpu_key_k_type (key, TYPE_ANY); set_cpu_key_k_type(key, TYPE_ANY);
set_cpu_key_k_offset(key, (loff_t)(-1)); set_cpu_key_k_offset(key, (loff_t) (-1));
} }
static int sd_is_left_mergeable (struct reiserfs_key * key, unsigned long bsize) static int sd_is_left_mergeable(struct reiserfs_key *key, unsigned long bsize)
{ {
return 0; return 0;
} }
static char *print_time(time_t t)
static char * print_time (time_t t)
{ {
static char timebuf[256]; static char timebuf[256];
sprintf (timebuf, "%ld", t); sprintf(timebuf, "%ld", t);
return timebuf; return timebuf;
} }
static void sd_print_item(struct item_head *ih, char *item)
static void sd_print_item (struct item_head * ih, char * item)
{ {
printk ("\tmode | size | nlinks | first direct | mtime\n"); printk("\tmode | size | nlinks | first direct | mtime\n");
if (stat_data_v1 (ih)) { if (stat_data_v1(ih)) {
struct stat_data_v1 * sd = (struct stat_data_v1 *)item; struct stat_data_v1 *sd = (struct stat_data_v1 *)item;
printk ("\t0%-6o | %6u | %2u | %d | %s\n", sd_v1_mode(sd), printk("\t0%-6o | %6u | %2u | %d | %s\n", sd_v1_mode(sd),
sd_v1_size(sd), sd_v1_nlink(sd), sd_v1_first_direct_byte(sd), sd_v1_size(sd), sd_v1_nlink(sd),
print_time( sd_v1_mtime(sd) ) ); sd_v1_first_direct_byte(sd),
print_time(sd_v1_mtime(sd)));
} else { } else {
struct stat_data * sd = (struct stat_data *)item; struct stat_data *sd = (struct stat_data *)item;
printk ("\t0%-6o | %6Lu | %2u | %d | %s\n", sd_v2_mode(sd), printk("\t0%-6o | %6Lu | %2u | %d | %s\n", sd_v2_mode(sd),
(unsigned long long)sd_v2_size(sd), sd_v2_nlink(sd), (unsigned long long)sd_v2_size(sd), sd_v2_nlink(sd),
sd_v2_rdev(sd), print_time(sd_v2_mtime(sd))); sd_v2_rdev(sd), print_time(sd_v2_mtime(sd)));
} }
} }
static void sd_check_item (struct item_head * ih, char * item) static void sd_check_item(struct item_head *ih, char *item)
{ {
// FIXME: type something here! // FIXME: type something here!
} }
static int sd_create_vi(struct virtual_node *vn,
static int sd_create_vi (struct virtual_node * vn, struct virtual_item *vi,
struct virtual_item * vi, int is_affected, int insert_size)
int is_affected,
int insert_size)
{ {
vi->vi_index = TYPE_STAT_DATA; vi->vi_index = TYPE_STAT_DATA;
//vi->vi_type |= VI_TYPE_STAT_DATA;// not needed? //vi->vi_type |= VI_TYPE_STAT_DATA;// not needed?
return 0; return 0;
} }
static int sd_check_left(struct virtual_item *vi, int free,
static int sd_check_left (struct virtual_item * vi, int free,
int start_skip, int end_skip) int start_skip, int end_skip)
{ {
if (start_skip || end_skip) if (start_skip || end_skip)
BUG (); BUG();
return -1; return -1;
} }
static int sd_check_right(struct virtual_item *vi, int free)
static int sd_check_right (struct virtual_item * vi, int free)
{ {
return -1; return -1;
} }
static int sd_part_size (struct virtual_item * vi, int first, int count) static int sd_part_size(struct virtual_item *vi, int first, int count)
{ {
if (count) if (count)
BUG (); BUG();
return 0; return 0;
} }
static int sd_unit_num (struct virtual_item * vi) static int sd_unit_num(struct virtual_item *vi)
{ {
return vi->vi_item_len - IH_SIZE; return vi->vi_item_len - IH_SIZE;
} }
static void sd_print_vi(struct virtual_item *vi)
static void sd_print_vi (struct virtual_item * vi)
{ {
reiserfs_warning (NULL, "STATDATA, index %d, type 0x%x, %h", reiserfs_warning(NULL, "STATDATA, index %d, type 0x%x, %h",
vi->vi_index, vi->vi_type, vi->vi_ih); vi->vi_index, vi->vi_type, vi->vi_ih);
} }
@ -125,91 +118,81 @@ static struct item_operations stat_data_ops = {
.print_vi = sd_print_vi .print_vi = sd_print_vi
}; };
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
// direct item functions // direct item functions
// //
static int direct_bytes_number (struct item_head * ih, int block_size) static int direct_bytes_number(struct item_head *ih, int block_size)
{ {
return ih_item_len(ih); return ih_item_len(ih);
} }
// FIXME: this should probably switch to indirect as well // FIXME: this should probably switch to indirect as well
static void direct_decrement_key (struct cpu_key * key) static void direct_decrement_key(struct cpu_key *key)
{ {
cpu_key_k_offset_dec (key); cpu_key_k_offset_dec(key);
if (cpu_key_k_offset (key) == 0) if (cpu_key_k_offset(key) == 0)
set_cpu_key_k_type (key, TYPE_STAT_DATA); set_cpu_key_k_type(key, TYPE_STAT_DATA);
} }
static int direct_is_left_mergeable(struct reiserfs_key *key,
static int direct_is_left_mergeable (struct reiserfs_key * key, unsigned long bsize) unsigned long bsize)
{ {
int version = le_key_version (key); int version = le_key_version(key);
return ((le_key_k_offset (version, key) & (bsize - 1)) != 1); return ((le_key_k_offset(version, key) & (bsize - 1)) != 1);
} }
static void direct_print_item(struct item_head *ih, char *item)
static void direct_print_item (struct item_head * ih, char * item)
{ {
int j = 0; int j = 0;
// return; // return;
printk ("\""); printk("\"");
while (j < ih_item_len(ih)) while (j < ih_item_len(ih))
printk ("%c", item[j++]); printk("%c", item[j++]);
printk ("\"\n"); printk("\"\n");
} }
static void direct_check_item(struct item_head *ih, char *item)
static void direct_check_item (struct item_head * ih, char * item)
{ {
// FIXME: type something here! // FIXME: type something here!
} }
static int direct_create_vi(struct virtual_node *vn,
static int direct_create_vi (struct virtual_node * vn, struct virtual_item *vi,
struct virtual_item * vi, int is_affected, int insert_size)
int is_affected,
int insert_size)
{ {
vi->vi_index = TYPE_DIRECT; vi->vi_index = TYPE_DIRECT;
//vi->vi_type |= VI_TYPE_DIRECT; //vi->vi_type |= VI_TYPE_DIRECT;
return 0; return 0;
} }
static int direct_check_left (struct virtual_item * vi, int free, static int direct_check_left(struct virtual_item *vi, int free,
int start_skip, int end_skip) int start_skip, int end_skip)
{ {
int bytes; int bytes;
bytes = free - free % 8; bytes = free - free % 8;
return bytes ?: -1; return bytes ? : -1;
} }
static int direct_check_right(struct virtual_item *vi, int free)
static int direct_check_right (struct virtual_item * vi, int free)
{ {
return direct_check_left (vi, free, 0, 0); return direct_check_left(vi, free, 0, 0);
} }
static int direct_part_size (struct virtual_item * vi, int first, int count) static int direct_part_size(struct virtual_item *vi, int first, int count)
{ {
return count; return count;
} }
static int direct_unit_num(struct virtual_item *vi)
static int direct_unit_num (struct virtual_item * vi)
{ {
return vi->vi_item_len - IH_SIZE; return vi->vi_item_len - IH_SIZE;
} }
static void direct_print_vi(struct virtual_item *vi)
static void direct_print_vi (struct virtual_item * vi)
{ {
reiserfs_warning (NULL, "DIRECT, index %d, type 0x%x, %h", reiserfs_warning(NULL, "DIRECT, index %d, type 0x%x, %h",
vi->vi_index, vi->vi_type, vi->vi_ih); vi->vi_index, vi->vi_type, vi->vi_ih);
} }
@ -228,143 +211,132 @@ static struct item_operations direct_ops = {
.print_vi = direct_print_vi .print_vi = direct_print_vi
}; };
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
// indirect item functions // indirect item functions
// //
static int indirect_bytes_number (struct item_head * ih, int block_size) static int indirect_bytes_number(struct item_head *ih, int block_size)
{ {
return ih_item_len(ih) / UNFM_P_SIZE * block_size; //- get_ih_free_space (ih); return ih_item_len(ih) / UNFM_P_SIZE * block_size; //- get_ih_free_space (ih);
} }
// decrease offset, if it becomes 0, change type to stat data // decrease offset, if it becomes 0, change type to stat data
static void indirect_decrement_key (struct cpu_key * key) static void indirect_decrement_key(struct cpu_key *key)
{ {
cpu_key_k_offset_dec (key); cpu_key_k_offset_dec(key);
if (cpu_key_k_offset (key) == 0) if (cpu_key_k_offset(key) == 0)
set_cpu_key_k_type (key, TYPE_STAT_DATA); set_cpu_key_k_type(key, TYPE_STAT_DATA);
} }
// if it is not first item of the body, then it is mergeable // if it is not first item of the body, then it is mergeable
static int indirect_is_left_mergeable (struct reiserfs_key * key, unsigned long bsize) static int indirect_is_left_mergeable(struct reiserfs_key *key,
unsigned long bsize)
{ {
int version = le_key_version (key); int version = le_key_version(key);
return (le_key_k_offset (version, key) != 1); return (le_key_k_offset(version, key) != 1);
} }
// printing of indirect item // printing of indirect item
static void start_new_sequence (__u32 * start, int * len, __u32 new) static void start_new_sequence(__u32 * start, int *len, __u32 new)
{ {
*start = new; *start = new;
*len = 1; *len = 1;
} }
static int sequence_finished(__u32 start, int *len, __u32 new)
static int sequence_finished (__u32 start, int * len, __u32 new)
{ {
if (start == INT_MAX) if (start == INT_MAX)
return 1; return 1;
if (start == 0 && new == 0) { if (start == 0 && new == 0) {
(*len) ++; (*len)++;
return 0; return 0;
} }
if (start != 0 && (start + *len) == new) { if (start != 0 && (start + *len) == new) {
(*len) ++; (*len)++;
return 0; return 0;
} }
return 1; return 1;
} }
static void print_sequence (__u32 start, int len) static void print_sequence(__u32 start, int len)
{ {
if (start == INT_MAX) if (start == INT_MAX)
return; return;
if (len == 1) if (len == 1)
printk (" %d", start); printk(" %d", start);
else else
printk (" %d(%d)", start, len); printk(" %d(%d)", start, len);
} }
static void indirect_print_item(struct item_head *ih, char *item)
static void indirect_print_item (struct item_head * ih, char * item)
{ {
int j; int j;
__le32 * unp; __le32 *unp;
__u32 prev = INT_MAX; __u32 prev = INT_MAX;
int num; int num;
unp = (__le32 *)item; unp = (__le32 *) item;
if (ih_item_len(ih) % UNFM_P_SIZE) if (ih_item_len(ih) % UNFM_P_SIZE)
reiserfs_warning (NULL, "indirect_print_item: invalid item len"); reiserfs_warning(NULL, "indirect_print_item: invalid item len");
printk ("%d pointers\n[ ", (int)I_UNFM_NUM (ih)); printk("%d pointers\n[ ", (int)I_UNFM_NUM(ih));
for (j = 0; j < I_UNFM_NUM (ih); j ++) { for (j = 0; j < I_UNFM_NUM(ih); j++) {
if (sequence_finished (prev, &num, get_block_num(unp, j))) { if (sequence_finished(prev, &num, get_block_num(unp, j))) {
print_sequence (prev, num); print_sequence(prev, num);
start_new_sequence (&prev, &num, get_block_num(unp, j)); start_new_sequence(&prev, &num, get_block_num(unp, j));
} }
} }
print_sequence (prev, num); print_sequence(prev, num);
printk ("]\n"); printk("]\n");
} }
static void indirect_check_item (struct item_head * ih, char * item) static void indirect_check_item(struct item_head *ih, char *item)
{ {
// FIXME: type something here! // FIXME: type something here!
} }
static int indirect_create_vi(struct virtual_node *vn,
static int indirect_create_vi (struct virtual_node * vn, struct virtual_item *vi,
struct virtual_item * vi, int is_affected, int insert_size)
int is_affected,
int insert_size)
{ {
vi->vi_index = TYPE_INDIRECT; vi->vi_index = TYPE_INDIRECT;
//vi->vi_type |= VI_TYPE_INDIRECT; //vi->vi_type |= VI_TYPE_INDIRECT;
return 0; return 0;
} }
static int indirect_check_left (struct virtual_item * vi, int free, static int indirect_check_left(struct virtual_item *vi, int free,
int start_skip, int end_skip) int start_skip, int end_skip)
{ {
int bytes; int bytes;
bytes = free - free % UNFM_P_SIZE; bytes = free - free % UNFM_P_SIZE;
return bytes ?: -1; return bytes ? : -1;
} }
static int indirect_check_right(struct virtual_item *vi, int free)
static int indirect_check_right (struct virtual_item * vi, int free)
{ {
return indirect_check_left (vi, free, 0, 0); return indirect_check_left(vi, free, 0, 0);
} }
// return size in bytes of 'units' units. If first == 0 - calculate from the head (left), otherwise - from tail (right) // return size in bytes of 'units' units. If first == 0 - calculate from the head (left), otherwise - from tail (right)
static int indirect_part_size (struct virtual_item * vi, int first, int units) static int indirect_part_size(struct virtual_item *vi, int first, int units)
{ {
// unit of indirect item is byte (yet) // unit of indirect item is byte (yet)
return units; return units;
} }
static int indirect_unit_num (struct virtual_item * vi) static int indirect_unit_num(struct virtual_item *vi)
{ {
// unit of indirect item is byte (yet) // unit of indirect item is byte (yet)
return vi->vi_item_len - IH_SIZE; return vi->vi_item_len - IH_SIZE;
} }
static void indirect_print_vi (struct virtual_item * vi) static void indirect_print_vi(struct virtual_item *vi)
{ {
reiserfs_warning (NULL, "INDIRECT, index %d, type 0x%x, %h", reiserfs_warning(NULL, "INDIRECT, index %d, type 0x%x, %h",
vi->vi_index, vi->vi_type, vi->vi_ih); vi->vi_index, vi->vi_type, vi->vi_ih);
} }
@ -383,96 +355,94 @@ static struct item_operations indirect_ops = {
.print_vi = indirect_print_vi .print_vi = indirect_print_vi
}; };
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
// direntry functions // direntry functions
// //
static int direntry_bytes_number(struct item_head *ih, int block_size)
static int direntry_bytes_number (struct item_head * ih, int block_size)
{ {
reiserfs_warning (NULL, "vs-16090: direntry_bytes_number: " reiserfs_warning(NULL, "vs-16090: direntry_bytes_number: "
"bytes number is asked for direntry"); "bytes number is asked for direntry");
return 0; return 0;
} }
static void direntry_decrement_key (struct cpu_key * key) static void direntry_decrement_key(struct cpu_key *key)
{ {
cpu_key_k_offset_dec (key); cpu_key_k_offset_dec(key);
if (cpu_key_k_offset (key) == 0) if (cpu_key_k_offset(key) == 0)
set_cpu_key_k_type (key, TYPE_STAT_DATA); set_cpu_key_k_type(key, TYPE_STAT_DATA);
} }
static int direntry_is_left_mergeable(struct reiserfs_key *key,
static int direntry_is_left_mergeable (struct reiserfs_key * key, unsigned long bsize) unsigned long bsize)
{ {
if (le32_to_cpu (key->u.k_offset_v1.k_offset) == DOT_OFFSET) if (le32_to_cpu(key->u.k_offset_v1.k_offset) == DOT_OFFSET)
return 0; return 0;
return 1; return 1;
} }
static void direntry_print_item(struct item_head *ih, char *item)
static void direntry_print_item (struct item_head * ih, char * item)
{ {
int i; int i;
int namelen; int namelen;
struct reiserfs_de_head * deh; struct reiserfs_de_head *deh;
char * name; char *name;
static char namebuf [80]; static char namebuf[80];
printk("\n # %-15s%-30s%-15s%-15s%-15s\n", "Name",
printk ("\n # %-15s%-30s%-15s%-15s%-15s\n", "Name", "Key of pointed object", "Hash", "Gen number", "Status"); "Key of pointed object", "Hash", "Gen number", "Status");
deh = (struct reiserfs_de_head *)item; deh = (struct reiserfs_de_head *)item;
for (i = 0; i < I_ENTRY_COUNT (ih); i ++, deh ++) { for (i = 0; i < I_ENTRY_COUNT(ih); i++, deh++) {
namelen = (i ? (deh_location(deh - 1)) : ih_item_len(ih)) - deh_location(deh); namelen =
(i ? (deh_location(deh - 1)) : ih_item_len(ih)) -
deh_location(deh);
name = item + deh_location(deh); name = item + deh_location(deh);
if (name[namelen-1] == 0) if (name[namelen - 1] == 0)
namelen = strlen (name); namelen = strlen(name);
namebuf[0] = '"'; namebuf[0] = '"';
if (namelen > sizeof (namebuf) - 3) { if (namelen > sizeof(namebuf) - 3) {
strncpy (namebuf + 1, name, sizeof (namebuf) - 3); strncpy(namebuf + 1, name, sizeof(namebuf) - 3);
namebuf[sizeof (namebuf) - 2] = '"'; namebuf[sizeof(namebuf) - 2] = '"';
namebuf[sizeof (namebuf) - 1] = 0; namebuf[sizeof(namebuf) - 1] = 0;
} else { } else {
memcpy (namebuf + 1, name, namelen); memcpy(namebuf + 1, name, namelen);
namebuf[namelen + 1] = '"'; namebuf[namelen + 1] = '"';
namebuf[namelen + 2] = 0; namebuf[namelen + 2] = 0;
} }
printk ("%d: %-15s%-15d%-15d%-15Ld%-15Ld(%s)\n", printk("%d: %-15s%-15d%-15d%-15Ld%-15Ld(%s)\n",
i, namebuf, i, namebuf,
deh_dir_id(deh), deh_objectid(deh), deh_dir_id(deh), deh_objectid(deh),
GET_HASH_VALUE (deh_offset (deh)), GET_GENERATION_NUMBER ((deh_offset (deh))), GET_HASH_VALUE(deh_offset(deh)),
(de_hidden (deh)) ? "HIDDEN" : "VISIBLE"); GET_GENERATION_NUMBER((deh_offset(deh))),
(de_hidden(deh)) ? "HIDDEN" : "VISIBLE");
} }
} }
static void direntry_check_item(struct item_head *ih, char *item)
static void direntry_check_item (struct item_head * ih, char * item)
{ {
int i; int i;
struct reiserfs_de_head * deh; struct reiserfs_de_head *deh;
// FIXME: type something here! // FIXME: type something here!
deh = (struct reiserfs_de_head *)item; deh = (struct reiserfs_de_head *)item;
for (i = 0; i < I_ENTRY_COUNT (ih); i ++, deh ++) { for (i = 0; i < I_ENTRY_COUNT(ih); i++, deh++) {
; ;
} }
} }
#define DIRENTRY_VI_FIRST_DIRENTRY_ITEM 1 #define DIRENTRY_VI_FIRST_DIRENTRY_ITEM 1
/* /*
* function returns old entry number in directory item in real node * function returns old entry number in directory item in real node
* using new entry number in virtual item in virtual node */ * using new entry number in virtual item in virtual node */
static inline int old_entry_num (int is_affected, int virtual_entry_num, int pos_in_item, int mode) static inline int old_entry_num(int is_affected, int virtual_entry_num,
int pos_in_item, int mode)
{ {
if ( mode == M_INSERT || mode == M_DELETE) if (mode == M_INSERT || mode == M_DELETE)
return virtual_entry_num; return virtual_entry_num;
if (!is_affected) if (!is_affected)
@ -485,72 +455,70 @@ static inline int old_entry_num (int is_affected, int virtual_entry_num, int pos
if (mode == M_CUT) if (mode == M_CUT)
return virtual_entry_num + 1; return virtual_entry_num + 1;
RFALSE( mode != M_PASTE || virtual_entry_num == 0, RFALSE(mode != M_PASTE || virtual_entry_num == 0,
"vs-8015: old_entry_num: mode must be M_PASTE (mode = \'%c\'", mode); "vs-8015: old_entry_num: mode must be M_PASTE (mode = \'%c\'",
mode);
return virtual_entry_num - 1; return virtual_entry_num - 1;
} }
/* Create an array of sizes of directory entries for virtual /* Create an array of sizes of directory entries for virtual
item. Return space used by an item. FIXME: no control over item. Return space used by an item. FIXME: no control over
consuming of space used by this item handler */ consuming of space used by this item handler */
static int direntry_create_vi (struct virtual_node * vn, static int direntry_create_vi(struct virtual_node *vn,
struct virtual_item * vi, struct virtual_item *vi,
int is_affected, int is_affected, int insert_size)
int insert_size)
{ {
struct direntry_uarea * dir_u = vi->vi_uarea; struct direntry_uarea *dir_u = vi->vi_uarea;
int i, j; int i, j;
int size = sizeof (struct direntry_uarea); int size = sizeof(struct direntry_uarea);
struct reiserfs_de_head * deh; struct reiserfs_de_head *deh;
vi->vi_index = TYPE_DIRENTRY; vi->vi_index = TYPE_DIRENTRY;
if (!(vi->vi_ih) || !vi->vi_item) if (!(vi->vi_ih) || !vi->vi_item)
BUG (); BUG();
dir_u->flags = 0; dir_u->flags = 0;
if (le_ih_k_offset (vi->vi_ih) == DOT_OFFSET) if (le_ih_k_offset(vi->vi_ih) == DOT_OFFSET)
dir_u->flags |= DIRENTRY_VI_FIRST_DIRENTRY_ITEM; dir_u->flags |= DIRENTRY_VI_FIRST_DIRENTRY_ITEM;
deh = (struct reiserfs_de_head *)(vi->vi_item); deh = (struct reiserfs_de_head *)(vi->vi_item);
/* virtual directory item have this amount of entry after */ /* virtual directory item have this amount of entry after */
dir_u->entry_count = ih_entry_count (vi->vi_ih) + dir_u->entry_count = ih_entry_count(vi->vi_ih) +
((is_affected) ? ((vn->vn_mode == M_CUT) ? -1 : ((is_affected) ? ((vn->vn_mode == M_CUT) ? -1 :
(vn->vn_mode == M_PASTE ? 1 : 0)) : 0); (vn->vn_mode == M_PASTE ? 1 : 0)) : 0);
for (i = 0; i < dir_u->entry_count; i ++) { for (i = 0; i < dir_u->entry_count; i++) {
j = old_entry_num (is_affected, i, vn->vn_pos_in_item, vn->vn_mode); j = old_entry_num(is_affected, i, vn->vn_pos_in_item,
dir_u->entry_sizes[i] = (j ? deh_location( &(deh[j - 1]) ) : vn->vn_mode);
ih_item_len (vi->vi_ih)) - dir_u->entry_sizes[i] =
deh_location( &(deh[j])) + DEH_SIZE; (j ? deh_location(&(deh[j - 1])) : ih_item_len(vi->vi_ih)) -
deh_location(&(deh[j])) + DEH_SIZE;
} }
size += (dir_u->entry_count * sizeof (short)); size += (dir_u->entry_count * sizeof(short));
/* set size of pasted entry */ /* set size of pasted entry */
if (is_affected && vn->vn_mode == M_PASTE) if (is_affected && vn->vn_mode == M_PASTE)
dir_u->entry_sizes[vn->vn_pos_in_item] = insert_size; dir_u->entry_sizes[vn->vn_pos_in_item] = insert_size;
#ifdef CONFIG_REISERFS_CHECK #ifdef CONFIG_REISERFS_CHECK
/* compare total size of entries with item length */ /* compare total size of entries with item length */
{ {
int k, l; int k, l;
l = 0; l = 0;
for (k = 0; k < dir_u->entry_count; k ++) for (k = 0; k < dir_u->entry_count; k++)
l += dir_u->entry_sizes[k]; l += dir_u->entry_sizes[k];
if (l + IH_SIZE != vi->vi_item_len + if (l + IH_SIZE != vi->vi_item_len +
((is_affected && (vn->vn_mode == M_PASTE || vn->vn_mode == M_CUT)) ? insert_size : 0) ) { ((is_affected
reiserfs_panic (NULL, "vs-8025: set_entry_sizes: (mode==%c, insert_size==%d), invalid length of directory item", && (vn->vn_mode == M_PASTE
|| vn->vn_mode == M_CUT)) ? insert_size : 0)) {
reiserfs_panic(NULL,
"vs-8025: set_entry_sizes: (mode==%c, insert_size==%d), invalid length of directory item",
vn->vn_mode, insert_size); vn->vn_mode, insert_size);
} }
} }
@ -558,73 +526,72 @@ static int direntry_create_vi (struct virtual_node * vn,
return size; return size;
} }
// //
// return number of entries which may fit into specified amount of // return number of entries which may fit into specified amount of
// free space, or -1 if free space is not enough even for 1 entry // free space, or -1 if free space is not enough even for 1 entry
// //
static int direntry_check_left (struct virtual_item * vi, int free, static int direntry_check_left(struct virtual_item *vi, int free,
int start_skip, int end_skip) int start_skip, int end_skip)
{ {
int i; int i;
int entries = 0; int entries = 0;
struct direntry_uarea * dir_u = vi->vi_uarea; struct direntry_uarea *dir_u = vi->vi_uarea;
for (i = start_skip; i < dir_u->entry_count - end_skip; i ++) { for (i = start_skip; i < dir_u->entry_count - end_skip; i++) {
if (dir_u->entry_sizes[i] > free) if (dir_u->entry_sizes[i] > free)
/* i-th entry doesn't fit into the remaining free space */ /* i-th entry doesn't fit into the remaining free space */
break; break;
free -= dir_u->entry_sizes[i]; free -= dir_u->entry_sizes[i];
entries ++; entries++;
} }
if (entries == dir_u->entry_count) { if (entries == dir_u->entry_count) {
reiserfs_panic (NULL, "free space %d, entry_count %d\n", free, dir_u->entry_count); reiserfs_panic(NULL, "free space %d, entry_count %d\n", free,
dir_u->entry_count);
} }
/* "." and ".." can not be separated from each other */ /* "." and ".." can not be separated from each other */
if (start_skip == 0 && (dir_u->flags & DIRENTRY_VI_FIRST_DIRENTRY_ITEM) && entries < 2) if (start_skip == 0 && (dir_u->flags & DIRENTRY_VI_FIRST_DIRENTRY_ITEM)
&& entries < 2)
entries = 0; entries = 0;
return entries ?: -1; return entries ? : -1;
} }
static int direntry_check_right(struct virtual_item *vi, int free)
static int direntry_check_right (struct virtual_item * vi, int free)
{ {
int i; int i;
int entries = 0; int entries = 0;
struct direntry_uarea * dir_u = vi->vi_uarea; struct direntry_uarea *dir_u = vi->vi_uarea;
for (i = dir_u->entry_count - 1; i >= 0; i --) { for (i = dir_u->entry_count - 1; i >= 0; i--) {
if (dir_u->entry_sizes[i] > free) if (dir_u->entry_sizes[i] > free)
/* i-th entry doesn't fit into the remaining free space */ /* i-th entry doesn't fit into the remaining free space */
break; break;
free -= dir_u->entry_sizes[i]; free -= dir_u->entry_sizes[i];
entries ++; entries++;
} }
if (entries == dir_u->entry_count) if (entries == dir_u->entry_count)
BUG (); BUG();
/* "." and ".." can not be separated from each other */ /* "." and ".." can not be separated from each other */
if ((dir_u->flags & DIRENTRY_VI_FIRST_DIRENTRY_ITEM) && entries > dir_u->entry_count - 2) if ((dir_u->flags & DIRENTRY_VI_FIRST_DIRENTRY_ITEM)
&& entries > dir_u->entry_count - 2)
entries = dir_u->entry_count - 2; entries = dir_u->entry_count - 2;
return entries ?: -1; return entries ? : -1;
} }
/* sum of entry sizes between from-th and to-th entries including both edges */ /* sum of entry sizes between from-th and to-th entries including both edges */
static int direntry_part_size (struct virtual_item * vi, int first, int count) static int direntry_part_size(struct virtual_item *vi, int first, int count)
{ {
int i, retval; int i, retval;
int from, to; int from, to;
struct direntry_uarea * dir_u = vi->vi_uarea; struct direntry_uarea *dir_u = vi->vi_uarea;
retval = 0; retval = 0;
if (first == 0) if (first == 0)
@ -633,32 +600,30 @@ static int direntry_part_size (struct virtual_item * vi, int first, int count)
from = dir_u->entry_count - count; from = dir_u->entry_count - count;
to = from + count - 1; to = from + count - 1;
for (i = from; i <= to; i ++) for (i = from; i <= to; i++)
retval += dir_u->entry_sizes[i]; retval += dir_u->entry_sizes[i];
return retval; return retval;
} }
static int direntry_unit_num (struct virtual_item * vi) static int direntry_unit_num(struct virtual_item *vi)
{ {
struct direntry_uarea * dir_u = vi->vi_uarea; struct direntry_uarea *dir_u = vi->vi_uarea;
return dir_u->entry_count; return dir_u->entry_count;
} }
static void direntry_print_vi(struct virtual_item *vi)
static void direntry_print_vi (struct virtual_item * vi)
{ {
int i; int i;
struct direntry_uarea * dir_u = vi->vi_uarea; struct direntry_uarea *dir_u = vi->vi_uarea;
reiserfs_warning (NULL, "DIRENTRY, index %d, type 0x%x, %h, flags 0x%x", reiserfs_warning(NULL, "DIRENTRY, index %d, type 0x%x, %h, flags 0x%x",
vi->vi_index, vi->vi_type, vi->vi_ih, dir_u->flags); vi->vi_index, vi->vi_type, vi->vi_ih, dir_u->flags);
printk ("%d entries: ", dir_u->entry_count); printk("%d entries: ", dir_u->entry_count);
for (i = 0; i < dir_u->entry_count; i ++) for (i = 0; i < dir_u->entry_count; i++)
printk ("%d ", dir_u->entry_sizes[i]); printk("%d ", dir_u->entry_sizes[i]);
printk ("\n"); printk("\n");
} }
static struct item_operations direntry_ops = { static struct item_operations direntry_ops = {
@ -676,79 +641,85 @@ static struct item_operations direntry_ops = {
.print_vi = direntry_print_vi .print_vi = direntry_print_vi
}; };
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
// Error catching functions to catch errors caused by incorrect item types. // Error catching functions to catch errors caused by incorrect item types.
// //
static int errcatch_bytes_number (struct item_head * ih, int block_size) static int errcatch_bytes_number(struct item_head *ih, int block_size)
{ {
reiserfs_warning (NULL, "green-16001: Invalid item type observed, run fsck ASAP"); reiserfs_warning(NULL,
"green-16001: Invalid item type observed, run fsck ASAP");
return 0; return 0;
} }
static void errcatch_decrement_key (struct cpu_key * key) static void errcatch_decrement_key(struct cpu_key *key)
{ {
reiserfs_warning (NULL, "green-16002: Invalid item type observed, run fsck ASAP"); reiserfs_warning(NULL,
"green-16002: Invalid item type observed, run fsck ASAP");
} }
static int errcatch_is_left_mergeable(struct reiserfs_key *key,
static int errcatch_is_left_mergeable (struct reiserfs_key * key, unsigned long bsize) unsigned long bsize)
{ {
reiserfs_warning (NULL, "green-16003: Invalid item type observed, run fsck ASAP"); reiserfs_warning(NULL,
"green-16003: Invalid item type observed, run fsck ASAP");
return 0; return 0;
} }
static void errcatch_print_item(struct item_head *ih, char *item)
static void errcatch_print_item (struct item_head * ih, char * item)
{ {
reiserfs_warning (NULL, "green-16004: Invalid item type observed, run fsck ASAP"); reiserfs_warning(NULL,
"green-16004: Invalid item type observed, run fsck ASAP");
} }
static void errcatch_check_item(struct item_head *ih, char *item)
static void errcatch_check_item (struct item_head * ih, char * item)
{ {
reiserfs_warning (NULL, "green-16005: Invalid item type observed, run fsck ASAP"); reiserfs_warning(NULL,
"green-16005: Invalid item type observed, run fsck ASAP");
} }
static int errcatch_create_vi (struct virtual_node * vn, static int errcatch_create_vi(struct virtual_node *vn,
struct virtual_item * vi, struct virtual_item *vi,
int is_affected, int is_affected, int insert_size)
int insert_size)
{ {
reiserfs_warning (NULL, "green-16006: Invalid item type observed, run fsck ASAP"); reiserfs_warning(NULL,
"green-16006: Invalid item type observed, run fsck ASAP");
return 0; // We might return -1 here as well, but it won't help as create_virtual_node() from where return 0; // We might return -1 here as well, but it won't help as create_virtual_node() from where
// this operation is called from is of return type void. // this operation is called from is of return type void.
} }
static int errcatch_check_left (struct virtual_item * vi, int free, static int errcatch_check_left(struct virtual_item *vi, int free,
int start_skip, int end_skip) int start_skip, int end_skip)
{ {
reiserfs_warning (NULL, "green-16007: Invalid item type observed, run fsck ASAP"); reiserfs_warning(NULL,
"green-16007: Invalid item type observed, run fsck ASAP");
return -1; return -1;
} }
static int errcatch_check_right(struct virtual_item *vi, int free)
static int errcatch_check_right (struct virtual_item * vi, int free)
{ {
reiserfs_warning (NULL, "green-16008: Invalid item type observed, run fsck ASAP"); reiserfs_warning(NULL,
"green-16008: Invalid item type observed, run fsck ASAP");
return -1; return -1;
} }
static int errcatch_part_size (struct virtual_item * vi, int first, int count) static int errcatch_part_size(struct virtual_item *vi, int first, int count)
{ {
reiserfs_warning (NULL, "green-16009: Invalid item type observed, run fsck ASAP"); reiserfs_warning(NULL,
"green-16009: Invalid item type observed, run fsck ASAP");
return 0; return 0;
} }
static int errcatch_unit_num (struct virtual_item * vi) static int errcatch_unit_num(struct virtual_item *vi)
{ {
reiserfs_warning (NULL, "green-16010: Invalid item type observed, run fsck ASAP"); reiserfs_warning(NULL,
"green-16010: Invalid item type observed, run fsck ASAP");
return 0; return 0;
} }
static void errcatch_print_vi (struct virtual_item * vi) static void errcatch_print_vi(struct virtual_item *vi)
{ {
reiserfs_warning (NULL, "green-16011: Invalid item type observed, run fsck ASAP"); reiserfs_warning(NULL,
"green-16011: Invalid item type observed, run fsck ASAP");
} }
static struct item_operations errcatch_ops = { static struct item_operations errcatch_ops = {
@ -766,8 +737,6 @@ static struct item_operations errcatch_ops = {
errcatch_print_vi errcatch_print_vi
}; };
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
// //
// //
@ -775,7 +744,7 @@ static struct item_operations errcatch_ops = {
#error Item types must use disk-format assigned values. #error Item types must use disk-format assigned values.
#endif #endif
struct item_operations * item_ops [TYPE_ANY + 1] = { struct item_operations *item_ops[TYPE_ANY + 1] = {
&stat_data_ops, &stat_data_ops,
&indirect_ops, &indirect_ops,
&direct_ops, &direct_ops,
@ -783,7 +752,3 @@ struct item_operations * item_ops [TYPE_ANY + 1] = {
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
&errcatch_ops /* This is to catch errors with invalid type (15th entry for TYPE_ANY) */ &errcatch_ops /* This is to catch errors with invalid type (15th entry for TYPE_ANY) */
}; };

2915
fs/reiserfs/journal.c
View file

File diff suppressed because it is too large Load diff

1016
fs/reiserfs/lbalance.c
View file

File diff suppressed because it is too large Load diff

918
fs/reiserfs/namei.c
View file

File diff suppressed because it is too large Load diff

143
fs/reiserfs/objectid.c
View file

@ -14,24 +14,24 @@
(__le32 *)((struct reiserfs_super_block_v1 *)(rs) + 1) :\ (__le32 *)((struct reiserfs_super_block_v1 *)(rs) + 1) :\
(__le32 *)((rs) + 1)) (__le32 *)((rs) + 1))
#ifdef CONFIG_REISERFS_CHECK #ifdef CONFIG_REISERFS_CHECK
static void check_objectid_map (struct super_block * s, __le32 * map) static void check_objectid_map(struct super_block *s, __le32 * map)
{ {
if (le32_to_cpu (map[0]) != 1) if (le32_to_cpu(map[0]) != 1)
reiserfs_panic (s, "vs-15010: check_objectid_map: map corrupted: %lx", reiserfs_panic(s,
( long unsigned int ) le32_to_cpu (map[0])); "vs-15010: check_objectid_map: map corrupted: %lx",
(long unsigned int)le32_to_cpu(map[0]));
// FIXME: add something else here // FIXME: add something else here
} }
#else #else
static void check_objectid_map (struct super_block * s, __le32 * map) static void check_objectid_map(struct super_block *s, __le32 * map)
{;} {;
}
#endif #endif
/* When we allocate objectids we allocate the first unused objectid. /* When we allocate objectids we allocate the first unused objectid.
Each sequence of objectids in use (the odd sequences) is followed Each sequence of objectids in use (the odd sequences) is followed
by a sequence of objectids not in use (the even sequences). We by a sequence of objectids not in use (the even sequences). We
@ -46,25 +46,24 @@ static void check_objectid_map (struct super_block * s, __le32 * map)
interesting optimizations of layout could result from complicating interesting optimizations of layout could result from complicating
objectid assignment, but we have deferred making them for now. */ objectid assignment, but we have deferred making them for now. */
/* get unique object identifier */ /* get unique object identifier */
__u32 reiserfs_get_unused_objectid (struct reiserfs_transaction_handle *th) __u32 reiserfs_get_unused_objectid(struct reiserfs_transaction_handle *th)
{ {
struct super_block * s = th->t_super; struct super_block *s = th->t_super;
struct reiserfs_super_block * rs = SB_DISK_SUPER_BLOCK (s); struct reiserfs_super_block *rs = SB_DISK_SUPER_BLOCK(s);
__le32 * map = objectid_map (s, rs); __le32 *map = objectid_map(s, rs);
__u32 unused_objectid; __u32 unused_objectid;
BUG_ON (!th->t_trans_id); BUG_ON(!th->t_trans_id);
check_objectid_map (s, map); check_objectid_map(s, map);
reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1) ; reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1);
/* comment needed -Hans */ /* comment needed -Hans */
unused_objectid = le32_to_cpu (map[1]); unused_objectid = le32_to_cpu(map[1]);
if (unused_objectid == U32_MAX) { if (unused_objectid == U32_MAX) {
reiserfs_warning (s, "%s: no more object ids", __FUNCTION__); reiserfs_warning(s, "%s: no more object ids", __FUNCTION__);
reiserfs_restore_prepared_buffer(s, SB_BUFFER_WITH_SB(s)) ; reiserfs_restore_prepared_buffer(s, SB_BUFFER_WITH_SB(s));
return 0; return 0;
} }
@ -73,7 +72,7 @@ __u32 reiserfs_get_unused_objectid (struct reiserfs_transaction_handle *th)
unused objectid, and by incrementing it we use it. See below unused objectid, and by incrementing it we use it. See below
where we check to see if we eliminated a sequence of unused where we check to see if we eliminated a sequence of unused
objectids.... */ objectids.... */
map[1] = cpu_to_le32 (unused_objectid + 1); map[1] = cpu_to_le32(unused_objectid + 1);
/* Now we check to see if we eliminated the last remaining member of /* Now we check to see if we eliminated the last remaining member of
the first even sequence (and can eliminate the sequence by the first even sequence (and can eliminate the sequence by
@ -82,30 +81,30 @@ __u32 reiserfs_get_unused_objectid (struct reiserfs_transaction_handle *th)
result is to eliminate a pair of objectids from oids. We do this result is to eliminate a pair of objectids from oids. We do this
by shifting the entire map to the left. */ by shifting the entire map to the left. */
if (sb_oid_cursize(rs) > 2 && map[1] == map[2]) { if (sb_oid_cursize(rs) > 2 && map[1] == map[2]) {
memmove (map + 1, map + 3, (sb_oid_cursize(rs) - 3) * sizeof(__u32)); memmove(map + 1, map + 3,
set_sb_oid_cursize( rs, sb_oid_cursize(rs) - 2 ); (sb_oid_cursize(rs) - 3) * sizeof(__u32));
set_sb_oid_cursize(rs, sb_oid_cursize(rs) - 2);
} }
journal_mark_dirty(th, s, SB_BUFFER_WITH_SB (s)); journal_mark_dirty(th, s, SB_BUFFER_WITH_SB(s));
return unused_objectid; return unused_objectid;
} }
/* makes object identifier unused */ /* makes object identifier unused */
void reiserfs_release_objectid (struct reiserfs_transaction_handle *th, void reiserfs_release_objectid(struct reiserfs_transaction_handle *th,
__u32 objectid_to_release) __u32 objectid_to_release)
{ {
struct super_block * s = th->t_super; struct super_block *s = th->t_super;
struct reiserfs_super_block * rs = SB_DISK_SUPER_BLOCK (s); struct reiserfs_super_block *rs = SB_DISK_SUPER_BLOCK(s);
__le32 * map = objectid_map (s, rs); __le32 *map = objectid_map(s, rs);
int i = 0; int i = 0;
BUG_ON (!th->t_trans_id); BUG_ON(!th->t_trans_id);
//return; //return;
check_objectid_map (s, map); check_objectid_map(s, map);
reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1) ; reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1);
journal_mark_dirty(th, s, SB_BUFFER_WITH_SB (s)); journal_mark_dirty(th, s, SB_BUFFER_WITH_SB(s));
/* start at the beginning of the objectid map (i = 0) and go to /* start at the beginning of the objectid map (i = 0) and go to
the end of it (i = disk_sb->s_oid_cursize). Linear search is the end of it (i = disk_sb->s_oid_cursize). Linear search is
@ -113,20 +112,21 @@ void reiserfs_release_objectid (struct reiserfs_transaction_handle *th,
more efficient after performing lots of deletions (which is more efficient after performing lots of deletions (which is
when oids is large.) We only check even i's. */ when oids is large.) We only check even i's. */
while (i < sb_oid_cursize(rs)) { while (i < sb_oid_cursize(rs)) {
if (objectid_to_release == le32_to_cpu (map[i])) { if (objectid_to_release == le32_to_cpu(map[i])) {
/* This incrementation unallocates the objectid. */ /* This incrementation unallocates the objectid. */
//map[i]++; //map[i]++;
map[i] = cpu_to_le32 (le32_to_cpu (map[i]) + 1); map[i] = cpu_to_le32(le32_to_cpu(map[i]) + 1);
/* Did we unallocate the last member of an odd sequence, and can shrink oids? */ /* Did we unallocate the last member of an odd sequence, and can shrink oids? */
if (map[i] == map[i+1]) { if (map[i] == map[i + 1]) {
/* shrink objectid map */ /* shrink objectid map */
memmove (map + i, map + i + 2, memmove(map + i, map + i + 2,
(sb_oid_cursize(rs) - i - 2) * sizeof (__u32)); (sb_oid_cursize(rs) - i -
2) * sizeof(__u32));
//disk_sb->s_oid_cursize -= 2; //disk_sb->s_oid_cursize -= 2;
set_sb_oid_cursize( rs, sb_oid_cursize(rs) - 2 ); set_sb_oid_cursize(rs, sb_oid_cursize(rs) - 2);
RFALSE( sb_oid_cursize(rs) < 2 || RFALSE(sb_oid_cursize(rs) < 2 ||
sb_oid_cursize(rs) > sb_oid_maxsize(rs), sb_oid_cursize(rs) > sb_oid_maxsize(rs),
"vs-15005: objectid map corrupted cur_size == %d (max == %d)", "vs-15005: objectid map corrupted cur_size == %d (max == %d)",
sb_oid_cursize(rs), sb_oid_maxsize(rs)); sb_oid_cursize(rs), sb_oid_maxsize(rs));
@ -134,73 +134,74 @@ void reiserfs_release_objectid (struct reiserfs_transaction_handle *th,
return; return;
} }
if (objectid_to_release > le32_to_cpu (map[i]) && if (objectid_to_release > le32_to_cpu(map[i]) &&
objectid_to_release < le32_to_cpu (map[i + 1])) { objectid_to_release < le32_to_cpu(map[i + 1])) {
/* size of objectid map is not changed */ /* size of objectid map is not changed */
if (objectid_to_release + 1 == le32_to_cpu (map[i + 1])) { if (objectid_to_release + 1 == le32_to_cpu(map[i + 1])) {
//objectid_map[i+1]--; //objectid_map[i+1]--;
map[i + 1] = cpu_to_le32 (le32_to_cpu (map[i + 1]) - 1); map[i + 1] =
cpu_to_le32(le32_to_cpu(map[i + 1]) - 1);
return; return;
} }
/* JDM comparing two little-endian values for equality -- safe */ /* JDM comparing two little-endian values for equality -- safe */
if (sb_oid_cursize(rs) == sb_oid_maxsize(rs)) { if (sb_oid_cursize(rs) == sb_oid_maxsize(rs)) {
/* objectid map must be expanded, but there is no space */ /* objectid map must be expanded, but there is no space */
PROC_INFO_INC( s, leaked_oid ); PROC_INFO_INC(s, leaked_oid);
return; return;
} }
/* expand the objectid map*/ /* expand the objectid map */
memmove (map + i + 3, map + i + 1, memmove(map + i + 3, map + i + 1,
(sb_oid_cursize(rs) - i - 1) * sizeof(__u32)); (sb_oid_cursize(rs) - i - 1) * sizeof(__u32));
map[i + 1] = cpu_to_le32 (objectid_to_release); map[i + 1] = cpu_to_le32(objectid_to_release);
map[i + 2] = cpu_to_le32 (objectid_to_release + 1); map[i + 2] = cpu_to_le32(objectid_to_release + 1);
set_sb_oid_cursize( rs, sb_oid_cursize(rs) + 2 ); set_sb_oid_cursize(rs, sb_oid_cursize(rs) + 2);
return; return;
} }
i += 2; i += 2;
} }
reiserfs_warning (s, "vs-15011: reiserfs_release_objectid: tried to free free object id (%lu)", reiserfs_warning(s,
( long unsigned ) objectid_to_release); "vs-15011: reiserfs_release_objectid: tried to free free object id (%lu)",
(long unsigned)objectid_to_release);
} }
int reiserfs_convert_objectid_map_v1(struct super_block *s)
int reiserfs_convert_objectid_map_v1(struct super_block *s) { {
struct reiserfs_super_block *disk_sb = SB_DISK_SUPER_BLOCK (s); struct reiserfs_super_block *disk_sb = SB_DISK_SUPER_BLOCK(s);
int cur_size = sb_oid_cursize(disk_sb); int cur_size = sb_oid_cursize(disk_sb);
int new_size = (s->s_blocksize - SB_SIZE) / sizeof(__u32) / 2 * 2 ; int new_size = (s->s_blocksize - SB_SIZE) / sizeof(__u32) / 2 * 2;
int old_max = sb_oid_maxsize(disk_sb); int old_max = sb_oid_maxsize(disk_sb);
struct reiserfs_super_block_v1 *disk_sb_v1 ; struct reiserfs_super_block_v1 *disk_sb_v1;
__le32 *objectid_map, *new_objectid_map ; __le32 *objectid_map, *new_objectid_map;
int i ; int i;
disk_sb_v1=(struct reiserfs_super_block_v1 *)(SB_BUFFER_WITH_SB(s)->b_data); disk_sb_v1 =
objectid_map = (__le32 *)(disk_sb_v1 + 1) ; (struct reiserfs_super_block_v1 *)(SB_BUFFER_WITH_SB(s)->b_data);
new_objectid_map = (__le32 *)(disk_sb + 1) ; objectid_map = (__le32 *) (disk_sb_v1 + 1);
new_objectid_map = (__le32 *) (disk_sb + 1);
if (cur_size > new_size) { if (cur_size > new_size) {
/* mark everyone used that was listed as free at the end of the objectid /* mark everyone used that was listed as free at the end of the objectid
** map ** map
*/ */
objectid_map[new_size - 1] = objectid_map[cur_size - 1] ; objectid_map[new_size - 1] = objectid_map[cur_size - 1];
set_sb_oid_cursize(disk_sb,new_size) ; set_sb_oid_cursize(disk_sb, new_size);
} }
/* move the smaller objectid map past the end of the new super */ /* move the smaller objectid map past the end of the new super */
for (i = new_size - 1 ; i >= 0 ; i--) { for (i = new_size - 1; i >= 0; i--) {
objectid_map[i + (old_max - new_size)] = objectid_map[i] ; objectid_map[i + (old_max - new_size)] = objectid_map[i];
} }
/* set the max size so we don't overflow later */ /* set the max size so we don't overflow later */
set_sb_oid_maxsize(disk_sb,new_size) ; set_sb_oid_maxsize(disk_sb, new_size);
/* Zero out label and generate random UUID */ /* Zero out label and generate random UUID */
memset(disk_sb->s_label, 0, sizeof(disk_sb->s_label)) ; memset(disk_sb->s_label, 0, sizeof(disk_sb->s_label));
generate_random_uuid(disk_sb->s_uuid); generate_random_uuid(disk_sb->s_uuid);
/* finally, zero out the unused chunk of the new super */ /* finally, zero out the unused chunk of the new super */
memset(disk_sb->s_unused, 0, sizeof(disk_sb->s_unused)) ; memset(disk_sb->s_unused, 0, sizeof(disk_sb->s_unused));
return 0 ; return 0;
} }

581
fs/reiserfs/prints.c
View file

@ -15,169 +15,167 @@ static char error_buf[1024];
static char fmt_buf[1024]; static char fmt_buf[1024];
static char off_buf[80]; static char off_buf[80];
static char *reiserfs_cpu_offset(struct cpu_key *key)
static char * reiserfs_cpu_offset (struct cpu_key * key)
{ {
if (cpu_key_k_type(key) == TYPE_DIRENTRY) if (cpu_key_k_type(key) == TYPE_DIRENTRY)
sprintf (off_buf, "%Lu(%Lu)", sprintf(off_buf, "%Lu(%Lu)",
(unsigned long long)GET_HASH_VALUE (cpu_key_k_offset (key)), (unsigned long long)
(unsigned long long)GET_GENERATION_NUMBER (cpu_key_k_offset (key))); GET_HASH_VALUE(cpu_key_k_offset(key)),
(unsigned long long)
GET_GENERATION_NUMBER(cpu_key_k_offset(key)));
else else
sprintf (off_buf, "0x%Lx", (unsigned long long)cpu_key_k_offset (key)); sprintf(off_buf, "0x%Lx",
(unsigned long long)cpu_key_k_offset(key));
return off_buf; return off_buf;
} }
static char *le_offset(struct reiserfs_key *key)
static char * le_offset (struct reiserfs_key * key)
{ {
int version; int version;
version = le_key_version (key); version = le_key_version(key);
if (le_key_k_type (version, key) == TYPE_DIRENTRY) if (le_key_k_type(version, key) == TYPE_DIRENTRY)
sprintf (off_buf, "%Lu(%Lu)", sprintf(off_buf, "%Lu(%Lu)",
(unsigned long long)GET_HASH_VALUE (le_key_k_offset (version, key)), (unsigned long long)
(unsigned long long)GET_GENERATION_NUMBER (le_key_k_offset (version, key))); GET_HASH_VALUE(le_key_k_offset(version, key)),
(unsigned long long)
GET_GENERATION_NUMBER(le_key_k_offset(version, key)));
else else
sprintf (off_buf, "0x%Lx", (unsigned long long)le_key_k_offset (version, key)); sprintf(off_buf, "0x%Lx",
(unsigned long long)le_key_k_offset(version, key));
return off_buf; return off_buf;
} }
static char *cpu_type(struct cpu_key *key)
static char * cpu_type (struct cpu_key * key)
{ {
if (cpu_key_k_type (key) == TYPE_STAT_DATA) if (cpu_key_k_type(key) == TYPE_STAT_DATA)
return "SD"; return "SD";
if (cpu_key_k_type (key) == TYPE_DIRENTRY) if (cpu_key_k_type(key) == TYPE_DIRENTRY)
return "DIR"; return "DIR";
if (cpu_key_k_type (key) == TYPE_DIRECT) if (cpu_key_k_type(key) == TYPE_DIRECT)
return "DIRECT"; return "DIRECT";
if (cpu_key_k_type (key) == TYPE_INDIRECT) if (cpu_key_k_type(key) == TYPE_INDIRECT)
return "IND"; return "IND";
return "UNKNOWN"; return "UNKNOWN";
} }
static char *le_type(struct reiserfs_key *key)
static char * le_type (struct reiserfs_key * key)
{ {
int version; int version;
version = le_key_version (key); version = le_key_version(key);
if (le_key_k_type (version, key) == TYPE_STAT_DATA) if (le_key_k_type(version, key) == TYPE_STAT_DATA)
return "SD"; return "SD";
if (le_key_k_type (version, key) == TYPE_DIRENTRY) if (le_key_k_type(version, key) == TYPE_DIRENTRY)
return "DIR"; return "DIR";
if (le_key_k_type (version, key) == TYPE_DIRECT) if (le_key_k_type(version, key) == TYPE_DIRECT)
return "DIRECT"; return "DIRECT";
if (le_key_k_type (version, key) == TYPE_INDIRECT) if (le_key_k_type(version, key) == TYPE_INDIRECT)
return "IND"; return "IND";
return "UNKNOWN"; return "UNKNOWN";
} }
/* %k */ /* %k */
static void sprintf_le_key (char * buf, struct reiserfs_key * key) static void sprintf_le_key(char *buf, struct reiserfs_key *key)
{ {
if (key) if (key)
sprintf (buf, "[%d %d %s %s]", le32_to_cpu (key->k_dir_id), sprintf(buf, "[%d %d %s %s]", le32_to_cpu(key->k_dir_id),
le32_to_cpu (key->k_objectid), le_offset (key), le_type (key)); le32_to_cpu(key->k_objectid), le_offset(key),
le_type(key));
else else
sprintf (buf, "[NULL]"); sprintf(buf, "[NULL]");
} }
/* %K */ /* %K */
static void sprintf_cpu_key (char * buf, struct cpu_key * key) static void sprintf_cpu_key(char *buf, struct cpu_key *key)
{ {
if (key) if (key)
sprintf (buf, "[%d %d %s %s]", key->on_disk_key.k_dir_id, sprintf(buf, "[%d %d %s %s]", key->on_disk_key.k_dir_id,
key->on_disk_key.k_objectid, reiserfs_cpu_offset (key), key->on_disk_key.k_objectid, reiserfs_cpu_offset(key),
cpu_type (key)); cpu_type(key));
else else
sprintf (buf, "[NULL]"); sprintf(buf, "[NULL]");
} }
static void sprintf_de_head( char *buf, struct reiserfs_de_head *deh ) static void sprintf_de_head(char *buf, struct reiserfs_de_head *deh)
{ {
if( deh ) if (deh)
sprintf( buf, "[offset=%d dir_id=%d objectid=%d location=%d state=%04x]", deh_offset(deh), deh_dir_id(deh), sprintf(buf,
deh_objectid(deh), deh_location(deh), deh_state(deh) ); "[offset=%d dir_id=%d objectid=%d location=%d state=%04x]",
deh_offset(deh), deh_dir_id(deh), deh_objectid(deh),
deh_location(deh), deh_state(deh));
else else
sprintf( buf, "[NULL]" ); sprintf(buf, "[NULL]");
} }
static void sprintf_item_head (char * buf, struct item_head * ih) static void sprintf_item_head(char *buf, struct item_head *ih)
{ {
if (ih) { if (ih) {
strcpy (buf, (ih_version (ih) == KEY_FORMAT_3_6) ? "*3.6* " : "*3.5*"); strcpy(buf,
sprintf_le_key (buf + strlen (buf), &(ih->ih_key)); (ih_version(ih) == KEY_FORMAT_3_6) ? "*3.6* " : "*3.5*");
sprintf (buf + strlen (buf), ", item_len %d, item_location %d, " sprintf_le_key(buf + strlen(buf), &(ih->ih_key));
sprintf(buf + strlen(buf), ", item_len %d, item_location %d, "
"free_space(entry_count) %d", "free_space(entry_count) %d",
ih_item_len(ih), ih_location(ih), ih_free_space (ih)); ih_item_len(ih), ih_location(ih), ih_free_space(ih));
} else } else
sprintf (buf, "[NULL]"); sprintf(buf, "[NULL]");
} }
static void sprintf_direntry(char *buf, struct reiserfs_dir_entry *de)
static void sprintf_direntry (char * buf, struct reiserfs_dir_entry * de)
{ {
char name[20]; char name[20];
memcpy (name, de->de_name, de->de_namelen > 19 ? 19 : de->de_namelen); memcpy(name, de->de_name, de->de_namelen > 19 ? 19 : de->de_namelen);
name [de->de_namelen > 19 ? 19 : de->de_namelen] = 0; name[de->de_namelen > 19 ? 19 : de->de_namelen] = 0;
sprintf (buf, "\"%s\"==>[%d %d]", name, de->de_dir_id, de->de_objectid); sprintf(buf, "\"%s\"==>[%d %d]", name, de->de_dir_id, de->de_objectid);
} }
static void sprintf_block_head(char *buf, struct buffer_head *bh)
static void sprintf_block_head (char * buf, struct buffer_head * bh)
{ {
sprintf (buf, "level=%d, nr_items=%d, free_space=%d rdkey ", sprintf(buf, "level=%d, nr_items=%d, free_space=%d rdkey ",
B_LEVEL (bh), B_NR_ITEMS (bh), B_FREE_SPACE (bh)); B_LEVEL(bh), B_NR_ITEMS(bh), B_FREE_SPACE(bh));
} }
static void sprintf_buffer_head(char *buf, struct buffer_head *bh)
static void sprintf_buffer_head (char * buf, struct buffer_head * bh)
{ {
char b[BDEVNAME_SIZE]; char b[BDEVNAME_SIZE];
sprintf (buf, "dev %s, size %d, blocknr %llu, count %d, state 0x%lx, page %p, (%s, %s, %s)", sprintf(buf,
bdevname (bh->b_bdev, b), bh->b_size, "dev %s, size %d, blocknr %llu, count %d, state 0x%lx, page %p, (%s, %s, %s)",
(unsigned long long)bh->b_blocknr, bdevname(bh->b_bdev, b), bh->b_size,
atomic_read (&(bh->b_count)), (unsigned long long)bh->b_blocknr, atomic_read(&(bh->b_count)),
bh->b_state, bh->b_page, bh->b_state, bh->b_page,
buffer_uptodate (bh) ? "UPTODATE" : "!UPTODATE", buffer_uptodate(bh) ? "UPTODATE" : "!UPTODATE",
buffer_dirty (bh) ? "DIRTY" : "CLEAN", buffer_dirty(bh) ? "DIRTY" : "CLEAN",
buffer_locked (bh) ? "LOCKED" : "UNLOCKED"); buffer_locked(bh) ? "LOCKED" : "UNLOCKED");
} }
static void sprintf_disk_child(char *buf, struct disk_child *dc)
static void sprintf_disk_child (char * buf, struct disk_child * dc)
{ {
sprintf (buf, "[dc_number=%d, dc_size=%u]", dc_block_number(dc), dc_size(dc)); sprintf(buf, "[dc_number=%d, dc_size=%u]", dc_block_number(dc),
dc_size(dc));
} }
static char *is_there_reiserfs_struct(char *fmt, int *what, int *skip)
static char * is_there_reiserfs_struct (char * fmt, int * what, int * skip)
{ {
char * k = fmt; char *k = fmt;
*skip = 0; *skip = 0;
while ((k = strchr (k, '%')) != NULL) while ((k = strchr(k, '%')) != NULL) {
{
if (k[1] == 'k' || k[1] == 'K' || k[1] == 'h' || k[1] == 't' || if (k[1] == 'k' || k[1] == 'K' || k[1] == 'h' || k[1] == 't' ||
k[1] == 'z' || k[1] == 'b' || k[1] == 'y' || k[1] == 'a' ) { k[1] == 'z' || k[1] == 'b' || k[1] == 'y' || k[1] == 'a') {
*what = k[1]; *what = k[1];
break; break;
} }
(*skip) ++; (*skip)++;
k ++; k++;
} }
return k; return k;
} }
/* debugging reiserfs we used to print out a lot of different /* debugging reiserfs we used to print out a lot of different
variables, like keys, item headers, buffer heads etc. Values of variables, like keys, item headers, buffer heads etc. Values of
most fields matter. So it took a long time just to write most fields matter. So it took a long time just to write
@ -191,61 +189,64 @@ static char * is_there_reiserfs_struct (char * fmt, int * what, int * skip)
key->k_offset, key->k_uniqueness); key->k_offset, key->k_uniqueness);
*/ */
static void prepare_error_buf(const char *fmt, va_list args)
static void
prepare_error_buf( const char *fmt, va_list args )
{ {
char * fmt1 = fmt_buf; char *fmt1 = fmt_buf;
char * k; char *k;
char * p = error_buf; char *p = error_buf;
int i, j, what, skip; int i, j, what, skip;
strcpy (fmt1, fmt); strcpy(fmt1, fmt);
while( (k = is_there_reiserfs_struct( fmt1, &what, &skip )) != NULL ) while ((k = is_there_reiserfs_struct(fmt1, &what, &skip)) != NULL) {
{
*k = 0; *k = 0;
p += vsprintf (p, fmt1, args); p += vsprintf(p, fmt1, args);
for (i = 0; i < skip; i ++) for (i = 0; i < skip; i++)
j = va_arg (args, int); j = va_arg(args, int);
switch (what) { switch (what) {
case 'k': case 'k':
sprintf_le_key (p, va_arg(args, struct reiserfs_key *)); sprintf_le_key(p, va_arg(args, struct reiserfs_key *));
break; break;
case 'K': case 'K':
sprintf_cpu_key (p, va_arg(args, struct cpu_key *)); sprintf_cpu_key(p, va_arg(args, struct cpu_key *));
break; break;
case 'h': case 'h':
sprintf_item_head (p, va_arg(args, struct item_head *)); sprintf_item_head(p, va_arg(args, struct item_head *));
break; break;
case 't': case 't':
sprintf_direntry (p, va_arg(args, struct reiserfs_dir_entry *)); sprintf_direntry(p,
va_arg(args,
struct reiserfs_dir_entry *));
break; break;
case 'y': case 'y':
sprintf_disk_child (p, va_arg(args, struct disk_child *)); sprintf_disk_child(p,
va_arg(args, struct disk_child *));
break; break;
case 'z': case 'z':
sprintf_block_head (p, va_arg(args, struct buffer_head *)); sprintf_block_head(p,
va_arg(args, struct buffer_head *));
break; break;
case 'b': case 'b':
sprintf_buffer_head (p, va_arg(args, struct buffer_head *)); sprintf_buffer_head(p,
va_arg(args, struct buffer_head *));
break; break;
case 'a': case 'a':
sprintf_de_head (p, va_arg(args, struct reiserfs_de_head *)); sprintf_de_head(p,
va_arg(args,
struct reiserfs_de_head *));
break; break;
} }
p += strlen (p); p += strlen(p);
fmt1 = k + 2; fmt1 = k + 2;
} }
vsprintf (p, fmt1, args); vsprintf(p, fmt1, args);
} }
/* in addition to usual conversion specifiers this accepts reiserfs /* in addition to usual conversion specifiers this accepts reiserfs
specific conversion specifiers: specific conversion specifiers:
%k to print little endian key, %k to print little endian key,
@ -264,43 +265,43 @@ prepare_error_buf( const char *fmt, va_list args )
va_end( args );\ va_end( args );\
} }
void reiserfs_warning (struct super_block *sb, const char * fmt, ...) void reiserfs_warning(struct super_block *sb, const char *fmt, ...)
{ {
do_reiserfs_warning(fmt); do_reiserfs_warning(fmt);
if (sb) if (sb)
printk (KERN_WARNING "ReiserFS: %s: warning: %s\n", printk(KERN_WARNING "ReiserFS: %s: warning: %s\n",
reiserfs_bdevname (sb), error_buf); reiserfs_bdevname(sb), error_buf);
else else
printk (KERN_WARNING "ReiserFS: warning: %s\n", error_buf); printk(KERN_WARNING "ReiserFS: warning: %s\n", error_buf);
} }
/* No newline.. reiserfs_info calls can be followed by printk's */ /* No newline.. reiserfs_info calls can be followed by printk's */
void reiserfs_info (struct super_block *sb, const char * fmt, ...) void reiserfs_info(struct super_block *sb, const char *fmt, ...)
{ {
do_reiserfs_warning(fmt); do_reiserfs_warning(fmt);
if (sb) if (sb)
printk (KERN_NOTICE "ReiserFS: %s: %s", printk(KERN_NOTICE "ReiserFS: %s: %s",
reiserfs_bdevname (sb), error_buf); reiserfs_bdevname(sb), error_buf);
else else
printk (KERN_NOTICE "ReiserFS: %s", error_buf); printk(KERN_NOTICE "ReiserFS: %s", error_buf);
} }
/* No newline.. reiserfs_printk calls can be followed by printk's */ /* No newline.. reiserfs_printk calls can be followed by printk's */
static void reiserfs_printk (const char * fmt, ...) static void reiserfs_printk(const char *fmt, ...)
{ {
do_reiserfs_warning(fmt); do_reiserfs_warning(fmt);
printk (error_buf); printk(error_buf);
} }
void reiserfs_debug (struct super_block *s, int level, const char * fmt, ...) void reiserfs_debug(struct super_block *s, int level, const char *fmt, ...)
{ {
#ifdef CONFIG_REISERFS_CHECK #ifdef CONFIG_REISERFS_CHECK
do_reiserfs_warning(fmt); do_reiserfs_warning(fmt);
if (s) if (s)
printk (KERN_DEBUG "ReiserFS: %s: %s\n", printk(KERN_DEBUG "ReiserFS: %s: %s\n",
reiserfs_bdevname (s), error_buf); reiserfs_bdevname(s), error_buf);
else else
printk (KERN_DEBUG "ReiserFS: %s\n", error_buf); printk(KERN_DEBUG "ReiserFS: %s\n", error_buf);
#endif #endif
} }
@ -349,105 +350,102 @@ void reiserfs_debug (struct super_block *s, int level, const char * fmt, ...)
. */ . */
#ifdef CONFIG_REISERFS_CHECK #ifdef CONFIG_REISERFS_CHECK
extern struct tree_balance * cur_tb; extern struct tree_balance *cur_tb;
#endif #endif
void reiserfs_panic (struct super_block * sb, const char * fmt, ...) void reiserfs_panic(struct super_block *sb, const char *fmt, ...)
{ {
do_reiserfs_warning(fmt); do_reiserfs_warning(fmt);
printk (KERN_EMERG "REISERFS: panic (device %s): %s\n", printk(KERN_EMERG "REISERFS: panic (device %s): %s\n",
reiserfs_bdevname (sb), error_buf); reiserfs_bdevname(sb), error_buf);
BUG (); BUG();
/* this is not actually called, but makes reiserfs_panic() "noreturn" */ /* this is not actually called, but makes reiserfs_panic() "noreturn" */
panic ("REISERFS: panic (device %s): %s\n", panic("REISERFS: panic (device %s): %s\n",
reiserfs_bdevname (sb), error_buf); reiserfs_bdevname(sb), error_buf);
} }
void void reiserfs_abort(struct super_block *sb, int errno, const char *fmt, ...)
reiserfs_abort (struct super_block *sb, int errno, const char *fmt, ...)
{ {
do_reiserfs_warning (fmt); do_reiserfs_warning(fmt);
if (reiserfs_error_panic (sb)) { if (reiserfs_error_panic(sb)) {
panic (KERN_CRIT "REISERFS: panic (device %s): %s\n", panic(KERN_CRIT "REISERFS: panic (device %s): %s\n",
reiserfs_bdevname (sb), error_buf); reiserfs_bdevname(sb), error_buf);
} }
if (sb->s_flags & MS_RDONLY) if (sb->s_flags & MS_RDONLY)
return; return;
printk (KERN_CRIT "REISERFS: abort (device %s): %s\n", printk(KERN_CRIT "REISERFS: abort (device %s): %s\n",
reiserfs_bdevname (sb), error_buf); reiserfs_bdevname(sb), error_buf);
sb->s_flags |= MS_RDONLY; sb->s_flags |= MS_RDONLY;
reiserfs_journal_abort (sb, errno); reiserfs_journal_abort(sb, errno);
} }
/* this prints internal nodes (4 keys/items in line) (dc_number, /* this prints internal nodes (4 keys/items in line) (dc_number,
dc_size)[k_dirid, k_objectid, k_offset, k_uniqueness](dc_number, dc_size)[k_dirid, k_objectid, k_offset, k_uniqueness](dc_number,
dc_size)...*/ dc_size)...*/
static int print_internal (struct buffer_head * bh, int first, int last) static int print_internal(struct buffer_head *bh, int first, int last)
{ {
struct reiserfs_key * key; struct reiserfs_key *key;
struct disk_child * dc; struct disk_child *dc;
int i; int i;
int from, to; int from, to;
if (!B_IS_KEYS_LEVEL (bh)) if (!B_IS_KEYS_LEVEL(bh))
return 1; return 1;
check_internal (bh); check_internal(bh);
if (first == -1) { if (first == -1) {
from = 0; from = 0;
to = B_NR_ITEMS (bh); to = B_NR_ITEMS(bh);
} else { } else {
from = first; from = first;
to = last < B_NR_ITEMS (bh) ? last : B_NR_ITEMS (bh); to = last < B_NR_ITEMS(bh) ? last : B_NR_ITEMS(bh);
} }
reiserfs_printk ("INTERNAL NODE (%ld) contains %z\n", bh->b_blocknr, bh); reiserfs_printk("INTERNAL NODE (%ld) contains %z\n", bh->b_blocknr, bh);
dc = B_N_CHILD (bh, from); dc = B_N_CHILD(bh, from);
reiserfs_printk ("PTR %d: %y ", from, dc); reiserfs_printk("PTR %d: %y ", from, dc);
for (i = from, key = B_N_PDELIM_KEY (bh, from), dc ++; i < to; i ++, key ++, dc ++) { for (i = from, key = B_N_PDELIM_KEY(bh, from), dc++; i < to;
reiserfs_printk ("KEY %d: %k PTR %d: %y ", i, key, i + 1, dc); i++, key++, dc++) {
reiserfs_printk("KEY %d: %k PTR %d: %y ", i, key, i + 1, dc);
if (i && i % 4 == 0) if (i && i % 4 == 0)
printk ("\n"); printk("\n");
} }
printk ("\n"); printk("\n");
return 0; return 0;
} }
static int print_leaf(struct buffer_head *bh, int print_mode, int first,
int last)
static int print_leaf (struct buffer_head * bh, int print_mode, int first, int last)
{ {
struct block_head * blkh; struct block_head *blkh;
struct item_head * ih; struct item_head *ih;
int i, nr; int i, nr;
int from, to; int from, to;
if (!B_IS_ITEMS_LEVEL (bh)) if (!B_IS_ITEMS_LEVEL(bh))
return 1; return 1;
check_leaf (bh); check_leaf(bh);
blkh = B_BLK_HEAD (bh); blkh = B_BLK_HEAD(bh);
ih = B_N_PITEM_HEAD (bh,0); ih = B_N_PITEM_HEAD(bh, 0);
nr = blkh_nr_item(blkh); nr = blkh_nr_item(blkh);
printk ("\n===================================================================\n"); printk
reiserfs_printk ("LEAF NODE (%ld) contains %z\n", bh->b_blocknr, bh); ("\n===================================================================\n");
reiserfs_printk("LEAF NODE (%ld) contains %z\n", bh->b_blocknr, bh);
if (!(print_mode & PRINT_LEAF_ITEMS)) { if (!(print_mode & PRINT_LEAF_ITEMS)) {
reiserfs_printk ("FIRST ITEM_KEY: %k, LAST ITEM KEY: %k\n", reiserfs_printk("FIRST ITEM_KEY: %k, LAST ITEM KEY: %k\n",
&(ih->ih_key), &((ih + nr - 1)->ih_key)); &(ih->ih_key), &((ih + nr - 1)->ih_key));
return 0; return 0;
} }
@ -457,42 +455,47 @@ static int print_leaf (struct buffer_head * bh, int print_mode, int first, int l
else else
from = first; from = first;
if (last < 0 || last > nr ) if (last < 0 || last > nr)
to = nr; to = nr;
else else
to = last; to = last;
ih += from; ih += from;
printk ("-------------------------------------------------------------------------------\n"); printk
printk ("|##| type | key | ilen | free_space | version | loc |\n"); ("-------------------------------------------------------------------------------\n");
for (i = from; i < to; i++, ih ++) { printk
printk ("-------------------------------------------------------------------------------\n"); ("|##| type | key | ilen | free_space | version | loc |\n");
reiserfs_printk ("|%2d| %h |\n", i, ih); for (i = from; i < to; i++, ih++) {
printk
("-------------------------------------------------------------------------------\n");
reiserfs_printk("|%2d| %h |\n", i, ih);
if (print_mode & PRINT_LEAF_ITEMS) if (print_mode & PRINT_LEAF_ITEMS)
op_print_item (ih, B_I_PITEM (bh, ih)); op_print_item(ih, B_I_PITEM(bh, ih));
} }
printk ("===================================================================\n"); printk
("===================================================================\n");
return 0; return 0;
} }
char * reiserfs_hashname(int code) char *reiserfs_hashname(int code)
{ {
if ( code == YURA_HASH) if (code == YURA_HASH)
return "rupasov"; return "rupasov";
if ( code == TEA_HASH) if (code == TEA_HASH)
return "tea"; return "tea";
if ( code == R5_HASH) if (code == R5_HASH)
return "r5"; return "r5";
return "unknown"; return "unknown";
} }
/* return 1 if this is not super block */ /* return 1 if this is not super block */
static int print_super_block (struct buffer_head * bh) static int print_super_block(struct buffer_head *bh)
{ {
struct reiserfs_super_block * rs = (struct reiserfs_super_block *)(bh->b_data); struct reiserfs_super_block *rs =
(struct reiserfs_super_block *)(bh->b_data);
int skipped, data_blocks; int skipped, data_blocks;
char *version; char *version;
char b[BDEVNAME_SIZE]; char b[BDEVNAME_SIZE];
@ -508,217 +511,239 @@ static int print_super_block (struct buffer_head * bh)
return 1; return 1;
} }
printk ("%s\'s super block is in block %llu\n", bdevname (bh->b_bdev, b), printk("%s\'s super block is in block %llu\n", bdevname(bh->b_bdev, b),
(unsigned long long)bh->b_blocknr); (unsigned long long)bh->b_blocknr);
printk ("Reiserfs version %s\n", version ); printk("Reiserfs version %s\n", version);
printk ("Block count %u\n", sb_block_count(rs)); printk("Block count %u\n", sb_block_count(rs));
printk ("Blocksize %d\n", sb_blocksize(rs)); printk("Blocksize %d\n", sb_blocksize(rs));
printk ("Free blocks %u\n", sb_free_blocks(rs)); printk("Free blocks %u\n", sb_free_blocks(rs));
// FIXME: this would be confusing if // FIXME: this would be confusing if
// someone stores reiserfs super block in some data block ;) // someone stores reiserfs super block in some data block ;)
// skipped = (bh->b_blocknr * bh->b_size) / sb_blocksize(rs); // skipped = (bh->b_blocknr * bh->b_size) / sb_blocksize(rs);
skipped = bh->b_blocknr; skipped = bh->b_blocknr;
data_blocks = sb_block_count(rs) - skipped - 1 - sb_bmap_nr(rs) - data_blocks = sb_block_count(rs) - skipped - 1 - sb_bmap_nr(rs) -
(!is_reiserfs_jr(rs) ? sb_jp_journal_size(rs) + 1 : sb_reserved_for_journal(rs)) - (!is_reiserfs_jr(rs) ? sb_jp_journal_size(rs) +
sb_free_blocks(rs); 1 : sb_reserved_for_journal(rs)) - sb_free_blocks(rs);
printk ("Busy blocks (skipped %d, bitmaps - %d, journal (or reserved) blocks - %d\n" printk
"1 super block, %d data blocks\n", ("Busy blocks (skipped %d, bitmaps - %d, journal (or reserved) blocks - %d\n"
skipped, sb_bmap_nr(rs), (!is_reiserfs_jr(rs) ? (sb_jp_journal_size(rs) + 1) : "1 super block, %d data blocks\n", skipped, sb_bmap_nr(rs),
sb_reserved_for_journal(rs)) , data_blocks); (!is_reiserfs_jr(rs) ? (sb_jp_journal_size(rs) + 1) :
printk ("Root block %u\n", sb_root_block(rs)); sb_reserved_for_journal(rs)), data_blocks);
printk ("Journal block (first) %d\n", sb_jp_journal_1st_block(rs)); printk("Root block %u\n", sb_root_block(rs));
printk ("Journal dev %d\n", sb_jp_journal_dev(rs)); printk("Journal block (first) %d\n", sb_jp_journal_1st_block(rs));
printk ("Journal orig size %d\n", sb_jp_journal_size(rs)); printk("Journal dev %d\n", sb_jp_journal_dev(rs));
printk ("FS state %d\n", sb_fs_state(rs)); printk("Journal orig size %d\n", sb_jp_journal_size(rs));
printk ("Hash function \"%s\"\n", printk("FS state %d\n", sb_fs_state(rs));
printk("Hash function \"%s\"\n",
reiserfs_hashname(sb_hash_function_code(rs))); reiserfs_hashname(sb_hash_function_code(rs)));
printk ("Tree height %d\n", sb_tree_height(rs)); printk("Tree height %d\n", sb_tree_height(rs));
return 0; return 0;
} }
static int print_desc_block (struct buffer_head * bh) static int print_desc_block(struct buffer_head *bh)
{ {
struct reiserfs_journal_desc * desc; struct reiserfs_journal_desc *desc;
if (memcmp(get_journal_desc_magic (bh), JOURNAL_DESC_MAGIC, 8)) if (memcmp(get_journal_desc_magic(bh), JOURNAL_DESC_MAGIC, 8))
return 1; return 1;
desc = (struct reiserfs_journal_desc *)(bh->b_data); desc = (struct reiserfs_journal_desc *)(bh->b_data);
printk ("Desc block %llu (j_trans_id %d, j_mount_id %d, j_len %d)", printk("Desc block %llu (j_trans_id %d, j_mount_id %d, j_len %d)",
(unsigned long long)bh->b_blocknr, get_desc_trans_id (desc), get_desc_mount_id (desc), (unsigned long long)bh->b_blocknr, get_desc_trans_id(desc),
get_desc_trans_len (desc)); get_desc_mount_id(desc), get_desc_trans_len(desc));
return 0; return 0;
} }
void print_block(struct buffer_head *bh, ...) //int print_mode, int first, int last)
void print_block (struct buffer_head * bh, ...)//int print_mode, int first, int last)
{ {
va_list args; va_list args;
int mode, first, last; int mode, first, last;
va_start (args, bh); va_start(args, bh);
if ( ! bh ) { if (!bh) {
printk("print_block: buffer is NULL\n"); printk("print_block: buffer is NULL\n");
return; return;
} }
mode = va_arg (args, int); mode = va_arg(args, int);
first = va_arg (args, int); first = va_arg(args, int);
last = va_arg (args, int); last = va_arg(args, int);
if (print_leaf (bh, mode, first, last)) if (print_leaf(bh, mode, first, last))
if (print_internal (bh, first, last)) if (print_internal(bh, first, last))
if (print_super_block (bh)) if (print_super_block(bh))
if (print_desc_block (bh)) if (print_desc_block(bh))
printk ("Block %llu contains unformatted data\n", (unsigned long long)bh->b_blocknr); printk
("Block %llu contains unformatted data\n",
(unsigned long long)bh->b_blocknr);
} }
static char print_tb_buf[2048]; static char print_tb_buf[2048];
/* this stores initial state of tree balance in the print_tb_buf */ /* this stores initial state of tree balance in the print_tb_buf */
void store_print_tb (struct tree_balance * tb) void store_print_tb(struct tree_balance *tb)
{ {
int h = 0; int h = 0;
int i; int i;
struct buffer_head * tbSh, * tbFh; struct buffer_head *tbSh, *tbFh;
if (!tb) if (!tb)
return; return;
sprintf (print_tb_buf, "\n" sprintf(print_tb_buf, "\n"
"BALANCING %d\n" "BALANCING %d\n"
"MODE=%c, ITEM_POS=%d POS_IN_ITEM=%d\n" "MODE=%c, ITEM_POS=%d POS_IN_ITEM=%d\n"
"=====================================================================\n" "=====================================================================\n"
"* h * S * L * R * F * FL * FR * CFL * CFR *\n", "* h * S * L * R * F * FL * FR * CFL * CFR *\n",
REISERFS_SB(tb->tb_sb)->s_do_balance, REISERFS_SB(tb->tb_sb)->s_do_balance,
tb->tb_mode, PATH_LAST_POSITION (tb->tb_path), tb->tb_path->pos_in_item); tb->tb_mode, PATH_LAST_POSITION(tb->tb_path),
tb->tb_path->pos_in_item);
for (h = 0; h < sizeof(tb->insert_size) / sizeof (tb->insert_size[0]); h ++) { for (h = 0; h < sizeof(tb->insert_size) / sizeof(tb->insert_size[0]);
if (PATH_H_PATH_OFFSET (tb->tb_path, h) <= tb->tb_path->path_length && h++) {
PATH_H_PATH_OFFSET (tb->tb_path, h) > ILLEGAL_PATH_ELEMENT_OFFSET) { if (PATH_H_PATH_OFFSET(tb->tb_path, h) <=
tbSh = PATH_H_PBUFFER (tb->tb_path, h); tb->tb_path->path_length
tbFh = PATH_H_PPARENT (tb->tb_path, h); && PATH_H_PATH_OFFSET(tb->tb_path,
h) > ILLEGAL_PATH_ELEMENT_OFFSET) {
tbSh = PATH_H_PBUFFER(tb->tb_path, h);
tbFh = PATH_H_PPARENT(tb->tb_path, h);
} else { } else {
tbSh = NULL; tbSh = NULL;
tbFh = NULL; tbFh = NULL;
} }
sprintf (print_tb_buf + strlen (print_tb_buf), sprintf(print_tb_buf + strlen(print_tb_buf),
"* %d * %3lld(%2d) * %3lld(%2d) * %3lld(%2d) * %5lld * %5lld * %5lld * %5lld * %5lld *\n", "* %d * %3lld(%2d) * %3lld(%2d) * %3lld(%2d) * %5lld * %5lld * %5lld * %5lld * %5lld *\n",
h, h,
(tbSh) ? (long long)(tbSh->b_blocknr):(-1LL), (tbSh) ? (long long)(tbSh->b_blocknr) : (-1LL),
(tbSh) ? atomic_read (&(tbSh->b_count)) : -1, (tbSh) ? atomic_read(&(tbSh->b_count)) : -1,
(tb->L[h]) ? (long long)(tb->L[h]->b_blocknr):(-1LL), (tb->L[h]) ? (long long)(tb->L[h]->b_blocknr) : (-1LL),
(tb->L[h]) ? atomic_read (&(tb->L[h]->b_count)) : -1, (tb->L[h]) ? atomic_read(&(tb->L[h]->b_count)) : -1,
(tb->R[h]) ? (long long)(tb->R[h]->b_blocknr):(-1LL), (tb->R[h]) ? (long long)(tb->R[h]->b_blocknr) : (-1LL),
(tb->R[h]) ? atomic_read (&(tb->R[h]->b_count)) : -1, (tb->R[h]) ? atomic_read(&(tb->R[h]->b_count)) : -1,
(tbFh) ? (long long)(tbFh->b_blocknr):(-1LL), (tbFh) ? (long long)(tbFh->b_blocknr) : (-1LL),
(tb->FL[h]) ? (long long)(tb->FL[h]->b_blocknr):(-1LL), (tb->FL[h]) ? (long long)(tb->FL[h]->
(tb->FR[h]) ? (long long)(tb->FR[h]->b_blocknr):(-1LL), b_blocknr) : (-1LL),
(tb->CFL[h]) ? (long long)(tb->CFL[h]->b_blocknr):(-1LL), (tb->FR[h]) ? (long long)(tb->FR[h]->
(tb->CFR[h]) ? (long long)(tb->CFR[h]->b_blocknr):(-1LL)); b_blocknr) : (-1LL),
(tb->CFL[h]) ? (long long)(tb->CFL[h]->
b_blocknr) : (-1LL),
(tb->CFR[h]) ? (long long)(tb->CFR[h]->
b_blocknr) : (-1LL));
} }
sprintf (print_tb_buf + strlen (print_tb_buf), sprintf(print_tb_buf + strlen(print_tb_buf),
"=====================================================================\n" "=====================================================================\n"
"* h * size * ln * lb * rn * rb * blkn * s0 * s1 * s1b * s2 * s2b * curb * lk * rk *\n" "* h * size * ln * lb * rn * rb * blkn * s0 * s1 * s1b * s2 * s2b * curb * lk * rk *\n"
"* 0 * %4d * %2d * %2d * %2d * %2d * %4d * %2d * %2d * %3d * %2d * %3d * %4d * %2d * %2d *\n", "* 0 * %4d * %2d * %2d * %2d * %2d * %4d * %2d * %2d * %3d * %2d * %3d * %4d * %2d * %2d *\n",
tb->insert_size[0], tb->lnum[0], tb->lbytes, tb->rnum[0],tb->rbytes, tb->blknum[0], tb->insert_size[0], tb->lnum[0], tb->lbytes, tb->rnum[0],
tb->s0num, tb->s1num,tb->s1bytes, tb->s2num, tb->s2bytes, tb->cur_blknum, tb->lkey[0], tb->rkey[0]); tb->rbytes, tb->blknum[0], tb->s0num, tb->s1num, tb->s1bytes,
tb->s2num, tb->s2bytes, tb->cur_blknum, tb->lkey[0],
tb->rkey[0]);
/* this prints balance parameters for non-leaf levels */ /* this prints balance parameters for non-leaf levels */
h = 0; h = 0;
do { do {
h++; h++;
sprintf (print_tb_buf + strlen (print_tb_buf), sprintf(print_tb_buf + strlen(print_tb_buf),
"* %d * %4d * %2d * * %2d * * %2d *\n", "* %d * %4d * %2d * * %2d * * %2d *\n",
h, tb->insert_size[h], tb->lnum[h], tb->rnum[h], tb->blknum[h]); h, tb->insert_size[h], tb->lnum[h], tb->rnum[h],
tb->blknum[h]);
} while (tb->insert_size[h]); } while (tb->insert_size[h]);
sprintf (print_tb_buf + strlen (print_tb_buf), sprintf(print_tb_buf + strlen(print_tb_buf),
"=====================================================================\n" "=====================================================================\n"
"FEB list: "); "FEB list: ");
/* print FEB list (list of buffers in form (bh (b_blocknr, b_count), that will be used for new nodes) */ /* print FEB list (list of buffers in form (bh (b_blocknr, b_count), that will be used for new nodes) */
h = 0; h = 0;
for (i = 0; i < sizeof (tb->FEB) / sizeof (tb->FEB[0]); i ++) for (i = 0; i < sizeof(tb->FEB) / sizeof(tb->FEB[0]); i++)
sprintf (print_tb_buf + strlen (print_tb_buf), sprintf(print_tb_buf + strlen(print_tb_buf),
"%p (%llu %d)%s", tb->FEB[i], tb->FEB[i] ? (unsigned long long)tb->FEB[i]->b_blocknr : 0ULL, "%p (%llu %d)%s", tb->FEB[i],
tb->FEB[i] ? atomic_read (&(tb->FEB[i]->b_count)) : 0, tb->FEB[i] ? (unsigned long long)tb->FEB[i]->
(i == sizeof (tb->FEB) / sizeof (tb->FEB[0]) - 1) ? "\n" : ", "); b_blocknr : 0ULL,
tb->FEB[i] ? atomic_read(&(tb->FEB[i]->b_count)) : 0,
(i ==
sizeof(tb->FEB) / sizeof(tb->FEB[0]) -
1) ? "\n" : ", ");
sprintf (print_tb_buf + strlen (print_tb_buf), sprintf(print_tb_buf + strlen(print_tb_buf),
"======================== the end ====================================\n"); "======================== the end ====================================\n");
} }
void print_cur_tb (char * mes) void print_cur_tb(char *mes)
{ {
printk ("%s\n%s", mes, print_tb_buf); printk("%s\n%s", mes, print_tb_buf);
} }
static void check_leaf_block_head (struct buffer_head * bh) static void check_leaf_block_head(struct buffer_head *bh)
{ {
struct block_head * blkh; struct block_head *blkh;
int nr; int nr;
blkh = B_BLK_HEAD (bh); blkh = B_BLK_HEAD(bh);
nr = blkh_nr_item(blkh); nr = blkh_nr_item(blkh);
if ( nr > (bh->b_size - BLKH_SIZE) / IH_SIZE) if (nr > (bh->b_size - BLKH_SIZE) / IH_SIZE)
reiserfs_panic (NULL, "vs-6010: check_leaf_block_head: invalid item number %z", bh); reiserfs_panic(NULL,
if ( blkh_free_space(blkh) > "vs-6010: check_leaf_block_head: invalid item number %z",
bh->b_size - BLKH_SIZE - IH_SIZE * nr ) bh);
reiserfs_panic (NULL, "vs-6020: check_leaf_block_head: invalid free space %z", bh); if (blkh_free_space(blkh) > bh->b_size - BLKH_SIZE - IH_SIZE * nr)
reiserfs_panic(NULL,
"vs-6020: check_leaf_block_head: invalid free space %z",
bh);
} }
static void check_internal_block_head (struct buffer_head * bh) static void check_internal_block_head(struct buffer_head *bh)
{ {
struct block_head * blkh; struct block_head *blkh;
blkh = B_BLK_HEAD (bh); blkh = B_BLK_HEAD(bh);
if (!(B_LEVEL (bh) > DISK_LEAF_NODE_LEVEL && B_LEVEL (bh) <= MAX_HEIGHT)) if (!(B_LEVEL(bh) > DISK_LEAF_NODE_LEVEL && B_LEVEL(bh) <= MAX_HEIGHT))
reiserfs_panic (NULL, "vs-6025: check_internal_block_head: invalid level %z", bh); reiserfs_panic(NULL,
"vs-6025: check_internal_block_head: invalid level %z",
bh);
if (B_NR_ITEMS (bh) > (bh->b_size - BLKH_SIZE) / IH_SIZE) if (B_NR_ITEMS(bh) > (bh->b_size - BLKH_SIZE) / IH_SIZE)
reiserfs_panic (NULL, "vs-6030: check_internal_block_head: invalid item number %z", bh); reiserfs_panic(NULL,
"vs-6030: check_internal_block_head: invalid item number %z",
bh);
if (B_FREE_SPACE (bh) != if (B_FREE_SPACE(bh) !=
bh->b_size - BLKH_SIZE - KEY_SIZE * B_NR_ITEMS (bh) - DC_SIZE * (B_NR_ITEMS (bh) + 1)) bh->b_size - BLKH_SIZE - KEY_SIZE * B_NR_ITEMS(bh) -
reiserfs_panic (NULL, "vs-6040: check_internal_block_head: invalid free space %z", bh); DC_SIZE * (B_NR_ITEMS(bh) + 1))
reiserfs_panic(NULL,
"vs-6040: check_internal_block_head: invalid free space %z",
bh);
} }
void check_leaf(struct buffer_head *bh)
void check_leaf (struct buffer_head * bh)
{ {
int i; int i;
struct item_head * ih; struct item_head *ih;
if (!bh) if (!bh)
return; return;
check_leaf_block_head (bh); check_leaf_block_head(bh);
for (i = 0, ih = B_N_PITEM_HEAD (bh, 0); i < B_NR_ITEMS (bh); i ++, ih ++) for (i = 0, ih = B_N_PITEM_HEAD(bh, 0); i < B_NR_ITEMS(bh); i++, ih++)
op_check_item (ih, B_I_PITEM (bh, ih)); op_check_item(ih, B_I_PITEM(bh, ih));
} }
void check_internal(struct buffer_head *bh)
void check_internal (struct buffer_head * bh)
{ {
if (!bh) if (!bh)
return; return;
check_internal_block_head (bh); check_internal_block_head(bh);
} }
void print_statistics(struct super_block *s)
void print_statistics (struct super_block * s)
{ {
/* /*
printk ("reiserfs_put_super: session statistics: balances %d, fix_nodes %d, \ printk ("reiserfs_put_super: session statistics: balances %d, fix_nodes %d, \
bmap with search %d, without %d, dir2ind %d, ind2dir %d\n", bmap with search %d, without %d, dir2ind %d, ind2dir %d\n",
REISERFS_SB(s)->s_do_balance, REISERFS_SB(s)->s_fix_nodes, REISERFS_SB(s)->s_do_balance, REISERFS_SB(s)->s_fix_nodes,
REISERFS_SB(s)->s_bmaps, REISERFS_SB(s)->s_bmaps_without_search, REISERFS_SB(s)->s_bmaps, REISERFS_SB(s)->s_bmaps_without_search,
REISERFS_SB(s)->s_direct2indirect, REISERFS_SB(s)->s_indirect2direct); REISERFS_SB(s)->s_direct2indirect, REISERFS_SB(s)->s_indirect2direct);

383
fs/reiserfs/procfs.c
View file

@ -34,16 +34,15 @@ static int show_version(struct seq_file *m, struct super_block *sb)
{ {
char *format; char *format;
if ( REISERFS_SB(sb)->s_properties & (1 << REISERFS_3_6) ) { if (REISERFS_SB(sb)->s_properties & (1 << REISERFS_3_6)) {
format = "3.6"; format = "3.6";
} else if ( REISERFS_SB(sb)->s_properties & (1 << REISERFS_3_5) ) { } else if (REISERFS_SB(sb)->s_properties & (1 << REISERFS_3_5)) {
format = "3.5"; format = "3.5";
} else { } else {
format = "unknown"; format = "unknown";
} }
seq_printf(m, "%s format\twith checks %s\n", seq_printf(m, "%s format\twith checks %s\n", format,
format,
#if defined( CONFIG_REISERFS_CHECK ) #if defined( CONFIG_REISERFS_CHECK )
"on" "on"
#else #else
@ -53,8 +52,8 @@ static int show_version(struct seq_file *m, struct super_block *sb)
return 0; return 0;
} }
int reiserfs_global_version_in_proc( char *buffer, char **start, off_t offset, int reiserfs_global_version_in_proc(char *buffer, char **start, off_t offset,
int count, int *eof, void *data ) int count, int *eof, void *data)
{ {
*start = buffer; *start = buffer;
*eof = 1; *eof = 1;
@ -102,64 +101,45 @@ static int show_super(struct seq_file *m, struct super_block *sb)
"s_indirect2direct: \t%i\n" "s_indirect2direct: \t%i\n"
"\n" "\n"
"max_hash_collisions: \t%i\n" "max_hash_collisions: \t%i\n"
"breads: \t%lu\n" "breads: \t%lu\n"
"bread_misses: \t%lu\n" "bread_misses: \t%lu\n"
"search_by_key: \t%lu\n" "search_by_key: \t%lu\n"
"search_by_key_fs_changed: \t%lu\n" "search_by_key_fs_changed: \t%lu\n"
"search_by_key_restarted: \t%lu\n" "search_by_key_restarted: \t%lu\n"
"insert_item_restarted: \t%lu\n" "insert_item_restarted: \t%lu\n"
"paste_into_item_restarted: \t%lu\n" "paste_into_item_restarted: \t%lu\n"
"cut_from_item_restarted: \t%lu\n" "cut_from_item_restarted: \t%lu\n"
"delete_solid_item_restarted: \t%lu\n" "delete_solid_item_restarted: \t%lu\n"
"delete_item_restarted: \t%lu\n" "delete_item_restarted: \t%lu\n"
"leaked_oid: \t%lu\n" "leaked_oid: \t%lu\n"
"leaves_removable: \t%lu\n", "leaves_removable: \t%lu\n",
SF(s_mount_state) == REISERFS_VALID_FS ?
SF( s_mount_state ) == REISERFS_VALID_FS ?
"REISERFS_VALID_FS" : "REISERFS_ERROR_FS", "REISERFS_VALID_FS" : "REISERFS_ERROR_FS",
reiserfs_r5_hash( sb ) ? "FORCE_R5 " : "", reiserfs_r5_hash(sb) ? "FORCE_R5 " : "",
reiserfs_rupasov_hash( sb ) ? "FORCE_RUPASOV " : "", reiserfs_rupasov_hash(sb) ? "FORCE_RUPASOV " : "",
reiserfs_tea_hash( sb ) ? "FORCE_TEA " : "", reiserfs_tea_hash(sb) ? "FORCE_TEA " : "",
reiserfs_hash_detect( sb ) ? "DETECT_HASH " : "", reiserfs_hash_detect(sb) ? "DETECT_HASH " : "",
reiserfs_no_border( sb ) ? "NO_BORDER " : "BORDER ", reiserfs_no_border(sb) ? "NO_BORDER " : "BORDER ",
reiserfs_no_unhashed_relocation( sb ) ? "NO_UNHASHED_RELOCATION " : "", reiserfs_no_unhashed_relocation(sb) ?
reiserfs_hashed_relocation( sb ) ? "UNHASHED_RELOCATION " : "", "NO_UNHASHED_RELOCATION " : "",
reiserfs_test4( sb ) ? "TEST4 " : "", reiserfs_hashed_relocation(sb) ? "UNHASHED_RELOCATION " : "",
have_large_tails( sb ) ? "TAILS " : have_small_tails(sb)?"SMALL_TAILS ":"NO_TAILS ", reiserfs_test4(sb) ? "TEST4 " : "",
replay_only( sb ) ? "REPLAY_ONLY " : "", have_large_tails(sb) ? "TAILS " : have_small_tails(sb) ?
convert_reiserfs( sb ) ? "CONV " : "", "SMALL_TAILS " : "NO_TAILS ",
replay_only(sb) ? "REPLAY_ONLY " : "",
atomic_read( &r -> s_generation_counter ), convert_reiserfs(sb) ? "CONV " : "",
SF( s_kmallocs ), atomic_read(&r->s_generation_counter), SF(s_kmallocs),
SF( s_disk_reads ), SF(s_disk_reads), SF(s_disk_writes), SF(s_fix_nodes),
SF( s_disk_writes ), SF(s_do_balance), SF(s_unneeded_left_neighbor),
SF( s_fix_nodes ), SF(s_good_search_by_key_reada), SF(s_bmaps),
SF( s_do_balance ), SF(s_bmaps_without_search), SF(s_direct2indirect),
SF( s_unneeded_left_neighbor ), SF(s_indirect2direct), SFP(max_hash_collisions), SFP(breads),
SF( s_good_search_by_key_reada ), SFP(bread_miss), SFP(search_by_key),
SF( s_bmaps ), SFP(search_by_key_fs_changed), SFP(search_by_key_restarted),
SF( s_bmaps_without_search ), SFP(insert_item_restarted), SFP(paste_into_item_restarted),
SF( s_direct2indirect ), SFP(cut_from_item_restarted),
SF( s_indirect2direct ), SFP(delete_solid_item_restarted), SFP(delete_item_restarted),
SFP( max_hash_collisions ), SFP(leaked_oid), SFP(leaves_removable));
SFP( breads ),
SFP( bread_miss ),
SFP( search_by_key ),
SFP( search_by_key_fs_changed ),
SFP( search_by_key_restarted ),
SFP( insert_item_restarted ),
SFP( paste_into_item_restarted ),
SFP( cut_from_item_restarted ),
SFP( delete_solid_item_restarted ),
SFP( delete_item_restarted ),
SFP( leaked_oid ),
SFP( leaves_removable ) );
return 0; return 0;
} }
@ -182,14 +162,9 @@ static int show_per_level(struct seq_file *m, struct super_block *sb)
" lbytes" " lbytes"
" rbytes" " rbytes"
" get_neig" " get_neig"
" get_neig_res" " get_neig_res" " need_l_neig" " need_r_neig" "\n");
" need_l_neig"
" need_r_neig"
"\n"
); for (level = 0; level < MAX_HEIGHT; ++level) {
for( level = 0 ; level < MAX_HEIGHT ; ++ level ) {
seq_printf(m, "%i\t" seq_printf(m, "%i\t"
" %12lu" " %12lu"
" %12lu" " %12lu"
@ -208,21 +183,20 @@ static int show_per_level(struct seq_file *m, struct super_block *sb)
" %12lu" " %12lu"
"\n", "\n",
level, level,
SFPL( balance_at ), SFPL(balance_at),
SFPL( sbk_read_at ), SFPL(sbk_read_at),
SFPL( sbk_fs_changed ), SFPL(sbk_fs_changed),
SFPL( sbk_restarted ), SFPL(sbk_restarted),
SFPL( free_at ), SFPL(free_at),
SFPL( items_at ), SFPL(items_at),
SFPL( can_node_be_removed ), SFPL(can_node_be_removed),
SFPL( lnum ), SFPL(lnum),
SFPL( rnum ), SFPL(rnum),
SFPL( lbytes ), SFPL(lbytes),
SFPL( rbytes ), SFPL(rbytes),
SFPL( get_neighbors ), SFPL(get_neighbors),
SFPL( get_neighbors_restart ), SFPL(get_neighbors_restart),
SFPL( need_l_neighbor ), SFPL(need_l_neighbor), SFPL(need_r_neighbor)
SFPL( need_r_neighbor )
); );
} }
return 0; return 0;
@ -249,14 +223,13 @@ static int show_bitmap(struct seq_file *m, struct super_block *sb)
" %14lu" " %14lu"
" %14lu" " %14lu"
"\n", "\n",
SFP( free_block ), SFP(free_block),
SFPF( call ), SFPF(call),
SFPF( wait ), SFPF(wait),
SFPF( bmap ), SFPF(bmap),
SFPF( retry ), SFPF(retry),
SFPF( stolen ), SFPF(stolen),
SFPF( in_journal_hint ), SFPF(in_journal_hint), SFPF(in_journal_nohint));
SFPF( in_journal_nohint ) );
return 0; return 0;
} }
@ -264,9 +237,9 @@ static int show_bitmap(struct seq_file *m, struct super_block *sb)
static int show_on_disk_super(struct seq_file *m, struct super_block *sb) static int show_on_disk_super(struct seq_file *m, struct super_block *sb)
{ {
struct reiserfs_sb_info *sb_info = REISERFS_SB(sb); struct reiserfs_sb_info *sb_info = REISERFS_SB(sb);
struct reiserfs_super_block *rs = sb_info -> s_rs; struct reiserfs_super_block *rs = sb_info->s_rs;
int hash_code = DFL( s_hash_function_code ); int hash_code = DFL(s_hash_function_code);
__u32 flags = DJF( s_flags ); __u32 flags = DJF(s_flags);
seq_printf(m, "block_count: \t%i\n" seq_printf(m, "block_count: \t%i\n"
"free_blocks: \t%i\n" "free_blocks: \t%i\n"
@ -283,27 +256,23 @@ static int show_on_disk_super(struct seq_file *m, struct super_block *sb)
"version: \t%i\n" "version: \t%i\n"
"flags: \t%x[%s]\n" "flags: \t%x[%s]\n"
"reserved_for_journal: \t%i\n", "reserved_for_journal: \t%i\n",
DFL(s_block_count),
DFL( s_block_count ), DFL(s_free_blocks),
DFL( s_free_blocks ), DFL(s_root_block),
DFL( s_root_block ), DF(s_blocksize),
DF( s_blocksize ), DF(s_oid_maxsize),
DF( s_oid_maxsize ), DF(s_oid_cursize),
DF( s_oid_cursize ), DF(s_umount_state),
DF( s_umount_state ), rs->s_v1.s_magic,
rs -> s_v1.s_magic, DF(s_fs_state),
DF( s_fs_state ),
hash_code == TEA_HASH ? "tea" : hash_code == TEA_HASH ? "tea" :
( hash_code == YURA_HASH ) ? "rupasov" : (hash_code == YURA_HASH) ? "rupasov" :
( hash_code == R5_HASH ) ? "r5" : (hash_code == R5_HASH) ? "r5" :
( hash_code == UNSET_HASH ) ? "unset" : "unknown", (hash_code == UNSET_HASH) ? "unset" : "unknown",
DF( s_tree_height ), DF(s_tree_height),
DF( s_bmap_nr ), DF(s_bmap_nr),
DF( s_version ), DF(s_version), flags, (flags & reiserfs_attrs_cleared)
flags, ? "attrs_cleared" : "", DF(s_reserved_for_journal));
( flags & reiserfs_attrs_cleared )
? "attrs_cleared" : "",
DF (s_reserved_for_journal));
return 0; return 0;
} }
@ -311,42 +280,40 @@ static int show_on_disk_super(struct seq_file *m, struct super_block *sb)
static int show_oidmap(struct seq_file *m, struct super_block *sb) static int show_oidmap(struct seq_file *m, struct super_block *sb)
{ {
struct reiserfs_sb_info *sb_info = REISERFS_SB(sb); struct reiserfs_sb_info *sb_info = REISERFS_SB(sb);
struct reiserfs_super_block *rs = sb_info -> s_rs; struct reiserfs_super_block *rs = sb_info->s_rs;
unsigned int mapsize = le16_to_cpu( rs -> s_v1.s_oid_cursize ); unsigned int mapsize = le16_to_cpu(rs->s_v1.s_oid_cursize);
unsigned long total_used = 0; unsigned long total_used = 0;
int i; int i;
for( i = 0 ; i < mapsize ; ++i ) { for (i = 0; i < mapsize; ++i) {
__u32 right; __u32 right;
right = ( i == mapsize - 1 ) ? MAX_KEY_OBJECTID : MAP( i + 1 ); right = (i == mapsize - 1) ? MAX_KEY_OBJECTID : MAP(i + 1);
seq_printf(m, "%s: [ %x .. %x )\n", seq_printf(m, "%s: [ %x .. %x )\n",
( i & 1 ) ? "free" : "used", MAP( i ), right ); (i & 1) ? "free" : "used", MAP(i), right);
if( ! ( i & 1 ) ) { if (!(i & 1)) {
total_used += right - MAP( i ); total_used += right - MAP(i);
} }
} }
#if defined( REISERFS_USE_OIDMAPF ) #if defined( REISERFS_USE_OIDMAPF )
if( sb_info -> oidmap.use_file && ( sb_info -> oidmap.mapf != NULL ) ) { if (sb_info->oidmap.use_file && (sb_info->oidmap.mapf != NULL)) {
loff_t size = sb_info->oidmap.mapf->f_dentry->d_inode->i_size; loff_t size = sb_info->oidmap.mapf->f_dentry->d_inode->i_size;
total_used += size / sizeof( reiserfs_oidinterval_d_t ); total_used += size / sizeof(reiserfs_oidinterval_d_t);
} }
#endif #endif
seq_printf(m, "total: \t%i [%i/%i] used: %lu [exact]\n", seq_printf(m, "total: \t%i [%i/%i] used: %lu [exact]\n",
mapsize, mapsize,
mapsize, le16_to_cpu( rs -> s_v1.s_oid_maxsize ), mapsize, le16_to_cpu(rs->s_v1.s_oid_maxsize), total_used);
total_used);
return 0; return 0;
} }
static int show_journal(struct seq_file *m, struct super_block *sb) static int show_journal(struct seq_file *m, struct super_block *sb)
{ {
struct reiserfs_sb_info *r = REISERFS_SB(sb); struct reiserfs_sb_info *r = REISERFS_SB(sb);
struct reiserfs_super_block *rs = r -> s_rs; struct reiserfs_super_block *rs = r->s_rs;
struct journal_params *jp = &rs->s_v1.s_journal; struct journal_params *jp = &rs->s_v1.s_journal;
char b[BDEVNAME_SIZE]; char b[BDEVNAME_SIZE];
seq_printf(m, /* on-disk fields */ seq_printf(m, /* on-disk fields */
"jp_journal_1st_block: \t%i\n" "jp_journal_1st_block: \t%i\n"
"jp_journal_dev: \t%s[%x]\n" "jp_journal_dev: \t%s[%x]\n"
@ -373,9 +340,7 @@ static int show_journal(struct seq_file *m, struct super_block *sb)
"j_must_wait: \t%i\n" "j_must_wait: \t%i\n"
"j_next_full_flush: \t%i\n" "j_next_full_flush: \t%i\n"
"j_next_async_flush: \t%i\n" "j_next_async_flush: \t%i\n"
"j_cnode_used: \t%i\n" "j_cnode_used: \t%i\n" "j_cnode_free: \t%i\n" "\n"
"j_cnode_free: \t%i\n"
"\n"
/* reiserfs_proc_info_data_t.journal fields */ /* reiserfs_proc_info_data_t.journal fields */
"in_journal: \t%12lu\n" "in_journal: \t%12lu\n"
"in_journal_bitmap: \t%12lu\n" "in_journal_bitmap: \t%12lu\n"
@ -391,50 +356,45 @@ static int show_journal(struct seq_file *m, struct super_block *sb)
"restore_prepared: \t%12lu\n" "restore_prepared: \t%12lu\n"
"prepare: \t%12lu\n" "prepare: \t%12lu\n"
"prepare_retry: \t%12lu\n", "prepare_retry: \t%12lu\n",
DJP(jp_journal_1st_block),
DJP( jp_journal_1st_block ),
bdevname(SB_JOURNAL(sb)->j_dev_bd, b), bdevname(SB_JOURNAL(sb)->j_dev_bd, b),
DJP( jp_journal_dev ), DJP(jp_journal_dev),
DJP( jp_journal_size ), DJP(jp_journal_size),
DJP( jp_journal_trans_max ), DJP(jp_journal_trans_max),
DJP( jp_journal_magic ), DJP(jp_journal_magic),
DJP( jp_journal_max_batch ), DJP(jp_journal_max_batch),
SB_JOURNAL(sb)->j_max_commit_age, SB_JOURNAL(sb)->j_max_commit_age,
DJP( jp_journal_max_trans_age ), DJP(jp_journal_max_trans_age),
JF(j_1st_reserved_block),
JF( j_1st_reserved_block ), JF(j_state),
JF( j_state ), JF(j_trans_id),
JF( j_trans_id ), JF(j_mount_id),
JF( j_mount_id ), JF(j_start),
JF( j_start ), JF(j_len),
JF( j_len ), JF(j_len_alloc),
JF( j_len_alloc ), atomic_read(&r->s_journal->j_wcount),
atomic_read( & r -> s_journal -> j_wcount ), JF(j_bcount),
JF( j_bcount ), JF(j_first_unflushed_offset),
JF( j_first_unflushed_offset ), JF(j_last_flush_trans_id),
JF( j_last_flush_trans_id ), JF(j_trans_start_time),
JF( j_trans_start_time ), JF(j_list_bitmap_index),
JF( j_list_bitmap_index ), JF(j_must_wait),
JF( j_must_wait ), JF(j_next_full_flush),
JF( j_next_full_flush ), JF(j_next_async_flush),
JF( j_next_async_flush ), JF(j_cnode_used),
JF( j_cnode_used ), JF(j_cnode_free),
JF( j_cnode_free ), SFPJ(in_journal),
SFPJ(in_journal_bitmap),
SFPJ( in_journal ), SFPJ(in_journal_reusable),
SFPJ( in_journal_bitmap ), SFPJ(lock_journal),
SFPJ( in_journal_reusable ), SFPJ(lock_journal_wait),
SFPJ( lock_journal ), SFPJ(journal_being),
SFPJ( lock_journal_wait ), SFPJ(journal_relock_writers),
SFPJ( journal_being ), SFPJ(journal_relock_wcount),
SFPJ( journal_relock_writers ), SFPJ(mark_dirty),
SFPJ( journal_relock_wcount ), SFPJ(mark_dirty_already),
SFPJ( mark_dirty ), SFPJ(mark_dirty_notjournal),
SFPJ( mark_dirty_already ), SFPJ(restore_prepared), SFPJ(prepare), SFPJ(prepare_retry)
SFPJ( mark_dirty_notjournal ),
SFPJ( restore_prepared ),
SFPJ( prepare ),
SFPJ( prepare_retry )
); );
return 0; return 0;
} }
@ -450,7 +410,7 @@ static int set_sb(struct super_block *sb, void *data)
return -ENOENT; return -ENOENT;
} }
static void *r_start(struct seq_file *m, loff_t *pos) static void *r_start(struct seq_file *m, loff_t * pos)
{ {
struct proc_dir_entry *de = m->private; struct proc_dir_entry *de = m->private;
struct super_block *s = de->parent->data; struct super_block *s = de->parent->data;
@ -472,7 +432,7 @@ static void *r_start(struct seq_file *m, loff_t *pos)
return s; return s;
} }
static void *r_next(struct seq_file *m, void *v, loff_t *pos) static void *r_next(struct seq_file *m, void *v, loff_t * pos)
{ {
++*pos; ++*pos;
if (v) if (v)
@ -489,7 +449,7 @@ static void r_stop(struct seq_file *m, void *v)
static int r_show(struct seq_file *m, void *v) static int r_show(struct seq_file *m, void *v)
{ {
struct proc_dir_entry *de = m->private; struct proc_dir_entry *de = m->private;
int (*show)(struct seq_file *, struct super_block *) = de->data; int (*show) (struct seq_file *, struct super_block *) = de->data;
return show(m, v); return show(m, v);
} }
@ -522,7 +482,7 @@ static struct proc_dir_entry *proc_info_root = NULL;
static const char proc_info_root_name[] = "fs/reiserfs"; static const char proc_info_root_name[] = "fs/reiserfs";
static void add_file(struct super_block *sb, char *name, static void add_file(struct super_block *sb, char *name,
int (*func)(struct seq_file *, struct super_block *)) int (*func) (struct seq_file *, struct super_block *))
{ {
struct proc_dir_entry *de; struct proc_dir_entry *de;
de = create_proc_entry(name, 0, REISERFS_SB(sb)->procdir); de = create_proc_entry(name, 0, REISERFS_SB(sb)->procdir);
@ -532,11 +492,12 @@ static void add_file(struct super_block *sb, char *name,
} }
} }
int reiserfs_proc_info_init( struct super_block *sb ) int reiserfs_proc_info_init(struct super_block *sb)
{ {
spin_lock_init( & __PINFO( sb ).lock ); spin_lock_init(&__PINFO(sb).lock);
REISERFS_SB(sb)->procdir = proc_mkdir(reiserfs_bdevname (sb), proc_info_root); REISERFS_SB(sb)->procdir =
if( REISERFS_SB(sb)->procdir ) { proc_mkdir(reiserfs_bdevname(sb), proc_info_root);
if (REISERFS_SB(sb)->procdir) {
REISERFS_SB(sb)->procdir->owner = THIS_MODULE; REISERFS_SB(sb)->procdir->owner = THIS_MODULE;
REISERFS_SB(sb)->procdir->data = sb; REISERFS_SB(sb)->procdir->data = sb;
add_file(sb, "version", show_version); add_file(sb, "version", show_version);
@ -549,11 +510,11 @@ int reiserfs_proc_info_init( struct super_block *sb )
return 0; return 0;
} }
reiserfs_warning(sb, "reiserfs: cannot create /proc/%s/%s", reiserfs_warning(sb, "reiserfs: cannot create /proc/%s/%s",
proc_info_root_name, reiserfs_bdevname (sb) ); proc_info_root_name, reiserfs_bdevname(sb));
return 1; return 1;
} }
int reiserfs_proc_info_done( struct super_block *sb ) int reiserfs_proc_info_done(struct super_block *sb)
{ {
struct proc_dir_entry *de = REISERFS_SB(sb)->procdir; struct proc_dir_entry *de = REISERFS_SB(sb)->procdir;
if (de) { if (de) {
@ -565,48 +526,48 @@ int reiserfs_proc_info_done( struct super_block *sb )
remove_proc_entry("super", de); remove_proc_entry("super", de);
remove_proc_entry("version", de); remove_proc_entry("version", de);
} }
spin_lock( & __PINFO( sb ).lock ); spin_lock(&__PINFO(sb).lock);
__PINFO( sb ).exiting = 1; __PINFO(sb).exiting = 1;
spin_unlock( & __PINFO( sb ).lock ); spin_unlock(&__PINFO(sb).lock);
if ( proc_info_root ) { if (proc_info_root) {
remove_proc_entry( reiserfs_bdevname (sb), proc_info_root ); remove_proc_entry(reiserfs_bdevname(sb), proc_info_root);
REISERFS_SB(sb)->procdir = NULL; REISERFS_SB(sb)->procdir = NULL;
} }
return 0; return 0;
} }
struct proc_dir_entry *reiserfs_proc_register_global( char *name, struct proc_dir_entry *reiserfs_proc_register_global(char *name,
read_proc_t *func ) read_proc_t * func)
{ {
return ( proc_info_root ) ? create_proc_read_entry( name, 0, return (proc_info_root) ? create_proc_read_entry(name, 0,
proc_info_root, proc_info_root,
func, NULL ) : NULL; func, NULL) : NULL;
} }
void reiserfs_proc_unregister_global( const char *name ) void reiserfs_proc_unregister_global(const char *name)
{ {
remove_proc_entry( name, proc_info_root ); remove_proc_entry(name, proc_info_root);
} }
int reiserfs_proc_info_global_init( void ) int reiserfs_proc_info_global_init(void)
{ {
if( proc_info_root == NULL ) { if (proc_info_root == NULL) {
proc_info_root = proc_mkdir(proc_info_root_name, NULL); proc_info_root = proc_mkdir(proc_info_root_name, NULL);
if( proc_info_root ) { if (proc_info_root) {
proc_info_root -> owner = THIS_MODULE; proc_info_root->owner = THIS_MODULE;
} else { } else {
reiserfs_warning (NULL, reiserfs_warning(NULL,
"reiserfs: cannot create /proc/%s", "reiserfs: cannot create /proc/%s",
proc_info_root_name ); proc_info_root_name);
return 1; return 1;
} }
} }
return 0; return 0;
} }
int reiserfs_proc_info_global_done( void ) int reiserfs_proc_info_global_done(void)
{ {
if ( proc_info_root != NULL ) { if (proc_info_root != NULL) {
proc_info_root = NULL; proc_info_root = NULL;
remove_proc_entry(proc_info_root_name, NULL); remove_proc_entry(proc_info_root_name, NULL);
} }
@ -616,22 +577,40 @@ int reiserfs_proc_info_global_done( void )
/* REISERFS_PROC_INFO */ /* REISERFS_PROC_INFO */
#else #else
int reiserfs_proc_info_init( struct super_block *sb ) { return 0; } int reiserfs_proc_info_init(struct super_block *sb)
int reiserfs_proc_info_done( struct super_block *sb ) { return 0; } {
return 0;
}
int reiserfs_proc_info_done(struct super_block *sb)
{
return 0;
}
struct proc_dir_entry *reiserfs_proc_register_global( char *name, struct proc_dir_entry *reiserfs_proc_register_global(char *name,
read_proc_t *func ) read_proc_t * func)
{ return NULL; } {
return NULL;
}
void reiserfs_proc_unregister_global( const char *name ) {;} void reiserfs_proc_unregister_global(const char *name)
{;
}
int reiserfs_proc_info_global_init( void ) { return 0; } int reiserfs_proc_info_global_init(void)
int reiserfs_proc_info_global_done( void ) { return 0; } {
return 0;
}
int reiserfs_proc_info_global_done(void)
{
return 0;
}
int reiserfs_global_version_in_proc( char *buffer, char **start, int reiserfs_global_version_in_proc(char *buffer, char **start,
off_t offset, off_t offset,
int count, int *eof, void *data ) int count, int *eof, void *data)
{ return 0; } {
return 0;
}
/* REISERFS_PROC_INFO */ /* REISERFS_PROC_INFO */
#endif #endif

77
fs/reiserfs/resize.c
View file

@ -17,23 +17,23 @@
#include <linux/reiserfs_fs_sb.h> #include <linux/reiserfs_fs_sb.h>
#include <linux/buffer_head.h> #include <linux/buffer_head.h>
int reiserfs_resize (struct super_block * s, unsigned long block_count_new) int reiserfs_resize(struct super_block *s, unsigned long block_count_new)
{ {
int err = 0; int err = 0;
struct reiserfs_super_block * sb; struct reiserfs_super_block *sb;
struct reiserfs_bitmap_info *bitmap; struct reiserfs_bitmap_info *bitmap;
struct reiserfs_bitmap_info *old_bitmap = SB_AP_BITMAP(s); struct reiserfs_bitmap_info *old_bitmap = SB_AP_BITMAP(s);
struct buffer_head * bh; struct buffer_head *bh;
struct reiserfs_transaction_handle th; struct reiserfs_transaction_handle th;
unsigned int bmap_nr_new, bmap_nr; unsigned int bmap_nr_new, bmap_nr;
unsigned int block_r_new, block_r; unsigned int block_r_new, block_r;
struct reiserfs_list_bitmap * jb; struct reiserfs_list_bitmap *jb;
struct reiserfs_list_bitmap jbitmap[JOURNAL_NUM_BITMAPS]; struct reiserfs_list_bitmap jbitmap[JOURNAL_NUM_BITMAPS];
unsigned long int block_count, free_blocks; unsigned long int block_count, free_blocks;
int i; int i;
int copy_size ; int copy_size;
sb = SB_DISK_SUPER_BLOCK(s); sb = SB_DISK_SUPER_BLOCK(s);
@ -53,17 +53,17 @@ int reiserfs_resize (struct super_block * s, unsigned long block_count_new)
/* old disk layout detection; those partitions can be mounted, but /* old disk layout detection; those partitions can be mounted, but
* cannot be resized */ * cannot be resized */
if (SB_BUFFER_WITH_SB(s)->b_blocknr * SB_BUFFER_WITH_SB(s)->b_size if (SB_BUFFER_WITH_SB(s)->b_blocknr * SB_BUFFER_WITH_SB(s)->b_size
!= REISERFS_DISK_OFFSET_IN_BYTES ) { != REISERFS_DISK_OFFSET_IN_BYTES) {
printk("reiserfs_resize: unable to resize a reiserfs without distributed bitmap (fs version < 3.5.12)\n"); printk
("reiserfs_resize: unable to resize a reiserfs without distributed bitmap (fs version < 3.5.12)\n");
return -ENOTSUPP; return -ENOTSUPP;
} }
/* count used bits in last bitmap block */ /* count used bits in last bitmap block */
block_r = SB_BLOCK_COUNT(s) - block_r = SB_BLOCK_COUNT(s) - (SB_BMAP_NR(s) - 1) * s->s_blocksize * 8;
(SB_BMAP_NR(s) - 1) * s->s_blocksize * 8;
/* count bitmap blocks in new fs */ /* count bitmap blocks in new fs */
bmap_nr_new = block_count_new / ( s->s_blocksize * 8 ); bmap_nr_new = block_count_new / (s->s_blocksize * 8);
block_r_new = block_count_new - bmap_nr_new * s->s_blocksize * 8; block_r_new = block_count_new - bmap_nr_new * s->s_blocksize * 8;
if (block_r_new) if (block_r_new)
bmap_nr_new++; bmap_nr_new++;
@ -78,9 +78,10 @@ int reiserfs_resize (struct super_block * s, unsigned long block_count_new)
if (bmap_nr_new > bmap_nr) { if (bmap_nr_new > bmap_nr) {
/* reallocate journal bitmaps */ /* reallocate journal bitmaps */
if (reiserfs_allocate_list_bitmaps(s, jbitmap, bmap_nr_new) < 0) { if (reiserfs_allocate_list_bitmaps(s, jbitmap, bmap_nr_new) < 0) {
printk("reiserfs_resize: unable to allocate memory for journal bitmaps\n"); printk
unlock_super(s) ; ("reiserfs_resize: unable to allocate memory for journal bitmaps\n");
return -ENOMEM ; unlock_super(s);
return -ENOMEM;
} }
/* the new journal bitmaps are zero filled, now we copy in the bitmap /* the new journal bitmaps are zero filled, now we copy in the bitmap
** node pointers from the old journal bitmap structs, and then ** node pointers from the old journal bitmap structs, and then
@ -89,32 +90,35 @@ int reiserfs_resize (struct super_block * s, unsigned long block_count_new)
** using the copy_size var below allows this code to work for ** using the copy_size var below allows this code to work for
** both shrinking and expanding the FS. ** both shrinking and expanding the FS.
*/ */
copy_size = bmap_nr_new < bmap_nr ? bmap_nr_new : bmap_nr ; copy_size = bmap_nr_new < bmap_nr ? bmap_nr_new : bmap_nr;
copy_size = copy_size * sizeof(struct reiserfs_list_bitmap_node *) ; copy_size =
for (i = 0 ; i < JOURNAL_NUM_BITMAPS ; i++) { copy_size * sizeof(struct reiserfs_list_bitmap_node *);
struct reiserfs_bitmap_node **node_tmp ; for (i = 0; i < JOURNAL_NUM_BITMAPS; i++) {
jb = SB_JOURNAL(s)->j_list_bitmap + i ; struct reiserfs_bitmap_node **node_tmp;
memcpy(jbitmap[i].bitmaps, jb->bitmaps, copy_size) ; jb = SB_JOURNAL(s)->j_list_bitmap + i;
memcpy(jbitmap[i].bitmaps, jb->bitmaps, copy_size);
/* just in case vfree schedules on us, copy the new /* just in case vfree schedules on us, copy the new
** pointer into the journal struct before freeing the ** pointer into the journal struct before freeing the
** old one ** old one
*/ */
node_tmp = jb->bitmaps ; node_tmp = jb->bitmaps;
jb->bitmaps = jbitmap[i].bitmaps ; jb->bitmaps = jbitmap[i].bitmaps;
vfree(node_tmp) ; vfree(node_tmp);
} }
/* allocate additional bitmap blocks, reallocate array of bitmap /* allocate additional bitmap blocks, reallocate array of bitmap
* block pointers */ * block pointers */
bitmap = vmalloc(sizeof(struct reiserfs_bitmap_info) * bmap_nr_new); bitmap =
vmalloc(sizeof(struct reiserfs_bitmap_info) * bmap_nr_new);
if (!bitmap) { if (!bitmap) {
/* Journal bitmaps are still supersized, but the memory isn't /* Journal bitmaps are still supersized, but the memory isn't
* leaked, so I guess it's ok */ * leaked, so I guess it's ok */
printk("reiserfs_resize: unable to allocate memory.\n"); printk("reiserfs_resize: unable to allocate memory.\n");
return -ENOMEM; return -ENOMEM;
} }
memset (bitmap, 0, sizeof (struct reiserfs_bitmap_info) * SB_BMAP_NR(s)); memset(bitmap, 0,
sizeof(struct reiserfs_bitmap_info) * SB_BMAP_NR(s));
for (i = 0; i < bmap_nr; i++) for (i = 0; i < bmap_nr; i++)
bitmap[i] = old_bitmap[i]; bitmap[i] = old_bitmap[i];
@ -128,15 +132,15 @@ int reiserfs_resize (struct super_block * s, unsigned long block_count_new)
reiserfs_test_and_set_le_bit(0, bitmap[i].bh->b_data); reiserfs_test_and_set_le_bit(0, bitmap[i].bh->b_data);
set_buffer_uptodate(bitmap[i].bh); set_buffer_uptodate(bitmap[i].bh);
mark_buffer_dirty(bitmap[i].bh) ; mark_buffer_dirty(bitmap[i].bh);
sync_dirty_buffer(bitmap[i].bh); sync_dirty_buffer(bitmap[i].bh);
// update bitmap_info stuff // update bitmap_info stuff
bitmap[i].first_zero_hint=1; bitmap[i].first_zero_hint = 1;
bitmap[i].free_count = sb_blocksize(sb) * 8 - 1; bitmap[i].free_count = sb_blocksize(sb) * 8 - 1;
} }
/* free old bitmap blocks array */ /* free old bitmap blocks array */
SB_AP_BITMAP(s) = bitmap; SB_AP_BITMAP(s) = bitmap;
vfree (old_bitmap); vfree(old_bitmap);
} }
/* begin transaction, if there was an error, it's fine. Yes, we have /* begin transaction, if there was an error, it's fine. Yes, we have
@ -150,9 +154,10 @@ int reiserfs_resize (struct super_block * s, unsigned long block_count_new)
reiserfs_prepare_for_journal(s, SB_AP_BITMAP(s)[bmap_nr - 1].bh, 1); reiserfs_prepare_for_journal(s, SB_AP_BITMAP(s)[bmap_nr - 1].bh, 1);
for (i = block_r; i < s->s_blocksize * 8; i++) for (i = block_r; i < s->s_blocksize * 8; i++)
reiserfs_test_and_clear_le_bit(i, reiserfs_test_and_clear_le_bit(i,
SB_AP_BITMAP(s)[bmap_nr - 1].bh->b_data); SB_AP_BITMAP(s)[bmap_nr -
1].bh->b_data);
SB_AP_BITMAP(s)[bmap_nr - 1].free_count += s->s_blocksize * 8 - block_r; SB_AP_BITMAP(s)[bmap_nr - 1].free_count += s->s_blocksize * 8 - block_r;
if ( !SB_AP_BITMAP(s)[bmap_nr - 1].first_zero_hint) if (!SB_AP_BITMAP(s)[bmap_nr - 1].first_zero_hint)
SB_AP_BITMAP(s)[bmap_nr - 1].first_zero_hint = block_r; SB_AP_BITMAP(s)[bmap_nr - 1].first_zero_hint = block_r;
journal_mark_dirty(&th, s, SB_AP_BITMAP(s)[bmap_nr - 1].bh); journal_mark_dirty(&th, s, SB_AP_BITMAP(s)[bmap_nr - 1].bh);
@ -160,17 +165,21 @@ int reiserfs_resize (struct super_block * s, unsigned long block_count_new)
reiserfs_prepare_for_journal(s, SB_AP_BITMAP(s)[bmap_nr_new - 1].bh, 1); reiserfs_prepare_for_journal(s, SB_AP_BITMAP(s)[bmap_nr_new - 1].bh, 1);
for (i = block_r_new; i < s->s_blocksize * 8; i++) for (i = block_r_new; i < s->s_blocksize * 8; i++)
reiserfs_test_and_set_le_bit(i, reiserfs_test_and_set_le_bit(i,
SB_AP_BITMAP(s)[bmap_nr_new - 1].bh->b_data); SB_AP_BITMAP(s)[bmap_nr_new -
1].bh->b_data);
journal_mark_dirty(&th, s, SB_AP_BITMAP(s)[bmap_nr_new - 1].bh); journal_mark_dirty(&th, s, SB_AP_BITMAP(s)[bmap_nr_new - 1].bh);
SB_AP_BITMAP(s)[bmap_nr_new - 1].free_count -= s->s_blocksize * 8 - block_r_new; SB_AP_BITMAP(s)[bmap_nr_new - 1].free_count -=
s->s_blocksize * 8 - block_r_new;
/* Extreme case where last bitmap is the only valid block in itself. */ /* Extreme case where last bitmap is the only valid block in itself. */
if ( !SB_AP_BITMAP(s)[bmap_nr_new - 1].free_count ) if (!SB_AP_BITMAP(s)[bmap_nr_new - 1].free_count)
SB_AP_BITMAP(s)[bmap_nr_new - 1].first_zero_hint = 0; SB_AP_BITMAP(s)[bmap_nr_new - 1].first_zero_hint = 0;
/* update super */ /* update super */
reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1) ; reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1);
free_blocks = SB_FREE_BLOCKS(s); free_blocks = SB_FREE_BLOCKS(s);
PUT_SB_FREE_BLOCKS(s, free_blocks + (block_count_new - block_count - (bmap_nr_new - bmap_nr))); PUT_SB_FREE_BLOCKS(s,
free_blocks + (block_count_new - block_count -
(bmap_nr_new - bmap_nr)));
PUT_SB_BLOCK_COUNT(s, block_count_new); PUT_SB_BLOCK_COUNT(s, block_count_new);
PUT_SB_BMAP_NR(s, bmap_nr_new); PUT_SB_BMAP_NR(s, bmap_nr_new);
s->s_dirt = 1; s->s_dirt = 1;

1445
fs/reiserfs/stree.c
View file

File diff suppressed because it is too large Load diff

1359
fs/reiserfs/super.c
View file

File diff suppressed because it is too large Load diff

175
fs/reiserfs/tail_conversion.c
View file

@ -11,79 +11,78 @@
/* access to tail : when one is going to read tail it must make sure, that is not running. /* access to tail : when one is going to read tail it must make sure, that is not running.
direct2indirect and indirect2direct can not run concurrently */ direct2indirect and indirect2direct can not run concurrently */
/* Converts direct items to an unformatted node. Panics if file has no /* Converts direct items to an unformatted node. Panics if file has no
tail. -ENOSPC if no disk space for conversion */ tail. -ENOSPC if no disk space for conversion */
/* path points to first direct item of the file regarless of how many of /* path points to first direct item of the file regarless of how many of
them are there */ them are there */
int direct2indirect (struct reiserfs_transaction_handle *th, struct inode * inode, int direct2indirect(struct reiserfs_transaction_handle *th, struct inode *inode,
struct path * path, struct buffer_head * unbh, struct path *path, struct buffer_head *unbh,
loff_t tail_offset) loff_t tail_offset)
{ {
struct super_block * sb = inode->i_sb; struct super_block *sb = inode->i_sb;
struct buffer_head *up_to_date_bh ; struct buffer_head *up_to_date_bh;
struct item_head * p_le_ih = PATH_PITEM_HEAD (path); struct item_head *p_le_ih = PATH_PITEM_HEAD(path);
unsigned long total_tail = 0 ; unsigned long total_tail = 0;
struct cpu_key end_key; /* Key to search for the last byte of the struct cpu_key end_key; /* Key to search for the last byte of the
converted item. */ converted item. */
struct item_head ind_ih; /* new indirect item to be inserted or struct item_head ind_ih; /* new indirect item to be inserted or
key of unfm pointer to be pasted */ key of unfm pointer to be pasted */
int n_blk_size, int n_blk_size, n_retval; /* returned value for reiserfs_insert_item and clones */
n_retval; /* returned value for reiserfs_insert_item and clones */
unp_t unfm_ptr; /* Handle on an unformatted node unp_t unfm_ptr; /* Handle on an unformatted node
that will be inserted in the that will be inserted in the
tree. */ tree. */
BUG_ON (!th->t_trans_id); BUG_ON(!th->t_trans_id);
REISERFS_SB(sb)->s_direct2indirect ++; REISERFS_SB(sb)->s_direct2indirect++;
n_blk_size = sb->s_blocksize; n_blk_size = sb->s_blocksize;
/* and key to search for append or insert pointer to the new /* and key to search for append or insert pointer to the new
unformatted node. */ unformatted node. */
copy_item_head (&ind_ih, p_le_ih); copy_item_head(&ind_ih, p_le_ih);
set_le_ih_k_offset (&ind_ih, tail_offset); set_le_ih_k_offset(&ind_ih, tail_offset);
set_le_ih_k_type (&ind_ih, TYPE_INDIRECT); set_le_ih_k_type(&ind_ih, TYPE_INDIRECT);
/* Set the key to search for the place for new unfm pointer */ /* Set the key to search for the place for new unfm pointer */
make_cpu_key (&end_key, inode, tail_offset, TYPE_INDIRECT, 4); make_cpu_key(&end_key, inode, tail_offset, TYPE_INDIRECT, 4);
// FIXME: we could avoid this // FIXME: we could avoid this
if ( search_for_position_by_key (sb, &end_key, path) == POSITION_FOUND ) { if (search_for_position_by_key(sb, &end_key, path) == POSITION_FOUND) {
reiserfs_warning (sb, "PAP-14030: direct2indirect: " reiserfs_warning(sb, "PAP-14030: direct2indirect: "
"pasted or inserted byte exists in the tree %K. " "pasted or inserted byte exists in the tree %K. "
"Use fsck to repair.", &end_key); "Use fsck to repair.", &end_key);
pathrelse(path); pathrelse(path);
return -EIO; return -EIO;
} }
p_le_ih = PATH_PITEM_HEAD (path); p_le_ih = PATH_PITEM_HEAD(path);
unfm_ptr = cpu_to_le32 (unbh->b_blocknr); unfm_ptr = cpu_to_le32(unbh->b_blocknr);
if ( is_statdata_le_ih (p_le_ih) ) { if (is_statdata_le_ih(p_le_ih)) {
/* Insert new indirect item. */ /* Insert new indirect item. */
set_ih_free_space (&ind_ih, 0); /* delete at nearest future */ set_ih_free_space(&ind_ih, 0); /* delete at nearest future */
put_ih_item_len( &ind_ih, UNFM_P_SIZE ); put_ih_item_len(&ind_ih, UNFM_P_SIZE);
PATH_LAST_POSITION (path)++; PATH_LAST_POSITION(path)++;
n_retval = reiserfs_insert_item (th, path, &end_key, &ind_ih, inode, n_retval =
reiserfs_insert_item(th, path, &end_key, &ind_ih, inode,
(char *)&unfm_ptr); (char *)&unfm_ptr);
} else { } else {
/* Paste into last indirect item of an object. */ /* Paste into last indirect item of an object. */
n_retval = reiserfs_paste_into_item(th, path, &end_key, inode, n_retval = reiserfs_paste_into_item(th, path, &end_key, inode,
(char *)&unfm_ptr, UNFM_P_SIZE); (char *)&unfm_ptr,
UNFM_P_SIZE);
} }
if ( n_retval ) { if (n_retval) {
return n_retval; return n_retval;
} }
// note: from here there are two keys which have matching first // note: from here there are two keys which have matching first
// three key components. They only differ by the fourth one. // three key components. They only differ by the fourth one.
/* Set the key to search for the direct items of the file */ /* Set the key to search for the direct items of the file */
make_cpu_key (&end_key, inode, max_reiserfs_offset (inode), TYPE_DIRECT, 4); make_cpu_key(&end_key, inode, max_reiserfs_offset(inode), TYPE_DIRECT,
4);
/* Move bytes from the direct items to the new unformatted node /* Move bytes from the direct items to the new unformatted node
and delete them. */ and delete them. */
@ -92,14 +91,16 @@ int direct2indirect (struct reiserfs_transaction_handle *th, struct inode * inod
/* end_key.k_offset is set so, that we will always have found /* end_key.k_offset is set so, that we will always have found
last item of the file */ last item of the file */
if ( search_for_position_by_key (sb, &end_key, path) == POSITION_FOUND ) if (search_for_position_by_key(sb, &end_key, path) ==
reiserfs_panic (sb, "PAP-14050: direct2indirect: " POSITION_FOUND)
reiserfs_panic(sb,
"PAP-14050: direct2indirect: "
"direct item (%K) not found", &end_key); "direct item (%K) not found", &end_key);
p_le_ih = PATH_PITEM_HEAD (path); p_le_ih = PATH_PITEM_HEAD(path);
RFALSE( !is_direct_le_ih (p_le_ih), RFALSE(!is_direct_le_ih(p_le_ih),
"vs-14055: direct item expected(%K), found %h", "vs-14055: direct item expected(%K), found %h",
&end_key, p_le_ih); &end_key, p_le_ih);
tail_size = (le_ih_k_offset (p_le_ih) & (n_blk_size - 1)) tail_size = (le_ih_k_offset(p_le_ih) & (n_blk_size - 1))
+ ih_item_len(p_le_ih) - 1; + ih_item_len(p_le_ih) - 1;
/* we only send the unbh pointer if the buffer is not up to date. /* we only send the unbh pointer if the buffer is not up to date.
@ -108,15 +109,16 @@ int direct2indirect (struct reiserfs_transaction_handle *th, struct inode * inod
** Special case: unbh->b_page will be NULL if we are coming through ** Special case: unbh->b_page will be NULL if we are coming through
** DIRECT_IO handler here. ** DIRECT_IO handler here.
*/ */
if (!unbh->b_page || buffer_uptodate(unbh) || PageUptodate(unbh->b_page)) { if (!unbh->b_page || buffer_uptodate(unbh)
up_to_date_bh = NULL ; || PageUptodate(unbh->b_page)) {
up_to_date_bh = NULL;
} else { } else {
up_to_date_bh = unbh ; up_to_date_bh = unbh;
} }
n_retval = reiserfs_delete_item (th, path, &end_key, inode, n_retval = reiserfs_delete_item(th, path, &end_key, inode,
up_to_date_bh) ; up_to_date_bh);
total_tail += n_retval ; total_tail += n_retval;
if (tail_size == n_retval) if (tail_size == n_retval)
// done: file does not have direct items anymore // done: file does not have direct items anymore
break; break;
@ -126,9 +128,10 @@ int direct2indirect (struct reiserfs_transaction_handle *th, struct inode * inod
** out the unused part of the block (it was not up to date before) ** out the unused part of the block (it was not up to date before)
*/ */
if (up_to_date_bh) { if (up_to_date_bh) {
unsigned pgoff = (tail_offset + total_tail - 1) & (PAGE_CACHE_SIZE - 1); unsigned pgoff =
char *kaddr=kmap_atomic(up_to_date_bh->b_page, KM_USER0); (tail_offset + total_tail - 1) & (PAGE_CACHE_SIZE - 1);
memset(kaddr + pgoff, 0, n_blk_size - total_tail) ; char *kaddr = kmap_atomic(up_to_date_bh->b_page, KM_USER0);
memset(kaddr + pgoff, 0, n_blk_size - total_tail);
kunmap_atomic(kaddr, KM_USER0); kunmap_atomic(kaddr, KM_USER0);
} }
@ -137,18 +140,18 @@ int direct2indirect (struct reiserfs_transaction_handle *th, struct inode * inod
return 0; return 0;
} }
/* stolen from fs/buffer.c */ /* stolen from fs/buffer.c */
void reiserfs_unmap_buffer(struct buffer_head *bh) { void reiserfs_unmap_buffer(struct buffer_head *bh)
lock_buffer(bh) ; {
lock_buffer(bh);
if (buffer_journaled(bh) || buffer_journal_dirty(bh)) { if (buffer_journaled(bh) || buffer_journal_dirty(bh)) {
BUG() ; BUG();
} }
clear_buffer_dirty(bh) ; clear_buffer_dirty(bh);
/* Remove the buffer from whatever list it belongs to. We are mostly /* Remove the buffer from whatever list it belongs to. We are mostly
interested in removing it from per-sb j_dirty_buffers list, to avoid interested in removing it from per-sb j_dirty_buffers list, to avoid
BUG() on attempt to write not mapped buffer */ BUG() on attempt to write not mapped buffer */
if ( (!list_empty(&bh->b_assoc_buffers) || bh->b_private) && bh->b_page) { if ((!list_empty(&bh->b_assoc_buffers) || bh->b_private) && bh->b_page) {
struct inode *inode = bh->b_page->mapping->host; struct inode *inode = bh->b_page->mapping->host;
struct reiserfs_journal *j = SB_JOURNAL(inode->i_sb); struct reiserfs_journal *j = SB_JOURNAL(inode->i_sb);
spin_lock(&j->j_dirty_buffers_lock); spin_lock(&j->j_dirty_buffers_lock);
@ -156,11 +159,11 @@ void reiserfs_unmap_buffer(struct buffer_head *bh) {
reiserfs_free_jh(bh); reiserfs_free_jh(bh);
spin_unlock(&j->j_dirty_buffers_lock); spin_unlock(&j->j_dirty_buffers_lock);
} }
clear_buffer_mapped(bh) ; clear_buffer_mapped(bh);
clear_buffer_req(bh) ; clear_buffer_req(bh);
clear_buffer_new(bh); clear_buffer_new(bh);
bh->b_bdev = NULL; bh->b_bdev = NULL;
unlock_buffer(bh) ; unlock_buffer(bh);
} }
/* this first locks inode (neither reads nor sync are permitted), /* this first locks inode (neither reads nor sync are permitted),
@ -169,90 +172,93 @@ void reiserfs_unmap_buffer(struct buffer_head *bh) {
what we expect from it (number of cut bytes). But when tail remains what we expect from it (number of cut bytes). But when tail remains
in the unformatted node, we set mode to SKIP_BALANCING and unlock in the unformatted node, we set mode to SKIP_BALANCING and unlock
inode */ inode */
int indirect2direct (struct reiserfs_transaction_handle *th, int indirect2direct(struct reiserfs_transaction_handle *th, struct inode *p_s_inode, struct page *page, struct path *p_s_path, /* path to the indirect item. */
struct inode * p_s_inode, const struct cpu_key *p_s_item_key, /* Key to look for unformatted node pointer to be cut. */
struct page *page,
struct path * p_s_path, /* path to the indirect item. */
const struct cpu_key * p_s_item_key, /* Key to look for unformatted node pointer to be cut. */
loff_t n_new_file_size, /* New file size. */ loff_t n_new_file_size, /* New file size. */
char * p_c_mode) char *p_c_mode)
{ {
struct super_block * p_s_sb = p_s_inode->i_sb; struct super_block *p_s_sb = p_s_inode->i_sb;
struct item_head s_ih; struct item_head s_ih;
unsigned long n_block_size = p_s_sb->s_blocksize; unsigned long n_block_size = p_s_sb->s_blocksize;
char * tail; char *tail;
int tail_len, round_tail_len; int tail_len, round_tail_len;
loff_t pos, pos1; /* position of first byte of the tail */ loff_t pos, pos1; /* position of first byte of the tail */
struct cpu_key key; struct cpu_key key;
BUG_ON (!th->t_trans_id); BUG_ON(!th->t_trans_id);
REISERFS_SB(p_s_sb)->s_indirect2direct ++; REISERFS_SB(p_s_sb)->s_indirect2direct++;
*p_c_mode = M_SKIP_BALANCING; *p_c_mode = M_SKIP_BALANCING;
/* store item head path points to. */ /* store item head path points to. */
copy_item_head (&s_ih, PATH_PITEM_HEAD(p_s_path)); copy_item_head(&s_ih, PATH_PITEM_HEAD(p_s_path));
tail_len = (n_new_file_size & (n_block_size - 1)); tail_len = (n_new_file_size & (n_block_size - 1));
if (get_inode_sd_version (p_s_inode) == STAT_DATA_V2) if (get_inode_sd_version(p_s_inode) == STAT_DATA_V2)
round_tail_len = ROUND_UP (tail_len); round_tail_len = ROUND_UP(tail_len);
else else
round_tail_len = tail_len; round_tail_len = tail_len;
pos = le_ih_k_offset (&s_ih) - 1 + (ih_item_len(&s_ih) / UNFM_P_SIZE - 1) * p_s_sb->s_blocksize; pos =
le_ih_k_offset(&s_ih) - 1 + (ih_item_len(&s_ih) / UNFM_P_SIZE -
1) * p_s_sb->s_blocksize;
pos1 = pos; pos1 = pos;
// we are protected by i_sem. The tail can not disapper, not // we are protected by i_sem. The tail can not disapper, not
// append can be done either // append can be done either
// we are in truncate or packing tail in file_release // we are in truncate or packing tail in file_release
tail = (char *)kmap(page) ; /* this can schedule */ tail = (char *)kmap(page); /* this can schedule */
if (path_changed (&s_ih, p_s_path)) { if (path_changed(&s_ih, p_s_path)) {
/* re-search indirect item */ /* re-search indirect item */
if ( search_for_position_by_key (p_s_sb, p_s_item_key, p_s_path) == POSITION_NOT_FOUND ) if (search_for_position_by_key(p_s_sb, p_s_item_key, p_s_path)
reiserfs_panic(p_s_sb, "PAP-5520: indirect2direct: " == POSITION_NOT_FOUND)
"item to be converted %K does not exist", p_s_item_key); reiserfs_panic(p_s_sb,
"PAP-5520: indirect2direct: "
"item to be converted %K does not exist",
p_s_item_key);
copy_item_head(&s_ih, PATH_PITEM_HEAD(p_s_path)); copy_item_head(&s_ih, PATH_PITEM_HEAD(p_s_path));
#ifdef CONFIG_REISERFS_CHECK #ifdef CONFIG_REISERFS_CHECK
pos = le_ih_k_offset (&s_ih) - 1 + pos = le_ih_k_offset(&s_ih) - 1 +
(ih_item_len(&s_ih) / UNFM_P_SIZE - 1) * p_s_sb->s_blocksize; (ih_item_len(&s_ih) / UNFM_P_SIZE -
1) * p_s_sb->s_blocksize;
if (pos != pos1) if (pos != pos1)
reiserfs_panic (p_s_sb, "vs-5530: indirect2direct: " reiserfs_panic(p_s_sb, "vs-5530: indirect2direct: "
"tail position changed while we were reading it"); "tail position changed while we were reading it");
#endif #endif
} }
/* Set direct item header to insert. */ /* Set direct item header to insert. */
make_le_item_head (&s_ih, NULL, get_inode_item_key_version (p_s_inode), pos1 + 1, make_le_item_head(&s_ih, NULL, get_inode_item_key_version(p_s_inode),
TYPE_DIRECT, round_tail_len, 0xffff/*ih_free_space*/); pos1 + 1, TYPE_DIRECT, round_tail_len,
0xffff /*ih_free_space */ );
/* we want a pointer to the first byte of the tail in the page. /* we want a pointer to the first byte of the tail in the page.
** the page was locked and this part of the page was up to date when ** the page was locked and this part of the page was up to date when
** indirect2direct was called, so we know the bytes are still valid ** indirect2direct was called, so we know the bytes are still valid
*/ */
tail = tail + (pos & (PAGE_CACHE_SIZE - 1)) ; tail = tail + (pos & (PAGE_CACHE_SIZE - 1));
PATH_LAST_POSITION(p_s_path)++; PATH_LAST_POSITION(p_s_path)++;
key = *p_s_item_key; key = *p_s_item_key;
set_cpu_key_k_type (&key, TYPE_DIRECT); set_cpu_key_k_type(&key, TYPE_DIRECT);
key.key_length = 4; key.key_length = 4;
/* Insert tail as new direct item in the tree */ /* Insert tail as new direct item in the tree */
if ( reiserfs_insert_item(th, p_s_path, &key, &s_ih, p_s_inode, if (reiserfs_insert_item(th, p_s_path, &key, &s_ih, p_s_inode,
tail ? tail : NULL) < 0 ) { tail ? tail : NULL) < 0) {
/* No disk memory. So we can not convert last unformatted node /* No disk memory. So we can not convert last unformatted node
to the direct item. In this case we used to adjust to the direct item. In this case we used to adjust
indirect items's ih_free_space. Now ih_free_space is not indirect items's ih_free_space. Now ih_free_space is not
used, it would be ideal to write zeros to corresponding used, it would be ideal to write zeros to corresponding
unformatted node. For now i_size is considered as guard for unformatted node. For now i_size is considered as guard for
going out of file size */ going out of file size */
kunmap(page) ; kunmap(page);
return n_block_size - round_tail_len; return n_block_size - round_tail_len;
} }
kunmap(page) ; kunmap(page);
/* make sure to get the i_blocks changes from reiserfs_insert_item */ /* make sure to get the i_blocks changes from reiserfs_insert_item */
reiserfs_update_sd(th, p_s_inode); reiserfs_update_sd(th, p_s_inode);
@ -271,6 +277,3 @@ int indirect2direct (struct reiserfs_transaction_handle *th,
return n_block_size - round_tail_len; return n_block_size - round_tail_len;
} }

831
fs/reiserfs/xattr.c
View file

File diff suppressed because it is too large Load diff

221
fs/reiserfs/xattr_acl.c
View file

@ -9,7 +9,8 @@
#include <linux/reiserfs_acl.h> #include <linux/reiserfs_acl.h>
#include <asm/uaccess.h> #include <asm/uaccess.h>
static int reiserfs_set_acl(struct inode *inode, int type, struct posix_acl *acl); static int reiserfs_set_acl(struct inode *inode, int type,
struct posix_acl *acl);
static int static int
xattr_set_acl(struct inode *inode, int type, const void *value, size_t size) xattr_set_acl(struct inode *inode, int type, const void *value, size_t size)
@ -34,14 +35,13 @@ xattr_set_acl(struct inode *inode, int type, const void *value, size_t size)
} else } else
acl = NULL; acl = NULL;
error = reiserfs_set_acl (inode, type, acl); error = reiserfs_set_acl(inode, type, acl);
release_and_out: release_and_out:
posix_acl_release(acl); posix_acl_release(acl);
return error; return error;
} }
static int static int
xattr_get_acl(struct inode *inode, int type, void *buffer, size_t size) xattr_get_acl(struct inode *inode, int type, void *buffer, size_t size)
{ {
@ -51,7 +51,7 @@ xattr_get_acl(struct inode *inode, int type, void *buffer, size_t size)
if (!reiserfs_posixacl(inode->i_sb)) if (!reiserfs_posixacl(inode->i_sb))
return -EOPNOTSUPP; return -EOPNOTSUPP;
acl = reiserfs_get_acl (inode, type); acl = reiserfs_get_acl(inode, type);
if (IS_ERR(acl)) if (IS_ERR(acl))
return PTR_ERR(acl); return PTR_ERR(acl);
if (acl == NULL) if (acl == NULL)
@ -62,12 +62,10 @@ xattr_get_acl(struct inode *inode, int type, void *buffer, size_t size)
return error; return error;
} }
/* /*
* Convert from filesystem to in-memory representation. * Convert from filesystem to in-memory representation.
*/ */
static struct posix_acl * static struct posix_acl *posix_acl_from_disk(const void *value, size_t size)
posix_acl_from_disk(const void *value, size_t size)
{ {
const char *end = (char *)value + size; const char *end = (char *)value + size;
int n, count; int n, count;
@ -77,7 +75,7 @@ posix_acl_from_disk(const void *value, size_t size)
return NULL; return NULL;
if (size < sizeof(reiserfs_acl_header)) if (size < sizeof(reiserfs_acl_header))
return ERR_PTR(-EINVAL); return ERR_PTR(-EINVAL);
if (((reiserfs_acl_header *)value)->a_version != if (((reiserfs_acl_header *) value)->a_version !=
cpu_to_le32(REISERFS_ACL_VERSION)) cpu_to_le32(REISERFS_ACL_VERSION))
return ERR_PTR(-EINVAL); return ERR_PTR(-EINVAL);
value = (char *)value + sizeof(reiserfs_acl_header); value = (char *)value + sizeof(reiserfs_acl_header);
@ -89,14 +87,13 @@ posix_acl_from_disk(const void *value, size_t size)
acl = posix_acl_alloc(count, GFP_NOFS); acl = posix_acl_alloc(count, GFP_NOFS);
if (!acl) if (!acl)
return ERR_PTR(-ENOMEM); return ERR_PTR(-ENOMEM);
for (n=0; n < count; n++) { for (n = 0; n < count; n++) {
reiserfs_acl_entry *entry = reiserfs_acl_entry *entry = (reiserfs_acl_entry *) value;
(reiserfs_acl_entry *)value;
if ((char *)value + sizeof(reiserfs_acl_entry_short) > end) if ((char *)value + sizeof(reiserfs_acl_entry_short) > end)
goto fail; goto fail;
acl->a_entries[n].e_tag = le16_to_cpu(entry->e_tag); acl->a_entries[n].e_tag = le16_to_cpu(entry->e_tag);
acl->a_entries[n].e_perm = le16_to_cpu(entry->e_perm); acl->a_entries[n].e_perm = le16_to_cpu(entry->e_perm);
switch(acl->a_entries[n].e_tag) { switch (acl->a_entries[n].e_tag) {
case ACL_USER_OBJ: case ACL_USER_OBJ:
case ACL_GROUP_OBJ: case ACL_GROUP_OBJ:
case ACL_MASK: case ACL_MASK:
@ -111,8 +108,7 @@ posix_acl_from_disk(const void *value, size_t size)
value = (char *)value + sizeof(reiserfs_acl_entry); value = (char *)value + sizeof(reiserfs_acl_entry);
if ((char *)value > end) if ((char *)value > end)
goto fail; goto fail;
acl->a_entries[n].e_id = acl->a_entries[n].e_id = le32_to_cpu(entry->e_id);
le32_to_cpu(entry->e_id);
break; break;
default: default:
@ -123,7 +119,7 @@ posix_acl_from_disk(const void *value, size_t size)
goto fail; goto fail;
return acl; return acl;
fail: fail:
posix_acl_release(acl); posix_acl_release(acl);
return ERR_PTR(-EINVAL); return ERR_PTR(-EINVAL);
} }
@ -131,29 +127,29 @@ fail:
/* /*
* Convert from in-memory to filesystem representation. * Convert from in-memory to filesystem representation.
*/ */
static void * static void *posix_acl_to_disk(const struct posix_acl *acl, size_t * size)
posix_acl_to_disk(const struct posix_acl *acl, size_t *size)
{ {
reiserfs_acl_header *ext_acl; reiserfs_acl_header *ext_acl;
char *e; char *e;
int n; int n;
*size = reiserfs_acl_size(acl->a_count); *size = reiserfs_acl_size(acl->a_count);
ext_acl = (reiserfs_acl_header *)kmalloc(sizeof(reiserfs_acl_header) + ext_acl = (reiserfs_acl_header *) kmalloc(sizeof(reiserfs_acl_header) +
acl->a_count * sizeof(reiserfs_acl_entry), GFP_NOFS); acl->a_count *
sizeof(reiserfs_acl_entry),
GFP_NOFS);
if (!ext_acl) if (!ext_acl)
return ERR_PTR(-ENOMEM); return ERR_PTR(-ENOMEM);
ext_acl->a_version = cpu_to_le32(REISERFS_ACL_VERSION); ext_acl->a_version = cpu_to_le32(REISERFS_ACL_VERSION);
e = (char *)ext_acl + sizeof(reiserfs_acl_header); e = (char *)ext_acl + sizeof(reiserfs_acl_header);
for (n=0; n < acl->a_count; n++) { for (n = 0; n < acl->a_count; n++) {
reiserfs_acl_entry *entry = (reiserfs_acl_entry *)e; reiserfs_acl_entry *entry = (reiserfs_acl_entry *) e;
entry->e_tag = cpu_to_le16(acl->a_entries[n].e_tag); entry->e_tag = cpu_to_le16(acl->a_entries[n].e_tag);
entry->e_perm = cpu_to_le16(acl->a_entries[n].e_perm); entry->e_perm = cpu_to_le16(acl->a_entries[n].e_perm);
switch(acl->a_entries[n].e_tag) { switch (acl->a_entries[n].e_tag) {
case ACL_USER: case ACL_USER:
case ACL_GROUP: case ACL_GROUP:
entry->e_id = entry->e_id = cpu_to_le32(acl->a_entries[n].e_id);
cpu_to_le32(acl->a_entries[n].e_id);
e += sizeof(reiserfs_acl_entry); e += sizeof(reiserfs_acl_entry);
break; break;
@ -170,7 +166,7 @@ posix_acl_to_disk(const struct posix_acl *acl, size_t *size)
} }
return (char *)ext_acl; return (char *)ext_acl;
fail: fail:
kfree(ext_acl); kfree(ext_acl);
return ERR_PTR(-EINVAL); return ERR_PTR(-EINVAL);
} }
@ -181,8 +177,7 @@ fail:
* inode->i_sem: down * inode->i_sem: down
* BKL held [before 2.5.x] * BKL held [before 2.5.x]
*/ */
struct posix_acl * struct posix_acl *reiserfs_get_acl(struct inode *inode, int type)
reiserfs_get_acl(struct inode *inode, int type)
{ {
char *name, *value; char *name, *value;
struct posix_acl *acl, **p_acl; struct posix_acl *acl, **p_acl;
@ -200,39 +195,39 @@ reiserfs_get_acl(struct inode *inode, int type)
p_acl = &reiserfs_i->i_acl_default; p_acl = &reiserfs_i->i_acl_default;
break; break;
default: default:
return ERR_PTR (-EINVAL); return ERR_PTR(-EINVAL);
} }
if (IS_ERR (*p_acl)) { if (IS_ERR(*p_acl)) {
if (PTR_ERR (*p_acl) == -ENODATA) if (PTR_ERR(*p_acl) == -ENODATA)
return NULL; return NULL;
} else if (*p_acl != NULL) } else if (*p_acl != NULL)
return posix_acl_dup (*p_acl); return posix_acl_dup(*p_acl);
size = reiserfs_xattr_get (inode, name, NULL, 0); size = reiserfs_xattr_get(inode, name, NULL, 0);
if ((int)size < 0) { if ((int)size < 0) {
if (size == -ENODATA || size == -ENOSYS) { if (size == -ENODATA || size == -ENOSYS) {
*p_acl = ERR_PTR (-ENODATA); *p_acl = ERR_PTR(-ENODATA);
return NULL; return NULL;
} }
return ERR_PTR (size); return ERR_PTR(size);
} }
value = kmalloc (size, GFP_NOFS); value = kmalloc(size, GFP_NOFS);
if (!value) if (!value)
return ERR_PTR (-ENOMEM); return ERR_PTR(-ENOMEM);
retval = reiserfs_xattr_get(inode, name, value, size); retval = reiserfs_xattr_get(inode, name, value, size);
if (retval == -ENODATA || retval == -ENOSYS) { if (retval == -ENODATA || retval == -ENOSYS) {
/* This shouldn't actually happen as it should have /* This shouldn't actually happen as it should have
been caught above.. but just in case */ been caught above.. but just in case */
acl = NULL; acl = NULL;
*p_acl = ERR_PTR (-ENODATA); *p_acl = ERR_PTR(-ENODATA);
} else if (retval < 0) { } else if (retval < 0) {
acl = ERR_PTR(retval); acl = ERR_PTR(retval);
} else { } else {
acl = posix_acl_from_disk(value, retval); acl = posix_acl_from_disk(value, retval);
*p_acl = posix_acl_dup (acl); *p_acl = posix_acl_dup(acl);
} }
kfree(value); kfree(value);
@ -264,7 +259,7 @@ reiserfs_set_acl(struct inode *inode, int type, struct posix_acl *acl)
p_acl = &reiserfs_i->i_acl_access; p_acl = &reiserfs_i->i_acl_access;
if (acl) { if (acl) {
mode_t mode = inode->i_mode; mode_t mode = inode->i_mode;
error = posix_acl_equiv_mode (acl, &mode); error = posix_acl_equiv_mode(acl, &mode);
if (error < 0) if (error < 0)
return error; return error;
else { else {
@ -277,7 +272,7 @@ reiserfs_set_acl(struct inode *inode, int type, struct posix_acl *acl)
case ACL_TYPE_DEFAULT: case ACL_TYPE_DEFAULT:
name = POSIX_ACL_XATTR_DEFAULT; name = POSIX_ACL_XATTR_DEFAULT;
p_acl = &reiserfs_i->i_acl_default; p_acl = &reiserfs_i->i_acl_default;
if (!S_ISDIR (inode->i_mode)) if (!S_ISDIR(inode->i_mode))
return acl ? -EACCES : 0; return acl ? -EACCES : 0;
break; break;
default: default:
@ -290,13 +285,13 @@ reiserfs_set_acl(struct inode *inode, int type, struct posix_acl *acl)
return (int)PTR_ERR(value); return (int)PTR_ERR(value);
error = reiserfs_xattr_set(inode, name, value, size, 0); error = reiserfs_xattr_set(inode, name, value, size, 0);
} else { } else {
error = reiserfs_xattr_del (inode, name); error = reiserfs_xattr_del(inode, name);
if (error == -ENODATA) { if (error == -ENODATA) {
/* This may seem odd here, but it means that the ACL was set /* This may seem odd here, but it means that the ACL was set
* with a value representable with mode bits. If there was * with a value representable with mode bits. If there was
* an ACL before, reiserfs_xattr_del already dirtied the inode. * an ACL before, reiserfs_xattr_del already dirtied the inode.
*/ */
mark_inode_dirty (inode); mark_inode_dirty(inode);
error = 0; error = 0;
} }
} }
@ -306,13 +301,13 @@ reiserfs_set_acl(struct inode *inode, int type, struct posix_acl *acl)
if (!error) { if (!error) {
/* Release the old one */ /* Release the old one */
if (!IS_ERR (*p_acl) && *p_acl) if (!IS_ERR(*p_acl) && *p_acl)
posix_acl_release (*p_acl); posix_acl_release(*p_acl);
if (acl == NULL) if (acl == NULL)
*p_acl = ERR_PTR (-ENODATA); *p_acl = ERR_PTR(-ENODATA);
else else
*p_acl = posix_acl_dup (acl); *p_acl = posix_acl_dup(acl);
} }
return error; return error;
@ -321,33 +316,34 @@ reiserfs_set_acl(struct inode *inode, int type, struct posix_acl *acl)
/* dir->i_sem: down, /* dir->i_sem: down,
* inode is new and not released into the wild yet */ * inode is new and not released into the wild yet */
int int
reiserfs_inherit_default_acl (struct inode *dir, struct dentry *dentry, struct inode *inode) reiserfs_inherit_default_acl(struct inode *dir, struct dentry *dentry,
struct inode *inode)
{ {
struct posix_acl *acl; struct posix_acl *acl;
int err = 0; int err = 0;
/* ACLs only get applied to files and directories */ /* ACLs only get applied to files and directories */
if (S_ISLNK (inode->i_mode)) if (S_ISLNK(inode->i_mode))
return 0; return 0;
/* ACLs can only be used on "new" objects, so if it's an old object /* ACLs can only be used on "new" objects, so if it's an old object
* there is nothing to inherit from */ * there is nothing to inherit from */
if (get_inode_sd_version (dir) == STAT_DATA_V1) if (get_inode_sd_version(dir) == STAT_DATA_V1)
goto apply_umask; goto apply_umask;
/* Don't apply ACLs to objects in the .reiserfs_priv tree.. This /* Don't apply ACLs to objects in the .reiserfs_priv tree.. This
* would be useless since permissions are ignored, and a pain because * would be useless since permissions are ignored, and a pain because
* it introduces locking cycles */ * it introduces locking cycles */
if (is_reiserfs_priv_object (dir)) { if (is_reiserfs_priv_object(dir)) {
reiserfs_mark_inode_private (inode); reiserfs_mark_inode_private(inode);
goto apply_umask; goto apply_umask;
} }
acl = reiserfs_get_acl (dir, ACL_TYPE_DEFAULT); acl = reiserfs_get_acl(dir, ACL_TYPE_DEFAULT);
if (IS_ERR (acl)) { if (IS_ERR(acl)) {
if (PTR_ERR (acl) == -ENODATA) if (PTR_ERR(acl) == -ENODATA)
goto apply_umask; goto apply_umask;
return PTR_ERR (acl); return PTR_ERR(acl);
} }
if (acl) { if (acl) {
@ -356,22 +352,21 @@ reiserfs_inherit_default_acl (struct inode *dir, struct dentry *dentry, struct i
int need_acl; int need_acl;
/* Copy the default ACL to the default ACL of a new directory */ /* Copy the default ACL to the default ACL of a new directory */
if (S_ISDIR (inode->i_mode)) { if (S_ISDIR(inode->i_mode)) {
err = reiserfs_set_acl (inode, ACL_TYPE_DEFAULT, acl); err = reiserfs_set_acl(inode, ACL_TYPE_DEFAULT, acl);
if (err) if (err)
goto cleanup; goto cleanup;
} }
/* Now we reconcile the new ACL and the mode, /* Now we reconcile the new ACL and the mode,
potentially modifying both */ potentially modifying both */
acl_copy = posix_acl_clone (acl, GFP_NOFS); acl_copy = posix_acl_clone(acl, GFP_NOFS);
if (!acl_copy) { if (!acl_copy) {
err = -ENOMEM; err = -ENOMEM;
goto cleanup; goto cleanup;
} }
need_acl = posix_acl_create_masq(acl_copy, &mode);
need_acl = posix_acl_create_masq (acl_copy, &mode);
if (need_acl >= 0) { if (need_acl >= 0) {
if (mode != inode->i_mode) { if (mode != inode->i_mode) {
inode->i_mode = mode; inode->i_mode = mode;
@ -379,17 +374,19 @@ reiserfs_inherit_default_acl (struct inode *dir, struct dentry *dentry, struct i
/* If we need an ACL.. */ /* If we need an ACL.. */
if (need_acl > 0) { if (need_acl > 0) {
err = reiserfs_set_acl (inode, ACL_TYPE_ACCESS, acl_copy); err =
reiserfs_set_acl(inode, ACL_TYPE_ACCESS,
acl_copy);
if (err) if (err)
goto cleanup_copy; goto cleanup_copy;
} }
} }
cleanup_copy: cleanup_copy:
posix_acl_release (acl_copy); posix_acl_release(acl_copy);
cleanup: cleanup:
posix_acl_release (acl); posix_acl_release(acl);
} else { } else {
apply_umask: apply_umask:
/* no ACL, apply umask */ /* no ACL, apply umask */
inode->i_mode &= ~current->fs->umask; inode->i_mode &= ~current->fs->umask;
} }
@ -400,27 +397,24 @@ apply_umask:
/* Looks up and caches the result of the default ACL. /* Looks up and caches the result of the default ACL.
* We do this so that we don't need to carry the xattr_sem into * We do this so that we don't need to carry the xattr_sem into
* reiserfs_new_inode if we don't need to */ * reiserfs_new_inode if we don't need to */
int int reiserfs_cache_default_acl(struct inode *inode)
reiserfs_cache_default_acl (struct inode *inode)
{ {
int ret = 0; int ret = 0;
if (reiserfs_posixacl (inode->i_sb) && if (reiserfs_posixacl(inode->i_sb) && !is_reiserfs_priv_object(inode)) {
!is_reiserfs_priv_object (inode)) {
struct posix_acl *acl; struct posix_acl *acl;
reiserfs_read_lock_xattr_i (inode); reiserfs_read_lock_xattr_i(inode);
reiserfs_read_lock_xattrs (inode->i_sb); reiserfs_read_lock_xattrs(inode->i_sb);
acl = reiserfs_get_acl (inode, ACL_TYPE_DEFAULT); acl = reiserfs_get_acl(inode, ACL_TYPE_DEFAULT);
reiserfs_read_unlock_xattrs (inode->i_sb); reiserfs_read_unlock_xattrs(inode->i_sb);
reiserfs_read_unlock_xattr_i (inode); reiserfs_read_unlock_xattr_i(inode);
ret = acl ? 1 : 0; ret = acl ? 1 : 0;
posix_acl_release (acl); posix_acl_release(acl);
} }
return ret; return ret;
} }
int int reiserfs_acl_chmod(struct inode *inode)
reiserfs_acl_chmod (struct inode *inode)
{ {
struct posix_acl *acl, *clone; struct posix_acl *acl, *clone;
int error; int error;
@ -428,15 +422,14 @@ reiserfs_acl_chmod (struct inode *inode)
if (S_ISLNK(inode->i_mode)) if (S_ISLNK(inode->i_mode))
return -EOPNOTSUPP; return -EOPNOTSUPP;
if (get_inode_sd_version (inode) == STAT_DATA_V1 || if (get_inode_sd_version(inode) == STAT_DATA_V1 ||
!reiserfs_posixacl(inode->i_sb)) !reiserfs_posixacl(inode->i_sb)) {
{
return 0; return 0;
} }
reiserfs_read_lock_xattrs (inode->i_sb); reiserfs_read_lock_xattrs(inode->i_sb);
acl = reiserfs_get_acl(inode, ACL_TYPE_ACCESS); acl = reiserfs_get_acl(inode, ACL_TYPE_ACCESS);
reiserfs_read_unlock_xattrs (inode->i_sb); reiserfs_read_unlock_xattrs(inode->i_sb);
if (!acl) if (!acl)
return 0; return 0;
if (IS_ERR(acl)) if (IS_ERR(acl))
@ -447,18 +440,18 @@ reiserfs_acl_chmod (struct inode *inode)
return -ENOMEM; return -ENOMEM;
error = posix_acl_chmod_masq(clone, inode->i_mode); error = posix_acl_chmod_masq(clone, inode->i_mode);
if (!error) { if (!error) {
int lock = !has_xattr_dir (inode); int lock = !has_xattr_dir(inode);
reiserfs_write_lock_xattr_i (inode); reiserfs_write_lock_xattr_i(inode);
if (lock) if (lock)
reiserfs_write_lock_xattrs (inode->i_sb); reiserfs_write_lock_xattrs(inode->i_sb);
else else
reiserfs_read_lock_xattrs (inode->i_sb); reiserfs_read_lock_xattrs(inode->i_sb);
error = reiserfs_set_acl(inode, ACL_TYPE_ACCESS, clone); error = reiserfs_set_acl(inode, ACL_TYPE_ACCESS, clone);
if (lock) if (lock)
reiserfs_write_unlock_xattrs (inode->i_sb); reiserfs_write_unlock_xattrs(inode->i_sb);
else else
reiserfs_read_unlock_xattrs (inode->i_sb); reiserfs_read_unlock_xattrs(inode->i_sb);
reiserfs_write_unlock_xattr_i (inode); reiserfs_write_unlock_xattr_i(inode);
} }
posix_acl_release(clone); posix_acl_release(clone);
return error; return error;
@ -468,7 +461,7 @@ static int
posix_acl_access_get(struct inode *inode, const char *name, posix_acl_access_get(struct inode *inode, const char *name,
void *buffer, size_t size) void *buffer, size_t size)
{ {
if (strlen(name) != sizeof(POSIX_ACL_XATTR_ACCESS)-1) if (strlen(name) != sizeof(POSIX_ACL_XATTR_ACCESS) - 1)
return -EINVAL; return -EINVAL;
return xattr_get_acl(inode, ACL_TYPE_ACCESS, buffer, size); return xattr_get_acl(inode, ACL_TYPE_ACCESS, buffer, size);
} }
@ -477,34 +470,34 @@ static int
posix_acl_access_set(struct inode *inode, const char *name, posix_acl_access_set(struct inode *inode, const char *name,
const void *value, size_t size, int flags) const void *value, size_t size, int flags)
{ {
if (strlen(name) != sizeof(POSIX_ACL_XATTR_ACCESS)-1) if (strlen(name) != sizeof(POSIX_ACL_XATTR_ACCESS) - 1)
return -EINVAL; return -EINVAL;
return xattr_set_acl(inode, ACL_TYPE_ACCESS, value, size); return xattr_set_acl(inode, ACL_TYPE_ACCESS, value, size);
} }
static int static int posix_acl_access_del(struct inode *inode, const char *name)
posix_acl_access_del (struct inode *inode, const char *name)
{ {
struct reiserfs_inode_info *reiserfs_i = REISERFS_I(inode); struct reiserfs_inode_info *reiserfs_i = REISERFS_I(inode);
struct posix_acl **acl = &reiserfs_i->i_acl_access; struct posix_acl **acl = &reiserfs_i->i_acl_access;
if (strlen(name) != sizeof(POSIX_ACL_XATTR_ACCESS)-1) if (strlen(name) != sizeof(POSIX_ACL_XATTR_ACCESS) - 1)
return -EINVAL; return -EINVAL;
if (!IS_ERR (*acl) && *acl) { if (!IS_ERR(*acl) && *acl) {
posix_acl_release (*acl); posix_acl_release(*acl);
*acl = ERR_PTR (-ENODATA); *acl = ERR_PTR(-ENODATA);
} }
return 0; return 0;
} }
static int static int
posix_acl_access_list (struct inode *inode, const char *name, int namelen, char *out) posix_acl_access_list(struct inode *inode, const char *name, int namelen,
char *out)
{ {
int len = namelen; int len = namelen;
if (!reiserfs_posixacl (inode->i_sb)) if (!reiserfs_posixacl(inode->i_sb))
return 0; return 0;
if (out) if (out)
memcpy (out, name, len); memcpy(out, name, len);
return len; return len;
} }
@ -518,10 +511,10 @@ struct reiserfs_xattr_handler posix_acl_access_handler = {
}; };
static int static int
posix_acl_default_get (struct inode *inode, const char *name, posix_acl_default_get(struct inode *inode, const char *name,
void *buffer, size_t size) void *buffer, size_t size)
{ {
if (strlen(name) != sizeof(POSIX_ACL_XATTR_DEFAULT)-1) if (strlen(name) != sizeof(POSIX_ACL_XATTR_DEFAULT) - 1)
return -EINVAL; return -EINVAL;
return xattr_get_acl(inode, ACL_TYPE_DEFAULT, buffer, size); return xattr_get_acl(inode, ACL_TYPE_DEFAULT, buffer, size);
} }
@ -530,34 +523,34 @@ static int
posix_acl_default_set(struct inode *inode, const char *name, posix_acl_default_set(struct inode *inode, const char *name,
const void *value, size_t size, int flags) const void *value, size_t size, int flags)
{ {
if (strlen(name) != sizeof(POSIX_ACL_XATTR_DEFAULT)-1) if (strlen(name) != sizeof(POSIX_ACL_XATTR_DEFAULT) - 1)
return -EINVAL; return -EINVAL;
return xattr_set_acl(inode, ACL_TYPE_DEFAULT, value, size); return xattr_set_acl(inode, ACL_TYPE_DEFAULT, value, size);
} }
static int static int posix_acl_default_del(struct inode *inode, const char *name)
posix_acl_default_del (struct inode *inode, const char *name)
{ {
struct reiserfs_inode_info *reiserfs_i = REISERFS_I(inode); struct reiserfs_inode_info *reiserfs_i = REISERFS_I(inode);
struct posix_acl **acl = &reiserfs_i->i_acl_default; struct posix_acl **acl = &reiserfs_i->i_acl_default;
if (strlen(name) != sizeof(POSIX_ACL_XATTR_DEFAULT)-1) if (strlen(name) != sizeof(POSIX_ACL_XATTR_DEFAULT) - 1)
return -EINVAL; return -EINVAL;
if (!IS_ERR (*acl) && *acl) { if (!IS_ERR(*acl) && *acl) {
posix_acl_release (*acl); posix_acl_release(*acl);
*acl = ERR_PTR (-ENODATA); *acl = ERR_PTR(-ENODATA);
} }
return 0; return 0;
} }
static int static int
posix_acl_default_list (struct inode *inode, const char *name, int namelen, char *out) posix_acl_default_list(struct inode *inode, const char *name, int namelen,
char *out)
{ {
int len = namelen; int len = namelen;
if (!reiserfs_posixacl (inode->i_sb)) if (!reiserfs_posixacl(inode->i_sb))
return 0; return 0;
if (out) if (out)
memcpy (out, name, len); memcpy(out, name, len);
return len; return len;
} }

16
fs/reiserfs/xattr_security.c
View file

@ -9,7 +9,7 @@
#define XATTR_SECURITY_PREFIX "security." #define XATTR_SECURITY_PREFIX "security."
static int static int
security_get (struct inode *inode, const char *name, void *buffer, size_t size) security_get(struct inode *inode, const char *name, void *buffer, size_t size)
{ {
if (strlen(name) < sizeof(XATTR_SECURITY_PREFIX)) if (strlen(name) < sizeof(XATTR_SECURITY_PREFIX))
return -EINVAL; return -EINVAL;
@ -17,11 +17,11 @@ security_get (struct inode *inode, const char *name, void *buffer, size_t size)
if (is_reiserfs_priv_object(inode)) if (is_reiserfs_priv_object(inode))
return -EPERM; return -EPERM;
return reiserfs_xattr_get (inode, name, buffer, size); return reiserfs_xattr_get(inode, name, buffer, size);
} }
static int static int
security_set (struct inode *inode, const char *name, const void *buffer, security_set(struct inode *inode, const char *name, const void *buffer,
size_t size, int flags) size_t size, int flags)
{ {
if (strlen(name) < sizeof(XATTR_SECURITY_PREFIX)) if (strlen(name) < sizeof(XATTR_SECURITY_PREFIX))
@ -30,11 +30,10 @@ security_set (struct inode *inode, const char *name, const void *buffer,
if (is_reiserfs_priv_object(inode)) if (is_reiserfs_priv_object(inode))
return -EPERM; return -EPERM;
return reiserfs_xattr_set (inode, name, buffer, size, flags); return reiserfs_xattr_set(inode, name, buffer, size, flags);
} }
static int static int security_del(struct inode *inode, const char *name)
security_del (struct inode *inode, const char *name)
{ {
if (strlen(name) < sizeof(XATTR_SECURITY_PREFIX)) if (strlen(name) < sizeof(XATTR_SECURITY_PREFIX))
return -EINVAL; return -EINVAL;
@ -46,7 +45,7 @@ security_del (struct inode *inode, const char *name)
} }
static int static int
security_list (struct inode *inode, const char *name, int namelen, char *out) security_list(struct inode *inode, const char *name, int namelen, char *out)
{ {
int len = namelen; int len = namelen;
@ -54,12 +53,11 @@ security_list (struct inode *inode, const char *name, int namelen, char *out)
return 0; return 0;
if (out) if (out)
memcpy (out, name, len); memcpy(out, name, len);
return len; return len;
} }
struct reiserfs_xattr_handler security_handler = { struct reiserfs_xattr_handler security_handler = {
.prefix = XATTR_SECURITY_PREFIX, .prefix = XATTR_SECURITY_PREFIX,
.get = security_get, .get = security_get,

24
fs/reiserfs/xattr_trusted.c
View file

@ -9,43 +9,42 @@
#define XATTR_TRUSTED_PREFIX "trusted." #define XATTR_TRUSTED_PREFIX "trusted."
static int static int
trusted_get (struct inode *inode, const char *name, void *buffer, size_t size) trusted_get(struct inode *inode, const char *name, void *buffer, size_t size)
{ {
if (strlen(name) < sizeof(XATTR_TRUSTED_PREFIX)) if (strlen(name) < sizeof(XATTR_TRUSTED_PREFIX))
return -EINVAL; return -EINVAL;
if (!reiserfs_xattrs (inode->i_sb)) if (!reiserfs_xattrs(inode->i_sb))
return -EOPNOTSUPP; return -EOPNOTSUPP;
if (!(capable(CAP_SYS_ADMIN) || is_reiserfs_priv_object(inode))) if (!(capable(CAP_SYS_ADMIN) || is_reiserfs_priv_object(inode)))
return -EPERM; return -EPERM;
return reiserfs_xattr_get (inode, name, buffer, size); return reiserfs_xattr_get(inode, name, buffer, size);
} }
static int static int
trusted_set (struct inode *inode, const char *name, const void *buffer, trusted_set(struct inode *inode, const char *name, const void *buffer,
size_t size, int flags) size_t size, int flags)
{ {
if (strlen(name) < sizeof(XATTR_TRUSTED_PREFIX)) if (strlen(name) < sizeof(XATTR_TRUSTED_PREFIX))
return -EINVAL; return -EINVAL;
if (!reiserfs_xattrs (inode->i_sb)) if (!reiserfs_xattrs(inode->i_sb))
return -EOPNOTSUPP; return -EOPNOTSUPP;
if (!(capable(CAP_SYS_ADMIN) || is_reiserfs_priv_object(inode))) if (!(capable(CAP_SYS_ADMIN) || is_reiserfs_priv_object(inode)))
return -EPERM; return -EPERM;
return reiserfs_xattr_set (inode, name, buffer, size, flags); return reiserfs_xattr_set(inode, name, buffer, size, flags);
} }
static int static int trusted_del(struct inode *inode, const char *name)
trusted_del (struct inode *inode, const char *name)
{ {
if (strlen(name) < sizeof(XATTR_TRUSTED_PREFIX)) if (strlen(name) < sizeof(XATTR_TRUSTED_PREFIX))
return -EINVAL; return -EINVAL;
if (!reiserfs_xattrs (inode->i_sb)) if (!reiserfs_xattrs(inode->i_sb))
return -EOPNOTSUPP; return -EOPNOTSUPP;
if (!(capable(CAP_SYS_ADMIN) || is_reiserfs_priv_object(inode))) if (!(capable(CAP_SYS_ADMIN) || is_reiserfs_priv_object(inode)))
@ -55,23 +54,22 @@ trusted_del (struct inode *inode, const char *name)
} }
static int static int
trusted_list (struct inode *inode, const char *name, int namelen, char *out) trusted_list(struct inode *inode, const char *name, int namelen, char *out)
{ {
int len = namelen; int len = namelen;
if (!reiserfs_xattrs (inode->i_sb)) if (!reiserfs_xattrs(inode->i_sb))
return 0; return 0;
if (!(capable(CAP_SYS_ADMIN) || is_reiserfs_priv_object(inode))) if (!(capable(CAP_SYS_ADMIN) || is_reiserfs_priv_object(inode)))
return 0; return 0;
if (out) if (out)
memcpy (out, name, len); memcpy(out, name, len);
return len; return len;
} }
struct reiserfs_xattr_handler trusted_handler = { struct reiserfs_xattr_handler trusted_handler = {
.prefix = XATTR_TRUSTED_PREFIX, .prefix = XATTR_TRUSTED_PREFIX,
.get = trusted_get, .get = trusted_get,

37
fs/reiserfs/xattr_user.c
View file

@ -13,7 +13,7 @@
#define XATTR_USER_PREFIX "user." #define XATTR_USER_PREFIX "user."
static int static int
user_get (struct inode *inode, const char *name, void *buffer, size_t size) user_get(struct inode *inode, const char *name, void *buffer, size_t size)
{ {
int error; int error;
@ -21,18 +21,18 @@ user_get (struct inode *inode, const char *name, void *buffer, size_t size)
if (strlen(name) < sizeof(XATTR_USER_PREFIX)) if (strlen(name) < sizeof(XATTR_USER_PREFIX))
return -EINVAL; return -EINVAL;
if (!reiserfs_xattrs_user (inode->i_sb)) if (!reiserfs_xattrs_user(inode->i_sb))
return -EOPNOTSUPP; return -EOPNOTSUPP;
error = reiserfs_permission_locked (inode, MAY_READ, NULL); error = reiserfs_permission_locked(inode, MAY_READ, NULL);
if (error) if (error)
return error; return error;
return reiserfs_xattr_get (inode, name, buffer, size); return reiserfs_xattr_get(inode, name, buffer, size);
} }
static int static int
user_set (struct inode *inode, const char *name, const void *buffer, user_set(struct inode *inode, const char *name, const void *buffer,
size_t size, int flags) size_t size, int flags)
{ {
@ -41,36 +41,35 @@ user_set (struct inode *inode, const char *name, const void *buffer,
if (strlen(name) < sizeof(XATTR_USER_PREFIX)) if (strlen(name) < sizeof(XATTR_USER_PREFIX))
return -EINVAL; return -EINVAL;
if (!reiserfs_xattrs_user (inode->i_sb)) if (!reiserfs_xattrs_user(inode->i_sb))
return -EOPNOTSUPP; return -EOPNOTSUPP;
if (!S_ISREG (inode->i_mode) && if (!S_ISREG(inode->i_mode) &&
(!S_ISDIR (inode->i_mode) || inode->i_mode & S_ISVTX)) (!S_ISDIR(inode->i_mode) || inode->i_mode & S_ISVTX))
return -EPERM; return -EPERM;
error = reiserfs_permission_locked (inode, MAY_WRITE, NULL); error = reiserfs_permission_locked(inode, MAY_WRITE, NULL);
if (error) if (error)
return error; return error;
return reiserfs_xattr_set (inode, name, buffer, size, flags); return reiserfs_xattr_set(inode, name, buffer, size, flags);
} }
static int static int user_del(struct inode *inode, const char *name)
user_del (struct inode *inode, const char *name)
{ {
int error; int error;
if (strlen(name) < sizeof(XATTR_USER_PREFIX)) if (strlen(name) < sizeof(XATTR_USER_PREFIX))
return -EINVAL; return -EINVAL;
if (!reiserfs_xattrs_user (inode->i_sb)) if (!reiserfs_xattrs_user(inode->i_sb))
return -EOPNOTSUPP; return -EOPNOTSUPP;
if (!S_ISREG (inode->i_mode) && if (!S_ISREG(inode->i_mode) &&
(!S_ISDIR (inode->i_mode) || inode->i_mode & S_ISVTX)) (!S_ISDIR(inode->i_mode) || inode->i_mode & S_ISVTX))
return -EPERM; return -EPERM;
error = reiserfs_permission_locked (inode, MAY_WRITE, NULL); error = reiserfs_permission_locked(inode, MAY_WRITE, NULL);
if (error) if (error)
return error; return error;
@ -78,14 +77,14 @@ user_del (struct inode *inode, const char *name)
} }
static int static int
user_list (struct inode *inode, const char *name, int namelen, char *out) user_list(struct inode *inode, const char *name, int namelen, char *out)
{ {
int len = namelen; int len = namelen;
if (!reiserfs_xattrs_user (inode->i_sb)) if (!reiserfs_xattrs_user(inode->i_sb))
return 0; return 0;
if (out) if (out)
memcpy (out, name, len); memcpy(out, name, len);
return len; return len;
} }

42
include/linux/reiserfs_acl.h
View file

@ -46,14 +46,14 @@ static inline int reiserfs_acl_count(size_t size)
} }
} }
#ifdef CONFIG_REISERFS_FS_POSIX_ACL #ifdef CONFIG_REISERFS_FS_POSIX_ACL
struct posix_acl * reiserfs_get_acl(struct inode *inode, int type); struct posix_acl *reiserfs_get_acl(struct inode *inode, int type);
int reiserfs_acl_chmod (struct inode *inode); int reiserfs_acl_chmod(struct inode *inode);
int reiserfs_inherit_default_acl (struct inode *dir, struct dentry *dentry, struct inode *inode); int reiserfs_inherit_default_acl(struct inode *dir, struct dentry *dentry,
int reiserfs_cache_default_acl (struct inode *dir); struct inode *inode);
extern int reiserfs_xattr_posix_acl_init (void) __init; int reiserfs_cache_default_acl(struct inode *dir);
extern int reiserfs_xattr_posix_acl_exit (void); extern int reiserfs_xattr_posix_acl_init(void) __init;
extern int reiserfs_xattr_posix_acl_exit(void);
extern struct reiserfs_xattr_handler posix_acl_default_handler; extern struct reiserfs_xattr_handler posix_acl_default_handler;
extern struct reiserfs_xattr_handler posix_acl_access_handler; extern struct reiserfs_xattr_handler posix_acl_access_handler;
#else #else
@ -61,26 +61,24 @@ extern struct reiserfs_xattr_handler posix_acl_access_handler;
#define reiserfs_get_acl NULL #define reiserfs_get_acl NULL
#define reiserfs_cache_default_acl(inode) 0 #define reiserfs_cache_default_acl(inode) 0
static inline int static inline int reiserfs_xattr_posix_acl_init(void)
reiserfs_xattr_posix_acl_init (void) {
return 0;
}
static inline int reiserfs_xattr_posix_acl_exit(void)
{
return 0;
}
static inline int reiserfs_acl_chmod(struct inode *inode)
{ {
return 0; return 0;
} }
static inline int static inline int
reiserfs_xattr_posix_acl_exit (void) reiserfs_inherit_default_acl(const struct inode *dir, struct dentry *dentry,
{ struct inode *inode)
return 0;
}
static inline int
reiserfs_acl_chmod (struct inode *inode)
{
return 0;
}
static inline int
reiserfs_inherit_default_acl (const struct inode *dir, struct dentry *dentry, struct inode *inode)
{ {
return 0; return 0;
} }

819
include/linux/reiserfs_fs.h
View file

File diff suppressed because it is too large Load diff

5
include/linux/reiserfs_fs_i.h
View file

@ -27,9 +27,8 @@ typedef enum {
i_data_log = 0x0080, i_data_log = 0x0080,
} reiserfs_inode_flags; } reiserfs_inode_flags;
struct reiserfs_inode_info { struct reiserfs_inode_info {
__u32 i_key [4];/* key is still 4 32 bit integers */ __u32 i_key[4]; /* key is still 4 32 bit integers */
/** transient inode flags that are never stored on disk. Bitmasks /** transient inode flags that are never stored on disk. Bitmasks
for this field are defined above. */ for this field are defined above. */
__u32 i_flags; __u32 i_flags;
@ -51,7 +50,7 @@ struct reiserfs_inode_info {
/* we use these for fsync or O_SYNC to decide which transaction /* we use these for fsync or O_SYNC to decide which transaction
** needs to be committed in order for this inode to be properly ** needs to be committed in order for this inode to be properly
** flushed */ ** flushed */
unsigned long i_trans_id ; unsigned long i_trans_id;
struct reiserfs_journal_list *i_jl; struct reiserfs_journal_list *i_jl;
struct posix_acl *i_acl_access; struct posix_acl *i_acl_access;

204
include/linux/reiserfs_fs_sb.h
View file

@ -117,27 +117,27 @@ typedef enum {
** to a given transaction. ** to a given transaction.
*/ */
struct reiserfs_journal_cnode { struct reiserfs_journal_cnode {
struct buffer_head *bh ; /* real buffer head */ struct buffer_head *bh; /* real buffer head */
struct super_block *sb ; /* dev of real buffer head */ struct super_block *sb; /* dev of real buffer head */
__u32 blocknr ; /* block number of real buffer head, == 0 when buffer on disk */ __u32 blocknr; /* block number of real buffer head, == 0 when buffer on disk */
long state ; long state;
struct reiserfs_journal_list *jlist ; /* journal list this cnode lives in */ struct reiserfs_journal_list *jlist; /* journal list this cnode lives in */
struct reiserfs_journal_cnode *next ; /* next in transaction list */ struct reiserfs_journal_cnode *next; /* next in transaction list */
struct reiserfs_journal_cnode *prev ; /* prev in transaction list */ struct reiserfs_journal_cnode *prev; /* prev in transaction list */
struct reiserfs_journal_cnode *hprev ; /* prev in hash list */ struct reiserfs_journal_cnode *hprev; /* prev in hash list */
struct reiserfs_journal_cnode *hnext ; /* next in hash list */ struct reiserfs_journal_cnode *hnext; /* next in hash list */
}; };
struct reiserfs_bitmap_node { struct reiserfs_bitmap_node {
int id ; int id;
char *data ; char *data;
struct list_head list ; struct list_head list;
} ; };
struct reiserfs_list_bitmap { struct reiserfs_list_bitmap {
struct reiserfs_journal_list *journal_list ; struct reiserfs_journal_list *journal_list;
struct reiserfs_bitmap_node **bitmaps ; struct reiserfs_bitmap_node **bitmaps;
} ; };
/* /*
** one of these for each transaction. The most important part here is the j_realblock. ** one of these for each transaction. The most important part here is the j_realblock.
@ -146,19 +146,19 @@ struct reiserfs_list_bitmap {
** and to make sure every real block in a transaction is on disk before allowing the log area ** and to make sure every real block in a transaction is on disk before allowing the log area
** to be overwritten */ ** to be overwritten */
struct reiserfs_journal_list { struct reiserfs_journal_list {
unsigned long j_start ; unsigned long j_start;
unsigned long j_state; unsigned long j_state;
unsigned long j_len ; unsigned long j_len;
atomic_t j_nonzerolen ; atomic_t j_nonzerolen;
atomic_t j_commit_left ; atomic_t j_commit_left;
atomic_t j_older_commits_done ; /* all commits older than this on disk*/ atomic_t j_older_commits_done; /* all commits older than this on disk */
struct semaphore j_commit_lock; struct semaphore j_commit_lock;
unsigned long j_trans_id ; unsigned long j_trans_id;
time_t j_timestamp ; time_t j_timestamp;
struct reiserfs_list_bitmap *j_list_bitmap ; struct reiserfs_list_bitmap *j_list_bitmap;
struct buffer_head *j_commit_bh ; /* commit buffer head */ struct buffer_head *j_commit_bh; /* commit buffer head */
struct reiserfs_journal_cnode *j_realblock ; struct reiserfs_journal_cnode *j_realblock;
struct reiserfs_journal_cnode *j_freedlist ; /* list of buffers that were freed during this trans. free each of these on flush */ struct reiserfs_journal_cnode *j_freedlist; /* list of buffers that were freed during this trans. free each of these on flush */
/* time ordered list of all active transactions */ /* time ordered list of all active transactions */
struct list_head j_list; struct list_head j_list;
@ -170,54 +170,54 @@ struct reiserfs_journal_list {
/* list of data=ordered buffers in need of flush before commit */ /* list of data=ordered buffers in need of flush before commit */
struct list_head j_bh_list; struct list_head j_bh_list;
int j_refcount; int j_refcount;
} ; };
struct reiserfs_journal { struct reiserfs_journal {
struct buffer_head ** j_ap_blocks ; /* journal blocks on disk */ struct buffer_head **j_ap_blocks; /* journal blocks on disk */
struct reiserfs_journal_cnode *j_last ; /* newest journal block */ struct reiserfs_journal_cnode *j_last; /* newest journal block */
struct reiserfs_journal_cnode *j_first ; /* oldest journal block. start here for traverse */ struct reiserfs_journal_cnode *j_first; /* oldest journal block. start here for traverse */
struct file *j_dev_file; struct file *j_dev_file;
struct block_device *j_dev_bd; struct block_device *j_dev_bd;
int j_1st_reserved_block; /* first block on s_dev of reserved area journal */ int j_1st_reserved_block; /* first block on s_dev of reserved area journal */
long j_state ; long j_state;
unsigned long j_trans_id ; unsigned long j_trans_id;
unsigned long j_mount_id ; unsigned long j_mount_id;
unsigned long j_start ; /* start of current waiting commit (index into j_ap_blocks) */ unsigned long j_start; /* start of current waiting commit (index into j_ap_blocks) */
unsigned long j_len ; /* lenght of current waiting commit */ unsigned long j_len; /* lenght of current waiting commit */
unsigned long j_len_alloc ; /* number of buffers requested by journal_begin() */ unsigned long j_len_alloc; /* number of buffers requested by journal_begin() */
atomic_t j_wcount ; /* count of writers for current commit */ atomic_t j_wcount; /* count of writers for current commit */
unsigned long j_bcount ; /* batch count. allows turning X transactions into 1 */ unsigned long j_bcount; /* batch count. allows turning X transactions into 1 */
unsigned long j_first_unflushed_offset ; /* first unflushed transactions offset */ unsigned long j_first_unflushed_offset; /* first unflushed transactions offset */
unsigned long j_last_flush_trans_id ; /* last fully flushed journal timestamp */ unsigned long j_last_flush_trans_id; /* last fully flushed journal timestamp */
struct buffer_head *j_header_bh ; struct buffer_head *j_header_bh;
time_t j_trans_start_time ; /* time this transaction started */ time_t j_trans_start_time; /* time this transaction started */
struct semaphore j_lock; struct semaphore j_lock;
struct semaphore j_flush_sem; struct semaphore j_flush_sem;
wait_queue_head_t j_join_wait ; /* wait for current transaction to finish before starting new one */ wait_queue_head_t j_join_wait; /* wait for current transaction to finish before starting new one */
atomic_t j_jlock ; /* lock for j_join_wait */ atomic_t j_jlock; /* lock for j_join_wait */
int j_list_bitmap_index ; /* number of next list bitmap to use */ int j_list_bitmap_index; /* number of next list bitmap to use */
int j_must_wait ; /* no more journal begins allowed. MUST sleep on j_join_wait */ int j_must_wait; /* no more journal begins allowed. MUST sleep on j_join_wait */
int j_next_full_flush ; /* next journal_end will flush all journal list */ int j_next_full_flush; /* next journal_end will flush all journal list */
int j_next_async_flush ; /* next journal_end will flush all async commits */ int j_next_async_flush; /* next journal_end will flush all async commits */
int j_cnode_used ; /* number of cnodes on the used list */ int j_cnode_used; /* number of cnodes on the used list */
int j_cnode_free ; /* number of cnodes on the free list */ int j_cnode_free; /* number of cnodes on the free list */
unsigned int j_trans_max ; /* max number of blocks in a transaction. */ unsigned int j_trans_max; /* max number of blocks in a transaction. */
unsigned int j_max_batch ; /* max number of blocks to batch into a trans */ unsigned int j_max_batch; /* max number of blocks to batch into a trans */
unsigned int j_max_commit_age ; /* in seconds, how old can an async commit be */ unsigned int j_max_commit_age; /* in seconds, how old can an async commit be */
unsigned int j_max_trans_age ; /* in seconds, how old can a transaction be */ unsigned int j_max_trans_age; /* in seconds, how old can a transaction be */
unsigned int j_default_max_commit_age ; /* the default for the max commit age */ unsigned int j_default_max_commit_age; /* the default for the max commit age */
struct reiserfs_journal_cnode *j_cnode_free_list ; struct reiserfs_journal_cnode *j_cnode_free_list;
struct reiserfs_journal_cnode *j_cnode_free_orig ; /* orig pointer returned from vmalloc */ struct reiserfs_journal_cnode *j_cnode_free_orig; /* orig pointer returned from vmalloc */
struct reiserfs_journal_list *j_current_jl; struct reiserfs_journal_list *j_current_jl;
int j_free_bitmap_nodes ; int j_free_bitmap_nodes;
int j_used_bitmap_nodes ; int j_used_bitmap_nodes;
int j_num_lists; /* total number of active transactions */ int j_num_lists; /* total number of active transactions */
int j_num_work_lists; /* number that need attention from kreiserfsd */ int j_num_work_lists; /* number that need attention from kreiserfsd */
@ -228,23 +228,23 @@ struct reiserfs_journal {
/* debugging to make sure things are committed in order */ /* debugging to make sure things are committed in order */
int j_last_commit_id; int j_last_commit_id;
struct list_head j_bitmap_nodes ; struct list_head j_bitmap_nodes;
struct list_head j_dirty_buffers ; struct list_head j_dirty_buffers;
spinlock_t j_dirty_buffers_lock ; /* protects j_dirty_buffers */ spinlock_t j_dirty_buffers_lock; /* protects j_dirty_buffers */
/* list of all active transactions */ /* list of all active transactions */
struct list_head j_journal_list; struct list_head j_journal_list;
/* lists that haven't been touched by writeback attempts */ /* lists that haven't been touched by writeback attempts */
struct list_head j_working_list; struct list_head j_working_list;
struct reiserfs_list_bitmap j_list_bitmap[JOURNAL_NUM_BITMAPS] ; /* array of bitmaps to record the deleted blocks */ struct reiserfs_list_bitmap j_list_bitmap[JOURNAL_NUM_BITMAPS]; /* array of bitmaps to record the deleted blocks */
struct reiserfs_journal_cnode *j_hash_table[JOURNAL_HASH_SIZE] ; /* hash table for real buffer heads in current trans */ struct reiserfs_journal_cnode *j_hash_table[JOURNAL_HASH_SIZE]; /* hash table for real buffer heads in current trans */
struct reiserfs_journal_cnode *j_list_hash_table[JOURNAL_HASH_SIZE] ; /* hash table for all the real buffer heads in all struct reiserfs_journal_cnode *j_list_hash_table[JOURNAL_HASH_SIZE]; /* hash table for all the real buffer heads in all
the transactions */ the transactions */
struct list_head j_prealloc_list; /* list of inodes which have preallocated blocks */ struct list_head j_prealloc_list; /* list of inodes which have preallocated blocks */
int j_persistent_trans; int j_persistent_trans;
unsigned long j_max_trans_size ; unsigned long j_max_trans_size;
unsigned long j_max_batch_size ; unsigned long j_max_batch_size;
int j_errno; int j_errno;
@ -259,13 +259,11 @@ enum journal_state_bits {
J_ABORTED, /* set when log is aborted */ J_ABORTED, /* set when log is aborted */
}; };
#define JOURNAL_DESC_MAGIC "ReIsErLB" /* ick. magic string to find desc blocks in the journal */ #define JOURNAL_DESC_MAGIC "ReIsErLB" /* ick. magic string to find desc blocks in the journal */
typedef __u32 (*hashf_t) (const signed char *, int); typedef __u32(*hashf_t) (const signed char *, int);
struct reiserfs_bitmap_info struct reiserfs_bitmap_info {
{
// FIXME: Won't work with block sizes > 8K // FIXME: Won't work with block sizes > 8K
__u16 first_zero_hint; __u16 first_zero_hint;
__u16 free_count; __u16 free_count;
@ -276,8 +274,7 @@ struct proc_dir_entry;
#if defined( CONFIG_PROC_FS ) && defined( CONFIG_REISERFS_PROC_INFO ) #if defined( CONFIG_PROC_FS ) && defined( CONFIG_REISERFS_PROC_INFO )
typedef unsigned long int stat_cnt_t; typedef unsigned long int stat_cnt_t;
typedef struct reiserfs_proc_info_data typedef struct reiserfs_proc_info_data {
{
spinlock_t lock; spinlock_t lock;
int exiting; int exiting;
int max_hash_collisions; int max_hash_collisions;
@ -298,22 +295,22 @@ typedef struct reiserfs_proc_info_data
stat_cnt_t leaves_removable; stat_cnt_t leaves_removable;
/* balances per level. Use explicit 5 as MAX_HEIGHT is not visible yet. */ /* balances per level. Use explicit 5 as MAX_HEIGHT is not visible yet. */
stat_cnt_t balance_at[ 5 ]; /* XXX */ stat_cnt_t balance_at[5]; /* XXX */
/* sbk == search_by_key */ /* sbk == search_by_key */
stat_cnt_t sbk_read_at[ 5 ]; /* XXX */ stat_cnt_t sbk_read_at[5]; /* XXX */
stat_cnt_t sbk_fs_changed[ 5 ]; stat_cnt_t sbk_fs_changed[5];
stat_cnt_t sbk_restarted[ 5 ]; stat_cnt_t sbk_restarted[5];
stat_cnt_t items_at[ 5 ]; /* XXX */ stat_cnt_t items_at[5]; /* XXX */
stat_cnt_t free_at[ 5 ]; /* XXX */ stat_cnt_t free_at[5]; /* XXX */
stat_cnt_t can_node_be_removed[ 5 ]; /* XXX */ stat_cnt_t can_node_be_removed[5]; /* XXX */
long int lnum[ 5 ]; /* XXX */ long int lnum[5]; /* XXX */
long int rnum[ 5 ]; /* XXX */ long int rnum[5]; /* XXX */
long int lbytes[ 5 ]; /* XXX */ long int lbytes[5]; /* XXX */
long int rbytes[ 5 ]; /* XXX */ long int rbytes[5]; /* XXX */
stat_cnt_t get_neighbors[ 5 ]; stat_cnt_t get_neighbors[5];
stat_cnt_t get_neighbors_restart[ 5 ]; stat_cnt_t get_neighbors_restart[5];
stat_cnt_t need_l_neighbor[ 5 ]; stat_cnt_t need_l_neighbor[5];
stat_cnt_t need_r_neighbor[ 5 ]; stat_cnt_t need_r_neighbor[5];
stat_cnt_t free_block; stat_cnt_t free_block;
struct __scan_bitmap_stats { struct __scan_bitmap_stats {
@ -343,23 +340,22 @@ typedef struct reiserfs_proc_info_data
} journal; } journal;
} reiserfs_proc_info_data_t; } reiserfs_proc_info_data_t;
#else #else
typedef struct reiserfs_proc_info_data typedef struct reiserfs_proc_info_data {
{} reiserfs_proc_info_data_t; } reiserfs_proc_info_data_t;
#endif #endif
/* reiserfs union of in-core super block data */ /* reiserfs union of in-core super block data */
struct reiserfs_sb_info struct reiserfs_sb_info {
{ struct buffer_head *s_sbh; /* Buffer containing the super block */
struct buffer_head * s_sbh; /* Buffer containing the super block */
/* both the comment and the choice of /* both the comment and the choice of
name are unclear for s_rs -Hans */ name are unclear for s_rs -Hans */
struct reiserfs_super_block * s_rs; /* Pointer to the super block in the buffer */ struct reiserfs_super_block *s_rs; /* Pointer to the super block in the buffer */
struct reiserfs_bitmap_info * s_ap_bitmap; struct reiserfs_bitmap_info *s_ap_bitmap;
struct reiserfs_journal *s_journal ; /* pointer to journal information */ struct reiserfs_journal *s_journal; /* pointer to journal information */
unsigned short s_mount_state; /* reiserfs state (valid, invalid) */ unsigned short s_mount_state; /* reiserfs state (valid, invalid) */
/* Comment? -Hans */ /* Comment? -Hans */
void (*end_io_handler)(struct buffer_head *, int); void (*end_io_handler) (struct buffer_head *, int);
hashf_t s_hash_function; /* pointer to function which is used hashf_t s_hash_function; /* pointer to function which is used
to sort names in directory. Set on to sort names in directory. Set on
mount */ mount */
@ -504,14 +500,13 @@ enum reiserfs_mount_options {
#define reiserfs_error_panic(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_ERROR_PANIC)) #define reiserfs_error_panic(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_ERROR_PANIC))
#define reiserfs_error_ro(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_ERROR_RO)) #define reiserfs_error_ro(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_ERROR_RO))
void reiserfs_file_buffer (struct buffer_head * bh, int list); void reiserfs_file_buffer(struct buffer_head *bh, int list);
extern struct file_system_type reiserfs_fs_type; extern struct file_system_type reiserfs_fs_type;
int reiserfs_resize(struct super_block *, unsigned long) ; int reiserfs_resize(struct super_block *, unsigned long);
#define CARRY_ON 0 #define CARRY_ON 0
#define SCHEDULE_OCCURRED 1 #define SCHEDULE_OCCURRED 1
#define SB_BUFFER_WITH_SB(s) (REISERFS_SB(s)->s_sbh) #define SB_BUFFER_WITH_SB(s) (REISERFS_SB(s)->s_sbh)
#define SB_JOURNAL(s) (REISERFS_SB(s)->s_journal) #define SB_JOURNAL(s) (REISERFS_SB(s)->s_journal)
#define SB_JOURNAL_1st_RESERVED_BLOCK(s) (SB_JOURNAL(s)->j_1st_reserved_block) #define SB_JOURNAL_1st_RESERVED_BLOCK(s) (SB_JOURNAL(s)->j_1st_reserved_block)
@ -525,13 +520,14 @@ int reiserfs_resize(struct super_block *, unsigned long) ;
*/ */
static inline char *reiserfs_bdevname(struct super_block *s) static inline char *reiserfs_bdevname(struct super_block *s)
{ {
return (s == NULL) ? "Null superblock" : s -> s_id; return (s == NULL) ? "Null superblock" : s->s_id;
} }
#define reiserfs_is_journal_aborted(journal) (unlikely (__reiserfs_is_journal_aborted (journal))) #define reiserfs_is_journal_aborted(journal) (unlikely (__reiserfs_is_journal_aborted (journal)))
static inline int __reiserfs_is_journal_aborted (struct reiserfs_journal *journal) static inline int __reiserfs_is_journal_aborted(struct reiserfs_journal
*journal)
{ {
return test_bit (J_ABORTED, &journal->j_state); return test_bit(J_ABORTED, &journal->j_state);
} }
#endif /* _LINUX_REISER_FS_SB */ #endif /* _LINUX_REISER_FS_SB */

100
include/linux/reiserfs_xattr.h
View file

@ -18,37 +18,37 @@ struct reiserfs_xattr_header {
struct reiserfs_xattr_handler { struct reiserfs_xattr_handler {
char *prefix; char *prefix;
int (*init)(void); int (*init) (void);
void (*exit)(void); void (*exit) (void);
int (*get)(struct inode *inode, const char *name, void *buffer, int (*get) (struct inode * inode, const char *name, void *buffer,
size_t size); size_t size);
int (*set)(struct inode *inode, const char *name, const void *buffer, int (*set) (struct inode * inode, const char *name, const void *buffer,
size_t size, int flags); size_t size, int flags);
int (*del)(struct inode *inode, const char *name); int (*del) (struct inode * inode, const char *name);
int (*list)(struct inode *inode, const char *name, int namelen, char *out); int (*list) (struct inode * inode, const char *name, int namelen,
char *out);
struct list_head handlers; struct list_head handlers;
}; };
#ifdef CONFIG_REISERFS_FS_XATTR #ifdef CONFIG_REISERFS_FS_XATTR
#define is_reiserfs_priv_object(inode) IS_PRIVATE(inode) #define is_reiserfs_priv_object(inode) IS_PRIVATE(inode)
#define has_xattr_dir(inode) (REISERFS_I(inode)->i_flags & i_has_xattr_dir) #define has_xattr_dir(inode) (REISERFS_I(inode)->i_flags & i_has_xattr_dir)
ssize_t reiserfs_getxattr (struct dentry *dentry, const char *name, ssize_t reiserfs_getxattr(struct dentry *dentry, const char *name,
void *buffer, size_t size); void *buffer, size_t size);
int reiserfs_setxattr (struct dentry *dentry, const char *name, int reiserfs_setxattr(struct dentry *dentry, const char *name,
const void *value, size_t size, int flags); const void *value, size_t size, int flags);
ssize_t reiserfs_listxattr (struct dentry *dentry, char *buffer, size_t size); ssize_t reiserfs_listxattr(struct dentry *dentry, char *buffer, size_t size);
int reiserfs_removexattr (struct dentry *dentry, const char *name); int reiserfs_removexattr(struct dentry *dentry, const char *name);
int reiserfs_delete_xattrs (struct inode *inode); int reiserfs_delete_xattrs(struct inode *inode);
int reiserfs_chown_xattrs (struct inode *inode, struct iattr *attrs); int reiserfs_chown_xattrs(struct inode *inode, struct iattr *attrs);
int reiserfs_xattr_init (struct super_block *sb, int mount_flags); int reiserfs_xattr_init(struct super_block *sb, int mount_flags);
int reiserfs_permission (struct inode *inode, int mask, struct nameidata *nd); int reiserfs_permission(struct inode *inode, int mask, struct nameidata *nd);
int reiserfs_permission_locked (struct inode *inode, int mask, struct nameidata *nd); int reiserfs_permission_locked(struct inode *inode, int mask,
struct nameidata *nd);
int reiserfs_xattr_del (struct inode *, const char *); int reiserfs_xattr_del(struct inode *, const char *);
int reiserfs_xattr_get (const struct inode *, const char *, void *, size_t); int reiserfs_xattr_get(const struct inode *, const char *, void *, size_t);
int reiserfs_xattr_set (struct inode *, const char *, const void *, int reiserfs_xattr_set(struct inode *, const char *, const void *, size_t, int);
size_t, int);
extern struct reiserfs_xattr_handler user_handler; extern struct reiserfs_xattr_handler user_handler;
extern struct reiserfs_xattr_handler trusted_handler; extern struct reiserfs_xattr_handler trusted_handler;
@ -56,55 +56,46 @@ extern struct reiserfs_xattr_handler trusted_handler;
extern struct reiserfs_xattr_handler security_handler; extern struct reiserfs_xattr_handler security_handler;
#endif #endif
int reiserfs_xattr_register_handlers (void) __init; int reiserfs_xattr_register_handlers(void) __init;
void reiserfs_xattr_unregister_handlers (void); void reiserfs_xattr_unregister_handlers(void);
static inline void static inline void reiserfs_write_lock_xattrs(struct super_block *sb)
reiserfs_write_lock_xattrs(struct super_block *sb)
{ {
down_write (&REISERFS_XATTR_DIR_SEM(sb)); down_write(&REISERFS_XATTR_DIR_SEM(sb));
} }
static inline void static inline void reiserfs_write_unlock_xattrs(struct super_block *sb)
reiserfs_write_unlock_xattrs(struct super_block *sb)
{ {
up_write (&REISERFS_XATTR_DIR_SEM(sb)); up_write(&REISERFS_XATTR_DIR_SEM(sb));
} }
static inline void static inline void reiserfs_read_lock_xattrs(struct super_block *sb)
reiserfs_read_lock_xattrs(struct super_block *sb)
{ {
down_read (&REISERFS_XATTR_DIR_SEM(sb)); down_read(&REISERFS_XATTR_DIR_SEM(sb));
} }
static inline void static inline void reiserfs_read_unlock_xattrs(struct super_block *sb)
reiserfs_read_unlock_xattrs(struct super_block *sb)
{ {
up_read (&REISERFS_XATTR_DIR_SEM(sb)); up_read(&REISERFS_XATTR_DIR_SEM(sb));
} }
static inline void static inline void reiserfs_write_lock_xattr_i(struct inode *inode)
reiserfs_write_lock_xattr_i(struct inode *inode)
{ {
down_write (&REISERFS_I(inode)->xattr_sem); down_write(&REISERFS_I(inode)->xattr_sem);
} }
static inline void static inline void reiserfs_write_unlock_xattr_i(struct inode *inode)
reiserfs_write_unlock_xattr_i(struct inode *inode)
{ {
up_write (&REISERFS_I(inode)->xattr_sem); up_write(&REISERFS_I(inode)->xattr_sem);
} }
static inline void static inline void reiserfs_read_lock_xattr_i(struct inode *inode)
reiserfs_read_lock_xattr_i(struct inode *inode)
{ {
down_read (&REISERFS_I(inode)->xattr_sem); down_read(&REISERFS_I(inode)->xattr_sem);
} }
static inline void static inline void reiserfs_read_unlock_xattr_i(struct inode *inode)
reiserfs_read_unlock_xattr_i(struct inode *inode)
{ {
up_read (&REISERFS_I(inode)->xattr_sem); up_read(&REISERFS_I(inode)->xattr_sem);
} }
static inline void static inline void reiserfs_mark_inode_private(struct inode *inode)
reiserfs_mark_inode_private(struct inode *inode)
{ {
inode->i_flags |= S_PRIVATE; inode->i_flags |= S_PRIVATE;
} }
@ -127,9 +118,16 @@ reiserfs_mark_inode_private(struct inode *inode)
#define reiserfs_xattr_register_handlers() 0 #define reiserfs_xattr_register_handlers() 0
#define reiserfs_xattr_unregister_handlers() #define reiserfs_xattr_unregister_handlers()
static inline int reiserfs_delete_xattrs (struct inode *inode) { return 0; }; static inline int reiserfs_delete_xattrs(struct inode *inode)
static inline int reiserfs_chown_xattrs (struct inode *inode, struct iattr *attrs) { return 0; }; {
static inline int reiserfs_xattr_init (struct super_block *sb, int mount_flags) return 0;
};
static inline int reiserfs_chown_xattrs(struct inode *inode,
struct iattr *attrs)
{
return 0;
};
static inline int reiserfs_xattr_init(struct super_block *sb, int mount_flags)
{ {
sb->s_flags = (sb->s_flags & ~MS_POSIXACL); /* to be sure */ sb->s_flags = (sb->s_flags & ~MS_POSIXACL); /* to be sure */
return 0; return 0;