microsoft
/
WSL2-Linux-Kernel
зеркало из https://github.com/microsoft/WSL2-Linux-Kernel.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

reiserfs: run scripts/Lindent on reiserfs code 

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
Родитель 7fa94c8868
Коммит bd4c625c06
30 изменённых файлов: 23428 добавлений и 21662 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

1820
fs/reiserfs/bitmap.c
Просмотреть файл

Разница между файлами не показана из-за своего большого размера Загрузить разницу

454
fs/reiserfs/dir.c
Просмотреть файл

@ -12,264 +12,286 @@
#include <linux/buffer_head.h> #include <linux/buffer_head.h>
#include <asm/uaccess.h> #include <asm/uaccess.h>
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,
.readdir = reiserfs_readdir, .readdir = reiserfs_readdir,
.fsync = reiserfs_dir_fsync, .fsync = reiserfs_dir_fsync,
.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,
struct inode *inode = dentry->d_inode; int datasync)
int err; {
reiserfs_write_lock(inode->i_sb); struct inode *inode = dentry->d_inode;
err = reiserfs_commit_for_inode(inode) ; int err;
reiserfs_write_unlock(inode->i_sb) ; reiserfs_write_lock(inode->i_sb);
if (err < 0) err = reiserfs_commit_for_inode(inode);
return err; reiserfs_write_unlock(inode->i_sb);
return 0; if (err < 0)
return err;
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 =
if (search_res == IO_ERROR) { search_by_entry_key(inode->i_sb, &pos_key, &path_to_entry,
// FIXME: we could just skip part of directory which could &de);
// not be read if (search_res == IO_ERROR) {
ret = -EIO; // FIXME: we could just skip part of directory which could
goto out; // not be read
} ret = -EIO;
entry_num = de.de_entry_num;
bh = de.de_bh;
item_num = de.de_item_num;
ih = de.de_ih;
store_ih (&tmp_ih, ih);
/* we must have found item, that is item of this directory, */
RFALSE( COMP_SHORT_KEYS (&(ih->ih_key), &pos_key),
"vs-9000: found item %h does not match to dir we readdir %K",
ih, &pos_key);
RFALSE( item_num > B_NR_ITEMS (bh) - 1,
"vs-9005 item_num == %d, item amount == %d",
item_num, B_NR_ITEMS (bh));
/* and entry must be not more than number of entries in the item */
RFALSE( I_ENTRY_COUNT (ih) < entry_num,
"vs-9010: entry number is too big %d (%d)",
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 */
struct reiserfs_de_head * deh = B_I_DEH (bh, ih) + entry_num;
for (; entry_num < I_ENTRY_COUNT (ih); entry_num ++, deh ++) {
int d_reclen;
char * d_name;
off_t d_off;
ino_t d_ino;
if (!de_visible (deh))
/* it is hidden entry */
continue;
d_reclen = entry_length (bh, ih, entry_num);
d_name = B_I_DEH_ENTRY_FILE_NAME (bh, ih, deh);
if (!d_name[d_reclen - 1])
d_reclen = strlen (d_name);
if (d_reclen > REISERFS_MAX_NAME(inode->i_sb->s_blocksize)){
/* too big to send back to VFS */
continue ;
}
/* Ignore the .reiserfs_priv entry */
if (reiserfs_xattrs (inode->i_sb) &&
!old_format_only(inode->i_sb) &&
filp->f_dentry == inode->i_sb->s_root &&
REISERFS_SB(inode->i_sb)->priv_root &&
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)) {
continue;
}
d_off = deh_offset (deh);
filp->f_pos = d_off ;
d_ino = deh_objectid (deh);
if (d_reclen <= 32) {
local_buf = small_buf ;
} else {
local_buf = reiserfs_kmalloc(d_reclen, GFP_NOFS, inode->i_sb) ;
if (!local_buf) {
pathrelse (&path_to_entry);
ret = -ENOMEM ;
goto out; goto out;
}
if (item_moved (&tmp_ih, &path_to_entry)) {
reiserfs_kfree(local_buf, d_reclen, inode->i_sb) ;
goto research;
}
} }
// Note, that we copy name to user space via temporary entry_num = de.de_entry_num;
// buffer (local_buf) because filldir will block if bh = de.de_bh;
// user space buffer is swapped out. At that time item_num = de.de_item_num;
// entry can move to somewhere else ih = de.de_ih;
memcpy (local_buf, d_name, d_reclen); store_ih(&tmp_ih, ih);
if (filldir (dirent, local_buf, d_reclen, d_off, d_ino,
DT_UNKNOWN) < 0) { /* we must have found item, that is item of this directory, */
if (local_buf != small_buf) { RFALSE(COMP_SHORT_KEYS(&(ih->ih_key), &pos_key),
reiserfs_kfree(local_buf, d_reclen, inode->i_sb) ; "vs-9000: found item %h does not match to dir we readdir %K",
} ih, &pos_key);
goto end; RFALSE(item_num > B_NR_ITEMS(bh) - 1,
} "vs-9005 item_num == %d, item amount == %d",
if (local_buf != small_buf) { item_num, B_NR_ITEMS(bh));
reiserfs_kfree(local_buf, d_reclen, inode->i_sb) ;
/* and entry must be not more than number of entries in the item */
RFALSE(I_ENTRY_COUNT(ih) < entry_num,
"vs-9010: entry number is too big %d (%d)",
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 */
struct reiserfs_de_head *deh =
B_I_DEH(bh, ih) + entry_num;
for (; entry_num < I_ENTRY_COUNT(ih);
entry_num++, deh++) {
int d_reclen;
char *d_name;
off_t d_off;
ino_t d_ino;
if (!de_visible(deh))
/* it is hidden entry */
continue;
d_reclen = entry_length(bh, ih, entry_num);
d_name = B_I_DEH_ENTRY_FILE_NAME(bh, ih, deh);
if (!d_name[d_reclen - 1])
d_reclen = strlen(d_name);
if (d_reclen >
REISERFS_MAX_NAME(inode->i_sb->
s_blocksize)) {
/* too big to send back to VFS */
continue;
}
/* Ignore the .reiserfs_priv entry */
if (reiserfs_xattrs(inode->i_sb) &&
!old_format_only(inode->i_sb) &&
filp->f_dentry == inode->i_sb->s_root &&
REISERFS_SB(inode->i_sb)->priv_root &&
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)) {
continue;
}
d_off = deh_offset(deh);
filp->f_pos = d_off;
d_ino = deh_objectid(deh);
if (d_reclen <= 32) {
local_buf = small_buf;
} else {
local_buf =
reiserfs_kmalloc(d_reclen, GFP_NOFS,
inode->i_sb);
if (!local_buf) {
pathrelse(&path_to_entry);
ret = -ENOMEM;
goto out;
}
if (item_moved(&tmp_ih, &path_to_entry)) {
reiserfs_kfree(local_buf,
d_reclen,
inode->i_sb);
goto research;
}
}
// Note, that we copy name to user space via temporary
// buffer (local_buf) because filldir will block if
// user space buffer is swapped out. At that time
// entry can move to somewhere else
memcpy(local_buf, d_name, d_reclen);
if (filldir
(dirent, local_buf, d_reclen, d_off, d_ino,
DT_UNKNOWN) < 0) {
if (local_buf != small_buf) {
reiserfs_kfree(local_buf,
d_reclen,
inode->i_sb);
}
goto end;
}
if (local_buf != small_buf) {
reiserfs_kfree(local_buf, d_reclen,
inode->i_sb);
}
// next entry should be looked for with such offset
next_pos = deh_offset(deh) + 1;
if (item_moved(&tmp_ih, &path_to_entry)) {
goto research;
}
} /* for */
} }
// next entry should be looked for with such offset if (item_num != B_NR_ITEMS(bh) - 1)
next_pos = deh_offset (deh) + 1; // end of directory has been reached
goto end;
if (item_moved (&tmp_ih, &path_to_entry)) { /* item we went through is last item of node. Using right
goto research; delimiting key check is it directory end */
rkey = get_rkey(&path_to_entry, inode->i_sb);
if (!comp_le_keys(rkey, &MIN_KEY)) {
/* set pos_key to key, that is the smallest and greater
that key of the last entry in the item */
set_cpu_key_k_offset(&pos_key, next_pos);
continue;
} }
} /* for */
}
if (item_num != B_NR_ITEMS (bh) - 1) if (COMP_SHORT_KEYS(rkey, &pos_key)) {
// 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 /* directory continues in the right neighboring block */
delimiting key check is it directory end */ set_cpu_key_k_offset(&pos_key,
rkey = get_rkey (&path_to_entry, inode->i_sb); le_key_k_offset(KEY_FORMAT_3_5, rkey));
if (! comp_le_keys (rkey, &MIN_KEY)) {
/* set pos_key to key, that is the smallest and greater
that key of the last entry in the item */
set_cpu_key_k_offset (&pos_key, next_pos);
continue;
}
if ( COMP_SHORT_KEYS (rkey, &pos_key)) { } /* while */
// end of directory has been reached
goto end;
}
/* directory continues in the right neighboring block */ end:
set_cpu_key_k_offset (&pos_key, le_key_k_offset (KEY_FORMAT_3_5, rkey)); filp->f_pos = next_pos;
pathrelse(&path_to_entry);
} /* while */ reiserfs_check_path(&path_to_entry);
out:
reiserfs_write_unlock(inode->i_sb);
end: return ret;
filp->f_pos = next_pos;
pathrelse (&path_to_entry);
reiserfs_check_path(&path_to_entry) ;
out:
reiserfs_write_unlock(inode->i_sb);
return ret;
} }
/* 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]),
mark_de_visible(&(deh[1])); deh_location(&(deh[0])) - ROUND_UP(strlen("..")));
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);
} }

3276
fs/reiserfs/do_balan.c
Просмотреть файл

Разница между файлами не показана из-за своего большого размера Загрузить разницу

2474
fs/reiserfs/file.c
Просмотреть файл

Разница между файлами не показана из-за своего большого размера Загрузить разницу

3867
fs/reiserfs/fix_node.c
Просмотреть файл

Разница между файлами не показана из-за своего большого размера Загрузить разницу

177
fs/reiserfs/hashes.c
Просмотреть файл

@ -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,39 +47,31 @@
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;
u32 pad; u32 pad;
int i; int i;
// 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,55 +124,59 @@ 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++)
a = a + c * pow; pow = pow * 10;
} 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++)
a = a + c * pow; pow = pow * 10;
} 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++)
a = a + c * pow; pow = pow * 10;
} a = a + c * pow;
}
a = a << 7; a = a << 7;
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;
msg++; msg++;
} }
return a; return a;
} }

1654
fs/reiserfs/ibalance.c
Просмотреть файл

Разница между файлами не показана из-за своего большого размера Загрузить разницу

4615
fs/reiserfs/inode.c
Просмотреть файл

Разница между файлами не показана из-за своего большого размера Загрузить разницу

183
fs/reiserfs/ioctl.c
Просмотреть файл

@ -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,68 +19,71 @@ 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
return -ENOTTY; return -ENOTTY;
/* 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)
return -EPERM; && !capable(CAP_FOWNER))
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 |
return -EPERM; REISERFS_APPEND_FL))
&& !capable(CAP_LINUX_IMMUTABLE))
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);
REISERFS_I(inode)->i_attrs = flags;
inode->i_ctime = CURRENT_TIME_SEC;
mark_inode_dirty(inode);
return 0;
} }
sd_attrs_to_i_attrs( flags, inode );
REISERFS_I(inode) -> i_attrs = flags;
inode->i_ctime = CURRENT_TIME_SEC;
mark_inode_dirty(inode);
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;
goto out;
}
/* we unpack by finding the page with the tail, and calling
** reiserfs_prepare_write on that page. This will force a
** reiserfs_get_block to unpack the tail for us.
*/
index = inode->i_size >> PAGE_CACHE_SHIFT;
mapping = inode->i_mapping;
page = grab_cache_page(mapping, index);
retval = -ENOMEM;
if (!page) {
goto out;
}
retval =
mapping->a_ops->prepare_write(NULL, page, write_from, write_from);
if (retval)
goto out_unlock;
/* conversion can change page contents, must flush */
flush_dcache_page(page);
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;
goto out ;
}
/* we unpack by finding the page with the tail, and calling out_unlock:
** reiserfs_prepare_write on that page. This will force a unlock_page(page);
** reiserfs_get_block to unpack the tail for us. page_cache_release(page);
*/
index = inode->i_size >> PAGE_CACHE_SHIFT ;
mapping = inode->i_mapping ;
page = grab_cache_page(mapping, index) ;
retval = -ENOMEM;
if (!page) {
goto out ;
}
retval = mapping->a_ops->prepare_write(NULL, page, write_from, write_from) ;
if (retval)
goto out_unlock ;
/* conversion can change page contents, must flush */ out:
flush_dcache_page(page) ; up(&inode->i_sem);
retval = mapping->a_ops->commit_write(NULL, page, write_from, write_from) ; reiserfs_write_unlock(inode->i_sb);
REISERFS_I(inode)->i_flags |= i_nopack_mask; return retval;
out_unlock:
unlock_page(page) ;
page_cache_release(page) ;
out:
up(&inode->i_sem) ;
reiserfs_write_unlock(inode->i_sb);
return retval;
} }

949
fs/reiserfs/item_ops.c
Просмотреть файл

Разница между файлами не показана из-за своего большого размера Загрузить разницу

6391
fs/reiserfs/journal.c
Просмотреть файл

Разница между файлами не показана из-за своего большого размера Загрузить разницу

1934
fs/reiserfs/lbalance.c
Просмотреть файл

Разница между файлами не показана из-за своего большого размера Загрузить разницу

2484
fs/reiserfs/namei.c
Просмотреть файл

Разница между файлами не показана из-за своего большого размера Загрузить разницу

281
fs/reiserfs/objectid.c
Просмотреть файл

@ -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,161 +46,162 @@ 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;
} }
/* This incrementation allocates the first unused objectid. That /* This incrementation allocates the first unused objectid. That
is to say, the first entry on the objectid map is the first is to say, the first entry on the objectid map is the first
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
eliminating its last objectid from oids), and can collapse the eliminating its last objectid from oids), and can collapse the
first two odd sequences into one sequence. If so, then the net first two odd sequences into one sequence. If so, then the net
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
what we use, though it is possible that binary search would be what we use, though it is possible that binary search would be
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 -
//disk_sb->s_oid_cursize -= 2; 2) * sizeof(__u32));
set_sb_oid_cursize( rs, sb_oid_cursize(rs) - 2 ); //disk_sb->s_oid_cursize -= 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));
} }
return; return;
}
if (objectid_to_release > le32_to_cpu(map[i]) &&
objectid_to_release < le32_to_cpu(map[i + 1])) {
/* size of objectid map is not changed */
if (objectid_to_release + 1 == le32_to_cpu(map[i + 1])) {
//objectid_map[i+1]--;
map[i + 1] =
cpu_to_le32(le32_to_cpu(map[i + 1]) - 1);
return;
}
/* JDM comparing two little-endian values for equality -- safe */
if (sb_oid_cursize(rs) == sb_oid_maxsize(rs)) {
/* objectid map must be expanded, but there is no space */
PROC_INFO_INC(s, leaked_oid);
return;
}
/* expand the objectid map */
memmove(map + i + 3, map + i + 1,
(sb_oid_cursize(rs) - i - 1) * sizeof(__u32));
map[i + 1] = cpu_to_le32(objectid_to_release);
map[i + 2] = cpu_to_le32(objectid_to_release + 1);
set_sb_oid_cursize(rs, sb_oid_cursize(rs) + 2);
return;
}
i += 2;
} }
if (objectid_to_release > le32_to_cpu (map[i]) && reiserfs_warning(s,
objectid_to_release < le32_to_cpu (map[i + 1])) { "vs-15011: reiserfs_release_objectid: tried to free free object id (%lu)",
/* size of objectid map is not changed */ (long unsigned)objectid_to_release);
if (objectid_to_release + 1 == le32_to_cpu (map[i + 1])) {
//objectid_map[i+1]--;
map[i + 1] = cpu_to_le32 (le32_to_cpu (map[i + 1]) - 1);
return;
}
/* JDM comparing two little-endian values for equality -- safe */
if (sb_oid_cursize(rs) == sb_oid_maxsize(rs)) {
/* objectid map must be expanded, but there is no space */
PROC_INFO_INC( s, leaked_oid );
return;
}
/* expand the objectid map*/
memmove (map + i + 3, map + i + 1,
(sb_oid_cursize(rs) - i - 1) * sizeof(__u32));
map[i + 1] = cpu_to_le32 (objectid_to_release);
map[i + 2] = cpu_to_le32 (objectid_to_release + 1);
set_sb_oid_cursize( rs, sb_oid_cursize(rs) + 2 );
return;
}
i += 2;
}
reiserfs_warning (s, "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)
{
struct reiserfs_super_block *disk_sb = SB_DISK_SUPER_BLOCK(s);
int cur_size = sb_oid_cursize(disk_sb);
int new_size = (s->s_blocksize - SB_SIZE) / sizeof(__u32) / 2 * 2;
int old_max = sb_oid_maxsize(disk_sb);
struct reiserfs_super_block_v1 *disk_sb_v1;
__le32 *objectid_map, *new_objectid_map;
int i;
int reiserfs_convert_objectid_map_v1(struct super_block *s) { disk_sb_v1 =
struct reiserfs_super_block *disk_sb = SB_DISK_SUPER_BLOCK (s); (struct reiserfs_super_block_v1 *)(SB_BUFFER_WITH_SB(s)->b_data);
int cur_size = sb_oid_cursize(disk_sb); objectid_map = (__le32 *) (disk_sb_v1 + 1);
int new_size = (s->s_blocksize - SB_SIZE) / sizeof(__u32) / 2 * 2 ; new_objectid_map = (__le32 *) (disk_sb + 1);
int old_max = sb_oid_maxsize(disk_sb);
struct reiserfs_super_block_v1 *disk_sb_v1 ;
__le32 *objectid_map, *new_objectid_map ;
int i ;
disk_sb_v1=(struct reiserfs_super_block_v1 *)(SB_BUFFER_WITH_SB(s)->b_data); if (cur_size > new_size) {
objectid_map = (__le32 *)(disk_sb_v1 + 1) ; /* mark everyone used that was listed as free at the end of the objectid
new_objectid_map = (__le32 *)(disk_sb + 1) ; ** map
*/
objectid_map[new_size - 1] = objectid_map[cur_size - 1];
set_sb_oid_cursize(disk_sb, new_size);
}
/* move the smaller objectid map past the end of the new super */
for (i = new_size - 1; i >= 0; i--) {
objectid_map[i + (old_max - new_size)] = objectid_map[i];
}
if (cur_size > new_size) { /* set the max size so we don't overflow later */
/* mark everyone used that was listed as free at the end of the objectid set_sb_oid_maxsize(disk_sb, new_size);
** map
*/
objectid_map[new_size - 1] = objectid_map[cur_size - 1] ;
set_sb_oid_cursize(disk_sb,new_size) ;
}
/* move the smaller objectid map past the end of the new super */
for (i = new_size - 1 ; i >= 0 ; i--) {
objectid_map[i + (old_max - new_size)] = objectid_map[i] ;
}
/* Zero out label and generate random UUID */
memset(disk_sb->s_label, 0, sizeof(disk_sb->s_label));
generate_random_uuid(disk_sb->s_uuid);
/* set the max size so we don't overflow later */ /* finally, zero out the unused chunk of the new super */
set_sb_oid_maxsize(disk_sb,new_size) ; memset(disk_sb->s_unused, 0, sizeof(disk_sb->s_unused));
return 0;
/* Zero out label and generate random UUID */
memset(disk_sb->s_label, 0, sizeof(disk_sb->s_label)) ;
generate_random_uuid(disk_sb->s_uuid);
/* finally, zero out the unused chunk of the new super */
memset(disk_sb->s_unused, 0, sizeof(disk_sb->s_unused)) ;
return 0 ;
} }

959
fs/reiserfs/prints.c
Просмотреть файл

Разница между файлами не показана из-за своего большого размера Загрузить разницу

681
fs/reiserfs/procfs.c
Просмотреть файл

@ -34,27 +34,26 @@ 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
"off" "off"
#endif #endif
); );
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;
@ -86,80 +85,61 @@ static int show_super(struct seq_file *m, struct super_block *sb)
{ {
struct reiserfs_sb_info *r = REISERFS_SB(sb); struct reiserfs_sb_info *r = REISERFS_SB(sb);
seq_printf(m, "state: \t%s\n" seq_printf(m, "state: \t%s\n"
"mount options: \t%s%s%s%s%s%s%s%s%s%s%s\n" "mount options: \t%s%s%s%s%s%s%s%s%s%s%s\n"
"gen. counter: \t%i\n" "gen. counter: \t%i\n"
"s_kmallocs: \t%i\n" "s_kmallocs: \t%i\n"
"s_disk_reads: \t%i\n" "s_disk_reads: \t%i\n"
"s_disk_writes: \t%i\n" "s_disk_writes: \t%i\n"
"s_fix_nodes: \t%i\n" "s_fix_nodes: \t%i\n"
"s_do_balance: \t%i\n" "s_do_balance: \t%i\n"
"s_unneeded_left_neighbor: \t%i\n" "s_unneeded_left_neighbor: \t%i\n"
"s_good_search_by_key_reada: \t%i\n" "s_good_search_by_key_reada: \t%i\n"
"s_bmaps: \t%i\n" "s_bmaps: \t%i\n"
"s_bmaps_without_search: \t%i\n" "s_bmaps_without_search: \t%i\n"
"s_direct2indirect: \t%i\n" "s_direct2indirect: \t%i\n"
"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_fs_changed: \t%lu\n"
"search_by_key: \t%lu\n" "search_by_key_restarted: \t%lu\n"
"search_by_key_fs_changed: \t%lu\n" "insert_item_restarted: \t%lu\n"
"search_by_key_restarted: \t%lu\n" "paste_into_item_restarted: \t%lu\n"
"cut_from_item_restarted: \t%lu\n"
"insert_item_restarted: \t%lu\n" "delete_solid_item_restarted: \t%lu\n"
"paste_into_item_restarted: \t%lu\n" "delete_item_restarted: \t%lu\n"
"cut_from_item_restarted: \t%lu\n" "leaked_oid: \t%lu\n"
"delete_solid_item_restarted: \t%lu\n" "leaves_removable: \t%lu\n",
"delete_item_restarted: \t%lu\n" SF(s_mount_state) == REISERFS_VALID_FS ?
"REISERFS_VALID_FS" : "REISERFS_ERROR_FS",
"leaked_oid: \t%lu\n" reiserfs_r5_hash(sb) ? "FORCE_R5 " : "",
"leaves_removable: \t%lu\n", reiserfs_rupasov_hash(sb) ? "FORCE_RUPASOV " : "",
reiserfs_tea_hash(sb) ? "FORCE_TEA " : "",
SF( s_mount_state ) == REISERFS_VALID_FS ? reiserfs_hash_detect(sb) ? "DETECT_HASH " : "",
"REISERFS_VALID_FS" : "REISERFS_ERROR_FS", reiserfs_no_border(sb) ? "NO_BORDER " : "BORDER ",
reiserfs_r5_hash( sb ) ? "FORCE_R5 " : "", reiserfs_no_unhashed_relocation(sb) ?
reiserfs_rupasov_hash( sb ) ? "FORCE_RUPASOV " : "", "NO_UNHASHED_RELOCATION " : "",
reiserfs_tea_hash( sb ) ? "FORCE_TEA " : "", reiserfs_hashed_relocation(sb) ? "UNHASHED_RELOCATION " : "",
reiserfs_hash_detect( sb ) ? "DETECT_HASH " : "", reiserfs_test4(sb) ? "TEST4 " : "",
reiserfs_no_border( sb ) ? "NO_BORDER " : "BORDER ", have_large_tails(sb) ? "TAILS " : have_small_tails(sb) ?
reiserfs_no_unhashed_relocation( sb ) ? "NO_UNHASHED_RELOCATION " : "", "SMALL_TAILS " : "NO_TAILS ",
reiserfs_hashed_relocation( sb ) ? "UNHASHED_RELOCATION " : "", replay_only(sb) ? "REPLAY_ONLY " : "",
reiserfs_test4( sb ) ? "TEST4 " : "", convert_reiserfs(sb) ? "CONV " : "",
have_large_tails( sb ) ? "TAILS " : have_small_tails(sb)?"SMALL_TAILS ":"NO_TAILS ", atomic_read(&r->s_generation_counter), SF(s_kmallocs),
replay_only( sb ) ? "REPLAY_ONLY " : "", SF(s_disk_reads), SF(s_disk_writes), SF(s_fix_nodes),
convert_reiserfs( sb ) ? "CONV " : "", SF(s_do_balance), SF(s_unneeded_left_neighbor),
SF(s_good_search_by_key_reada), SF(s_bmaps),
atomic_read( &r -> s_generation_counter ), SF(s_bmaps_without_search), SF(s_direct2indirect),
SF( s_kmallocs ), SF(s_indirect2direct), SFP(max_hash_collisions), SFP(breads),
SF( s_disk_reads ), SFP(bread_miss), SFP(search_by_key),
SF( s_disk_writes ), SFP(search_by_key_fs_changed), SFP(search_by_key_restarted),
SF( s_fix_nodes ), SFP(insert_item_restarted), SFP(paste_into_item_restarted),
SF( s_do_balance ), SFP(cut_from_item_restarted),
SF( s_unneeded_left_neighbor ), SFP(delete_solid_item_restarted), SFP(delete_item_restarted),
SF( s_good_search_by_key_reada ), SFP(leaked_oid), SFP(leaves_removable));
SF( s_bmaps ),
SF( s_bmaps_without_search ),
SF( s_direct2indirect ),
SF( s_indirect2direct ),
SFP( max_hash_collisions ),
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;
} }
@ -169,61 +149,55 @@ static int show_per_level(struct seq_file *m, struct super_block *sb)
struct reiserfs_sb_info *r = REISERFS_SB(sb); struct reiserfs_sb_info *r = REISERFS_SB(sb);
int level; int level;
seq_printf(m, "level\t" seq_printf(m, "level\t"
" balances" " balances"
" [sbk: reads" " [sbk: reads"
" fs_changed" " fs_changed"
" restarted]" " restarted]"
" free space" " free space"
" items" " items"
" can_remove" " can_remove"
" lnum" " lnum"
" rnum" " rnum"
" 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) {
seq_printf(m, "%i\t"
for( level = 0 ; level < MAX_HEIGHT ; ++ level ) { " %12lu"
seq_printf(m, "%i\t" " %12lu"
" %12lu" " %12lu"
" %12lu" " %12lu"
" %12lu" " %12lu"
" %12lu" " %12lu"
" %12lu" " %12lu"
" %12lu" " %12li"
" %12lu" " %12li"
" %12li" " %12li"
" %12li" " %12li"
" %12li" " %12lu"
" %12li" " %12lu"
" %12lu" " %12lu"
" %12lu" " %12lu"
" %12lu" "\n",
" %12lu" level,
"\n", SFPL(balance_at),
level, SFPL(sbk_read_at),
SFPL( balance_at ), SFPL(sbk_fs_changed),
SFPL( sbk_read_at ), SFPL(sbk_restarted),
SFPL( sbk_fs_changed ), SFPL(free_at),
SFPL( sbk_restarted ), SFPL(items_at),
SFPL( free_at ), SFPL(can_node_be_removed),
SFPL( items_at ), SFPL(lnum),
SFPL( can_node_be_removed ), SFPL(rnum),
SFPL( lnum ), SFPL(lbytes),
SFPL( rnum ), SFPL(rbytes),
SFPL( lbytes ), SFPL(get_neighbors),
SFPL( rbytes ), SFPL(get_neighbors_restart),
SFPL( get_neighbors ), SFPL(need_l_neighbor), SFPL(need_r_neighbor)
SFPL( get_neighbors_restart ), );
SFPL( need_l_neighbor ),
SFPL( need_r_neighbor )
);
} }
return 0; return 0;
} }
@ -232,31 +206,30 @@ static int show_bitmap(struct seq_file *m, struct super_block *sb)
{ {
struct reiserfs_sb_info *r = REISERFS_SB(sb); struct reiserfs_sb_info *r = REISERFS_SB(sb);
seq_printf(m, "free_block: %lu\n" seq_printf(m, "free_block: %lu\n"
" scan_bitmap:" " scan_bitmap:"
" wait" " wait"
" bmap" " bmap"
" retry" " retry"
" stolen" " stolen"
" journal_hint" " journal_hint"
"journal_nohint" "journal_nohint"
"\n" "\n"
" %14lu" " %14lu"
" %14lu" " %14lu"
" %14lu" " %14lu"
" %14lu" " %14lu"
" %14lu" " %14lu"
" %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,46 +237,42 @@ 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"
"root_block: \t%i\n" "root_block: \t%i\n"
"blocksize: \t%i\n" "blocksize: \t%i\n"
"oid_maxsize: \t%i\n" "oid_maxsize: \t%i\n"
"oid_cursize: \t%i\n" "oid_cursize: \t%i\n"
"umount_state: \t%i\n" "umount_state: \t%i\n"
"magic: \t%10.10s\n" "magic: \t%10.10s\n"
"fs_state: \t%i\n" "fs_state: \t%i\n"
"hash: \t%s\n" "hash: \t%s\n"
"tree_height: \t%i\n" "tree_height: \t%i\n"
"bmap_nr: \t%i\n" "bmap_nr: \t%i\n"
"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), flags, (flags & reiserfs_attrs_cleared)
DF( s_version ), ? "attrs_cleared" : "", DF(s_reserved_for_journal));
flags,
( flags & reiserfs_attrs_cleared )
? "attrs_cleared" : "",
DF (s_reserved_for_journal));
return 0; return 0;
} }
@ -311,131 +280,122 @@ 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" "jp_journal_size: \t%i\n"
"jp_journal_size: \t%i\n" "jp_journal_trans_max: \t%i\n"
"jp_journal_trans_max: \t%i\n" "jp_journal_magic: \t%i\n"
"jp_journal_magic: \t%i\n" "jp_journal_max_batch: \t%i\n"
"jp_journal_max_batch: \t%i\n" "jp_journal_max_commit_age: \t%i\n"
"jp_journal_max_commit_age: \t%i\n" "jp_journal_max_trans_age: \t%i\n"
"jp_journal_max_trans_age: \t%i\n" /* incore fields */
/* incore fields */ "j_1st_reserved_block: \t%i\n"
"j_1st_reserved_block: \t%i\n" "j_state: \t%li\n"
"j_state: \t%li\n" "j_trans_id: \t%lu\n"
"j_trans_id: \t%lu\n" "j_mount_id: \t%lu\n"
"j_mount_id: \t%lu\n" "j_start: \t%lu\n"
"j_start: \t%lu\n" "j_len: \t%lu\n"
"j_len: \t%lu\n" "j_len_alloc: \t%lu\n"
"j_len_alloc: \t%lu\n" "j_wcount: \t%i\n"
"j_wcount: \t%i\n" "j_bcount: \t%lu\n"
"j_bcount: \t%lu\n" "j_first_unflushed_offset: \t%lu\n"
"j_first_unflushed_offset: \t%lu\n" "j_last_flush_trans_id: \t%lu\n"
"j_last_flush_trans_id: \t%lu\n" "j_trans_start_time: \t%li\n"
"j_trans_start_time: \t%li\n" "j_list_bitmap_index: \t%i\n"
"j_list_bitmap_index: \t%i\n" "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_free: \t%i\n" "\n"
"j_cnode_used: \t%i\n" /* reiserfs_proc_info_data_t.journal fields */
"j_cnode_free: \t%i\n" "in_journal: \t%12lu\n"
"\n" "in_journal_bitmap: \t%12lu\n"
/* reiserfs_proc_info_data_t.journal fields */ "in_journal_reusable: \t%12lu\n"
"in_journal: \t%12lu\n" "lock_journal: \t%12lu\n"
"in_journal_bitmap: \t%12lu\n" "lock_journal_wait: \t%12lu\n"
"in_journal_reusable: \t%12lu\n" "journal_begin: \t%12lu\n"
"lock_journal: \t%12lu\n" "journal_relock_writers: \t%12lu\n"
"lock_journal_wait: \t%12lu\n" "journal_relock_wcount: \t%12lu\n"
"journal_begin: \t%12lu\n" "mark_dirty: \t%12lu\n"
"journal_relock_writers: \t%12lu\n" "mark_dirty_already: \t%12lu\n"
"journal_relock_wcount: \t%12lu\n" "mark_dirty_notjournal: \t%12lu\n"
"mark_dirty: \t%12lu\n" "restore_prepared: \t%12lu\n"
"mark_dirty_already: \t%12lu\n" "prepare: \t%12lu\n"
"mark_dirty_notjournal: \t%12lu\n" "prepare_retry: \t%12lu\n",
"restore_prepared: \t%12lu\n" DJP(jp_journal_1st_block),
"prepare: \t%12lu\n" bdevname(SB_JOURNAL(sb)->j_dev_bd, b),
"prepare_retry: \t%12lu\n", DJP(jp_journal_dev),
DJP(jp_journal_size),
DJP( jp_journal_1st_block ), DJP(jp_journal_trans_max),
bdevname(SB_JOURNAL(sb)->j_dev_bd, b), DJP(jp_journal_magic),
DJP( jp_journal_dev ), DJP(jp_journal_max_batch),
DJP( jp_journal_size ), SB_JOURNAL(sb)->j_max_commit_age,
DJP( jp_journal_trans_max ), DJP(jp_journal_max_trans_age),
DJP( jp_journal_magic ), JF(j_1st_reserved_block),
DJP( jp_journal_max_batch ), JF(j_state),
SB_JOURNAL(sb)->j_max_commit_age, JF(j_trans_id),
DJP( jp_journal_max_trans_age ), JF(j_mount_id),
JF(j_start),
JF( j_1st_reserved_block ), JF(j_len),
JF( j_state ), JF(j_len_alloc),
JF( j_trans_id ), atomic_read(&r->s_journal->j_wcount),
JF( j_mount_id ), JF(j_bcount),
JF( j_start ), JF(j_first_unflushed_offset),
JF( j_len ), JF(j_last_flush_trans_id),
JF( j_len_alloc ), JF(j_trans_start_time),
atomic_read( & r -> s_journal -> j_wcount ), JF(j_list_bitmap_index),
JF( j_bcount ), JF(j_must_wait),
JF( j_first_unflushed_offset ), JF(j_next_full_flush),
JF( j_last_flush_trans_id ), JF(j_next_async_flush),
JF( j_trans_start_time ), JF(j_cnode_used),
JF( j_list_bitmap_index ), JF(j_cnode_free),
JF( j_must_wait ), SFPJ(in_journal),
JF( j_next_full_flush ), SFPJ(in_journal_bitmap),
JF( j_next_async_flush ), SFPJ(in_journal_reusable),
JF( j_cnode_used ), SFPJ(lock_journal),
JF( j_cnode_free ), SFPJ(lock_journal_wait),
SFPJ(journal_being),
SFPJ( in_journal ), SFPJ(journal_relock_writers),
SFPJ( in_journal_bitmap ), SFPJ(journal_relock_wcount),
SFPJ( in_journal_reusable ), SFPJ(mark_dirty),
SFPJ( lock_journal ), SFPJ(mark_dirty_already),
SFPJ( lock_journal_wait ), SFPJ(mark_dirty_notjournal),
SFPJ( journal_being ), SFPJ(restore_prepared), SFPJ(prepare), SFPJ(prepare_retry)
SFPJ( journal_relock_writers ), );
SFPJ( journal_relock_wcount ),
SFPJ( mark_dirty ),
SFPJ( mark_dirty_already ),
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);
} }
@ -512,17 +472,17 @@ static int r_open(struct inode *inode, struct file *file)
} }
static struct file_operations r_file_operations = { static struct file_operations r_file_operations = {
.open = r_open, .open = r_open,
.read = seq_read, .read = seq_read,
.llseek = seq_lseek, .llseek = seq_lseek,
.release = seq_release, .release = seq_release,
}; };
static struct proc_dir_entry *proc_info_root = NULL; 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

177
fs/reiserfs/resize.c
Просмотреть файл

@ -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);
@ -52,18 +52,18 @@ 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++;
@ -72,71 +72,75 @@ int reiserfs_resize (struct super_block * s, unsigned long block_count_new)
/* save old values */ /* save old values */
block_count = SB_BLOCK_COUNT(s); block_count = SB_BLOCK_COUNT(s);
bmap_nr = SB_BMAP_NR(s); bmap_nr = SB_BMAP_NR(s);
/* resizing of reiserfs bitmaps (journal and real), if needed */ /* resizing of reiserfs bitmaps (journal and real), if needed */
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 }
** node pointers from the old journal bitmap structs, and then /* the new journal bitmaps are zero filled, now we copy in the bitmap
** transfer the new data structures into the journal struct. ** node pointers from the old journal bitmap structs, and then
** ** transfer the new data structures into the journal struct.
** using the copy_size var below allows this code to work for **
** both shrinking and expanding the FS. ** using the copy_size var below allows this code to work for
*/ ** both shrinking and expanding the FS.
copy_size = bmap_nr_new < bmap_nr ? bmap_nr_new : bmap_nr ; */
copy_size = copy_size * sizeof(struct reiserfs_list_bitmap_node *) ; copy_size = bmap_nr_new < bmap_nr ? bmap_nr_new : bmap_nr;
for (i = 0 ; i < JOURNAL_NUM_BITMAPS ; i++) { copy_size =
struct reiserfs_bitmap_node **node_tmp ; copy_size * sizeof(struct reiserfs_list_bitmap_node *);
jb = SB_JOURNAL(s)->j_list_bitmap + i ; for (i = 0; i < JOURNAL_NUM_BITMAPS; i++) {
memcpy(jbitmap[i].bitmaps, jb->bitmaps, copy_size) ; struct reiserfs_bitmap_node **node_tmp;
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 =
if (!bitmap) { vmalloc(sizeof(struct reiserfs_bitmap_info) * bmap_nr_new);
/* Journal bitmaps are still supersized, but the memory isn't if (!bitmap) {
* leaked, so I guess it's ok */ /* Journal bitmaps are still supersized, but the memory isn't
printk("reiserfs_resize: unable to allocate memory.\n"); * leaked, so I guess it's ok */
return -ENOMEM; printk("reiserfs_resize: unable to allocate memory.\n");
} return -ENOMEM;
memset (bitmap, 0, sizeof (struct reiserfs_bitmap_info) * SB_BMAP_NR(s)); }
for (i = 0; i < bmap_nr; i++) memset(bitmap, 0,
bitmap[i] = old_bitmap[i]; sizeof(struct reiserfs_bitmap_info) * SB_BMAP_NR(s));
for (i = 0; i < bmap_nr; i++)
bitmap[i] = old_bitmap[i];
/* This doesn't go through the journal, but it doesn't have to. /* This doesn't go through the journal, but it doesn't have to.
* The changes are still atomic: We're synced up when the journal * The changes are still atomic: We're synced up when the journal
* transaction begins, and the new bitmaps don't matter if the * transaction begins, and the new bitmaps don't matter if the
* transaction fails. */ * transaction fails. */
for (i = bmap_nr; i < bmap_nr_new; i++) { for (i = bmap_nr; i < bmap_nr_new; i++) {
bitmap[i].bh = sb_getblk(s, i * s->s_blocksize * 8); bitmap[i].bh = sb_getblk(s, i * s->s_blocksize * 8);
memset(bitmap[i].bh->b_data, 0, sb_blocksize(sb)); memset(bitmap[i].bh->b_data, 0, sb_blocksize(sb));
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
@ -144,33 +148,38 @@ int reiserfs_resize (struct super_block * s, unsigned long block_count_new)
* disk anyway. */ * disk anyway. */
err = journal_begin(&th, s, 10); err = journal_begin(&th, s, 10);
if (err) if (err)
return err; return err;
/* correct last bitmap blocks in old and new disk layout */ /* correct last bitmap blocks in old and new disk layout */
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);
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;

3209
fs/reiserfs/stree.c
Просмотреть файл

Разница между файлами не показана из-за своего большого размера Загрузить разницу

3435
fs/reiserfs/super.c
Просмотреть файл

Разница между файлами не показана из-за своего большого размера Загрузить разницу

445
fs/reiserfs/tail_conversion.c
Просмотреть файл

@ -11,156 +11,159 @@
/* 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);
unfm_ptr = cpu_to_le32 (unbh->b_blocknr);
if ( is_statdata_le_ih (p_le_ih) ) {
/* Insert new indirect item. */
set_ih_free_space (&ind_ih, 0); /* delete at nearest future */
put_ih_item_len( &ind_ih, UNFM_P_SIZE );
PATH_LAST_POSITION (path)++;
n_retval = reiserfs_insert_item (th, path, &end_key, &ind_ih, inode,
(char *)&unfm_ptr);
} else {
/* Paste into last indirect item of an object. */
n_retval = reiserfs_paste_into_item(th, path, &end_key, inode,
(char *)&unfm_ptr, UNFM_P_SIZE);
}
if ( n_retval ) {
return n_retval;
}
// note: from here there are two keys which have matching first
// three key components. They only differ by the fourth one.
/* 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);
/* Move bytes from the direct items to the new unformatted node
and delete them. */
while (1) {
int tail_size;
/* end_key.k_offset is set so, that we will always have found
last item of the file */
if ( search_for_position_by_key (sb, &end_key, path) == POSITION_FOUND )
reiserfs_panic (sb, "PAP-14050: direct2indirect: "
"direct item (%K) not found", &end_key);
p_le_ih = PATH_PITEM_HEAD (path);
RFALSE( !is_direct_le_ih (p_le_ih),
"vs-14055: direct item expected(%K), found %h",
&end_key, p_le_ih);
tail_size = (le_ih_k_offset (p_le_ih) & (n_blk_size - 1))
+ ih_item_len(p_le_ih) - 1;
/* we only send the unbh pointer if the buffer is not up to date.
** this avoids overwriting good data from writepage() with old data
** from the disk or buffer cache
** Special case: unbh->b_page will be NULL if we are coming through
** DIRECT_IO handler here.
*/
if (!unbh->b_page || buffer_uptodate(unbh) || PageUptodate(unbh->b_page)) {
up_to_date_bh = NULL ;
} else {
up_to_date_bh = unbh ;
} }
n_retval = reiserfs_delete_item (th, path, &end_key, inode,
up_to_date_bh) ;
total_tail += n_retval ; p_le_ih = PATH_PITEM_HEAD(path);
if (tail_size == n_retval)
// done: file does not have direct items anymore
break;
} unfm_ptr = cpu_to_le32(unbh->b_blocknr);
/* if we've copied bytes from disk into the page, we need to zero
** out the unused part of the block (it was not up to date before)
*/
if (up_to_date_bh) {
unsigned pgoff = (tail_offset + total_tail - 1) & (PAGE_CACHE_SIZE - 1);
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);
}
REISERFS_I(inode)->i_first_direct_byte = U32_MAX; if (is_statdata_le_ih(p_le_ih)) {
/* Insert new indirect item. */
set_ih_free_space(&ind_ih, 0); /* delete at nearest future */
put_ih_item_len(&ind_ih, UNFM_P_SIZE);
PATH_LAST_POSITION(path)++;
n_retval =
reiserfs_insert_item(th, path, &end_key, &ind_ih, inode,
(char *)&unfm_ptr);
} else {
/* Paste into last indirect item of an object. */
n_retval = reiserfs_paste_into_item(th, path, &end_key, inode,
(char *)&unfm_ptr,
UNFM_P_SIZE);
}
if (n_retval) {
return n_retval;
}
// note: from here there are two keys which have matching first
// three key components. They only differ by the fourth one.
return 0; /* 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);
/* Move bytes from the direct items to the new unformatted node
and delete them. */
while (1) {
int tail_size;
/* end_key.k_offset is set so, that we will always have found
last item of the file */
if (search_for_position_by_key(sb, &end_key, path) ==
POSITION_FOUND)
reiserfs_panic(sb,
"PAP-14050: direct2indirect: "
"direct item (%K) not found", &end_key);
p_le_ih = PATH_PITEM_HEAD(path);
RFALSE(!is_direct_le_ih(p_le_ih),
"vs-14055: direct item expected(%K), found %h",
&end_key, p_le_ih);
tail_size = (le_ih_k_offset(p_le_ih) & (n_blk_size - 1))
+ ih_item_len(p_le_ih) - 1;
/* we only send the unbh pointer if the buffer is not up to date.
** this avoids overwriting good data from writepage() with old data
** from the disk or buffer cache
** Special case: unbh->b_page will be NULL if we are coming through
** DIRECT_IO handler here.
*/
if (!unbh->b_page || buffer_uptodate(unbh)
|| PageUptodate(unbh->b_page)) {
up_to_date_bh = NULL;
} else {
up_to_date_bh = unbh;
}
n_retval = reiserfs_delete_item(th, path, &end_key, inode,
up_to_date_bh);
total_tail += n_retval;
if (tail_size == n_retval)
// done: file does not have direct items anymore
break;
}
/* if we've copied bytes from disk into the page, we need to zero
** out the unused part of the block (it was not up to date before)
*/
if (up_to_date_bh) {
unsigned pgoff =
(tail_offset + total_tail - 1) & (PAGE_CACHE_SIZE - 1);
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);
}
REISERFS_I(inode)->i_first_direct_byte = U32_MAX;
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) ; {
if (buffer_journaled(bh) || buffer_journal_dirty(bh)) { lock_buffer(bh);
BUG() ; if (buffer_journaled(bh) || buffer_journal_dirty(bh)) {
} BUG();
clear_buffer_dirty(bh) ; }
/* Remove the buffer from whatever list it belongs to. We are mostly clear_buffer_dirty(bh);
interested in removing it from per-sb j_dirty_buffers list, to avoid /* Remove the buffer from whatever list it belongs to. We are mostly
BUG() on attempt to write not mapped buffer */ interested in removing it from per-sb j_dirty_buffers list, to avoid
if ( (!list_empty(&bh->b_assoc_buffers) || bh->b_private) && bh->b_page) { BUG() on attempt to write not mapped buffer */
struct inode *inode = bh->b_page->mapping->host; if ((!list_empty(&bh->b_assoc_buffers) || bh->b_private) && bh->b_page) {
struct reiserfs_journal *j = SB_JOURNAL(inode->i_sb); struct inode *inode = bh->b_page->mapping->host;
spin_lock(&j->j_dirty_buffers_lock); struct reiserfs_journal *j = SB_JOURNAL(inode->i_sb);
list_del_init(&bh->b_assoc_buffers); spin_lock(&j->j_dirty_buffers_lock);
reiserfs_free_jh(bh); list_del_init(&bh->b_assoc_buffers);
spin_unlock(&j->j_dirty_buffers_lock); reiserfs_free_jh(bh);
} spin_unlock(&j->j_dirty_buffers_lock);
clear_buffer_mapped(bh) ; }
clear_buffer_req(bh) ; clear_buffer_mapped(bh);
clear_buffer_new(bh); clear_buffer_req(bh);
bh->b_bdev = NULL; clear_buffer_new(bh);
unlock_buffer(bh) ; bh->b_bdev = NULL;
unlock_buffer(bh);
} }
/* this first locks inode (neither reads nor sync are permitted), /* this first locks inode (neither reads nor sync are permitted),
@ -169,108 +172,108 @@ 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, loff_t n_new_file_size, /* New file size. */
struct path * p_s_path, /* path to the indirect item. */ char *p_c_mode)
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. */
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));
tail_len = (n_new_file_size & (n_block_size - 1));
if (get_inode_sd_version (p_s_inode) == STAT_DATA_V2)
round_tail_len = ROUND_UP (tail_len);
else
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;
pos1 = pos;
// we are protected by i_sem. The tail can not disapper, not
// append can be done either
// we are in truncate or packing tail in file_release
tail = (char *)kmap(page) ; /* this can schedule */
if (path_changed (&s_ih, p_s_path)) {
/* re-search indirect item */
if ( search_for_position_by_key (p_s_sb, p_s_item_key, p_s_path) == POSITION_NOT_FOUND )
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));
tail_len = (n_new_file_size & (n_block_size - 1));
if (get_inode_sd_version(p_s_inode) == STAT_DATA_V2)
round_tail_len = ROUND_UP(tail_len);
else
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;
pos1 = pos;
// we are protected by i_sem. The tail can not disapper, not
// append can be done either
// we are in truncate or packing tail in file_release
tail = (char *)kmap(page); /* this can schedule */
if (path_changed(&s_ih, p_s_path)) {
/* re-search indirect item */
if (search_for_position_by_key(p_s_sb, p_s_item_key, p_s_path)
== POSITION_NOT_FOUND)
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));
#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 -
if (pos != pos1) 1) * p_s_sb->s_blocksize;
reiserfs_panic (p_s_sb, "vs-5530: indirect2direct: " if (pos != pos1)
"tail position changed while we were reading it"); reiserfs_panic(p_s_sb, "vs-5530: indirect2direct: "
"tail position changed while we were reading it");
#endif #endif
} }
/* Set direct item header to insert. */
make_le_item_head(&s_ih, NULL, get_inode_item_key_version(p_s_inode),
pos1 + 1, TYPE_DIRECT, round_tail_len,
0xffff /*ih_free_space */ );
/* Set direct item header to insert. */ /* we want a pointer to the first byte of the tail in the page.
make_le_item_head (&s_ih, NULL, get_inode_item_key_version (p_s_inode), pos1 + 1, ** the page was locked and this part of the page was up to date when
TYPE_DIRECT, round_tail_len, 0xffff/*ih_free_space*/); ** indirect2direct was called, so we know the bytes are still valid
*/
tail = tail + (pos & (PAGE_CACHE_SIZE - 1));
/* we want a pointer to the first byte of the tail in the page. PATH_LAST_POSITION(p_s_path)++;
** 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
*/
tail = tail + (pos & (PAGE_CACHE_SIZE - 1)) ;
PATH_LAST_POSITION(p_s_path)++; key = *p_s_item_key;
set_cpu_key_k_type(&key, TYPE_DIRECT);
key.key_length = 4;
/* Insert tail as new direct item in the tree */
if (reiserfs_insert_item(th, p_s_path, &key, &s_ih, p_s_inode,
tail ? tail : NULL) < 0) {
/* No disk memory. So we can not convert last unformatted node
to the direct item. In this case we used to adjust
indirect items's ih_free_space. Now ih_free_space is not
used, it would be ideal to write zeros to corresponding
unformatted node. For now i_size is considered as guard for
going out of file size */
kunmap(page);
return n_block_size - round_tail_len;
}
kunmap(page);
/* make sure to get the i_blocks changes from reiserfs_insert_item */
reiserfs_update_sd(th, p_s_inode);
// note: we have now the same as in above direct2indirect
// conversion: there are two keys which have matching first three
// key components. They only differ by the fouhth one.
/* We have inserted new direct item and must remove last
unformatted node. */
*p_c_mode = M_CUT;
/* we store position of first direct item in the in-core inode */
//mark_file_with_tail (p_s_inode, pos1 + 1);
REISERFS_I(p_s_inode)->i_first_direct_byte = pos1 + 1;
key = *p_s_item_key;
set_cpu_key_k_type (&key, TYPE_DIRECT);
key.key_length = 4;
/* Insert tail as new direct item in the tree */
if ( reiserfs_insert_item(th, p_s_path, &key, &s_ih, p_s_inode,
tail ? tail : NULL) < 0 ) {
/* No disk memory. So we can not convert last unformatted node
to the direct item. In this case we used to adjust
indirect items's ih_free_space. Now ih_free_space is not
used, it would be ideal to write zeros to corresponding
unformatted node. For now i_size is considered as guard for
going out of file size */
kunmap(page) ;
return n_block_size - round_tail_len; return n_block_size - round_tail_len;
}
kunmap(page) ;
/* make sure to get the i_blocks changes from reiserfs_insert_item */
reiserfs_update_sd(th, p_s_inode);
// note: we have now the same as in above direct2indirect
// conversion: there are two keys which have matching first three
// key components. They only differ by the fouhth one.
/* We have inserted new direct item and must remove last
unformatted node. */
*p_c_mode = M_CUT;
/* we store position of first direct item in the in-core inode */
//mark_file_with_tail (p_s_inode, pos1 + 1);
REISERFS_I(p_s_inode)->i_first_direct_byte = pos1 + 1;
return n_block_size - round_tail_len;
} }

1971
fs/reiserfs/xattr.c
Просмотреть файл

Разница между файлами не показана из-за своего большого размера Загрузить разницу

613
fs/reiserfs/xattr_acl.c
Просмотреть файл

@ -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;
@ -76,8 +74,8 @@ posix_acl_from_disk(const void *value, size_t size)
if (!value) if (!value)
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,41 +87,39 @@ 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:
case ACL_OTHER: case ACL_OTHER:
value = (char *)value + value = (char *)value +
sizeof(reiserfs_acl_entry_short); sizeof(reiserfs_acl_entry_short);
acl->a_entries[n].e_id = ACL_UNDEFINED_ID; acl->a_entries[n].e_id = ACL_UNDEFINED_ID;
break; break;
case ACL_USER: case ACL_USER:
case ACL_GROUP: case ACL_GROUP:
value = (char *)value + sizeof(reiserfs_acl_entry); value = (char *)value + sizeof(reiserfs_acl_entry);
if ((char *)value > end) if ((char *)value > end)
goto fail;
acl->a_entries[n].e_id =
le32_to_cpu(entry->e_id);
break;
default:
goto fail; goto fail;
acl->a_entries[n].e_id = le32_to_cpu(entry->e_id);
break;
default:
goto fail;
} }
} }
if (value != end) if (value != end)
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,46 +127,46 @@ 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;
case ACL_USER_OBJ: case ACL_USER_OBJ:
case ACL_GROUP_OBJ: case ACL_GROUP_OBJ:
case ACL_MASK: case ACL_MASK:
case ACL_OTHER: case ACL_OTHER:
e += sizeof(reiserfs_acl_entry_short); e += sizeof(reiserfs_acl_entry_short);
break; break;
default: default:
goto fail; goto fail;
} }
} }
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,59 +177,58 @@ 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;
size_t size; size_t size;
int retval; int retval;
struct reiserfs_inode_info *reiserfs_i = REISERFS_I(inode); struct reiserfs_inode_info *reiserfs_i = REISERFS_I(inode);
switch (type) { switch (type) {
case ACL_TYPE_ACCESS: case ACL_TYPE_ACCESS:
name = POSIX_ACL_XATTR_ACCESS; name = POSIX_ACL_XATTR_ACCESS;
p_acl = &reiserfs_i->i_acl_access; p_acl = &reiserfs_i->i_acl_access;
break; break;
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;
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);
return acl; return acl;
@ -248,72 +243,72 @@ reiserfs_get_acl(struct inode *inode, int type)
static int static int
reiserfs_set_acl(struct inode *inode, int type, struct posix_acl *acl) reiserfs_set_acl(struct inode *inode, int type, struct posix_acl *acl)
{ {
char *name; char *name;
void *value = NULL; void *value = NULL;
struct posix_acl **p_acl; struct posix_acl **p_acl;
size_t size; size_t size;
int error; int error;
struct reiserfs_inode_info *reiserfs_i = REISERFS_I(inode); struct reiserfs_inode_info *reiserfs_i = REISERFS_I(inode);
if (S_ISLNK(inode->i_mode)) if (S_ISLNK(inode->i_mode))
return -EOPNOTSUPP; return -EOPNOTSUPP;
switch (type) { switch (type) {
case ACL_TYPE_ACCESS: case ACL_TYPE_ACCESS:
name = POSIX_ACL_XATTR_ACCESS; name = POSIX_ACL_XATTR_ACCESS;
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 {
inode->i_mode = mode; inode->i_mode = mode;
if (error == 0) if (error == 0)
acl = NULL; acl = NULL;
} }
} }
break; break;
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:
return -EINVAL; return -EINVAL;
} }
if (acl) { if (acl) {
value = posix_acl_to_disk(acl, &size); value = posix_acl_to_disk(acl, &size);
if (IS_ERR(value)) if (IS_ERR(value))
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;
} }
} }
if (value) if (value)
kfree(value); kfree(value);
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,192 +316,190 @@ 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) {
struct posix_acl *acl_copy; struct posix_acl *acl_copy;
mode_t mode = inode->i_mode; mode_t mode = inode->i_mode;
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);
if (need_acl >= 0) {
if (mode != inode->i_mode) {
inode->i_mode = mode;
}
need_acl = posix_acl_create_masq (acl_copy, &mode); /* If we need an ACL.. */
if (need_acl >= 0) { if (need_acl > 0) {
if (mode != inode->i_mode) { err =
inode->i_mode = mode; reiserfs_set_acl(inode, ACL_TYPE_ACCESS,
} acl_copy);
if (err)
goto cleanup_copy;
}
}
cleanup_copy:
posix_acl_release(acl_copy);
cleanup:
posix_acl_release(acl);
} else {
apply_umask:
/* no ACL, apply umask */
inode->i_mode &= ~current->fs->umask;
}
/* If we need an ACL.. */ return err;
if (need_acl > 0) {
err = reiserfs_set_acl (inode, ACL_TYPE_ACCESS, acl_copy);
if (err)
goto cleanup_copy;
}
}
cleanup_copy:
posix_acl_release (acl_copy);
cleanup:
posix_acl_release (acl);
} else {
apply_umask:
/* no ACL, apply umask */
inode->i_mode &= ~current->fs->umask;
}
return err;
} }
/* 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;
}
int
reiserfs_acl_chmod (struct inode *inode)
{
struct posix_acl *acl, *clone;
int error;
if (S_ISLNK(inode->i_mode))
return -EOPNOTSUPP;
if (get_inode_sd_version (inode) == STAT_DATA_V1 ||
!reiserfs_posixacl(inode->i_sb))
{
return 0;
} }
reiserfs_read_lock_xattrs (inode->i_sb); return ret;
acl = reiserfs_get_acl(inode, ACL_TYPE_ACCESS); }
reiserfs_read_unlock_xattrs (inode->i_sb);
if (!acl) int reiserfs_acl_chmod(struct inode *inode)
return 0; {
if (IS_ERR(acl)) struct posix_acl *acl, *clone;
return PTR_ERR(acl); int error;
clone = posix_acl_clone(acl, GFP_NOFS);
posix_acl_release(acl); if (S_ISLNK(inode->i_mode))
if (!clone) return -EOPNOTSUPP;
return -ENOMEM;
error = posix_acl_chmod_masq(clone, inode->i_mode); if (get_inode_sd_version(inode) == STAT_DATA_V1 ||
if (!error) { !reiserfs_posixacl(inode->i_sb)) {
int lock = !has_xattr_dir (inode); return 0;
reiserfs_write_lock_xattr_i (inode); }
if (lock)
reiserfs_write_lock_xattrs (inode->i_sb); reiserfs_read_lock_xattrs(inode->i_sb);
else acl = reiserfs_get_acl(inode, ACL_TYPE_ACCESS);
reiserfs_read_lock_xattrs (inode->i_sb); reiserfs_read_unlock_xattrs(inode->i_sb);
error = reiserfs_set_acl(inode, ACL_TYPE_ACCESS, clone); if (!acl)
if (lock) return 0;
reiserfs_write_unlock_xattrs (inode->i_sb); if (IS_ERR(acl))
else return PTR_ERR(acl);
reiserfs_read_unlock_xattrs (inode->i_sb); clone = posix_acl_clone(acl, GFP_NOFS);
reiserfs_write_unlock_xattr_i (inode); posix_acl_release(acl);
} if (!clone)
posix_acl_release(clone); return -ENOMEM;
return error; error = posix_acl_chmod_masq(clone, inode->i_mode);
if (!error) {
int lock = !has_xattr_dir(inode);
reiserfs_write_lock_xattr_i(inode);
if (lock)
reiserfs_write_lock_xattrs(inode->i_sb);
else
reiserfs_read_lock_xattrs(inode->i_sb);
error = reiserfs_set_acl(inode, ACL_TYPE_ACCESS, clone);
if (lock)
reiserfs_write_unlock_xattrs(inode->i_sb);
else
reiserfs_read_unlock_xattrs(inode->i_sb);
reiserfs_write_unlock_xattr_i(inode);
}
posix_acl_release(clone);
return error;
} }
static int 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);
} }
static int 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;
} }
struct reiserfs_xattr_handler posix_acl_access_handler = { struct reiserfs_xattr_handler posix_acl_access_handler = {
@ -518,48 +511,48 @@ 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);
} }
static int 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;
} }
struct reiserfs_xattr_handler posix_acl_default_handler = { struct reiserfs_xattr_handler posix_acl_default_handler = {

66
fs/reiserfs/xattr_security.c
Просмотреть файл

@ -9,57 +9,55 @@
#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;
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))
return -EINVAL; return -EINVAL;
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 security_del(struct inode *inode, const char *name)
{
if (strlen(name) < sizeof(XATTR_SECURITY_PREFIX))
return -EINVAL;
if (is_reiserfs_priv_object(inode))
return -EPERM;
return 0;
} }
static int static int
security_del (struct inode *inode, const char *name) security_list(struct inode *inode, const char *name, int namelen, char *out)
{ {
if (strlen(name) < sizeof(XATTR_SECURITY_PREFIX)) int len = namelen;
return -EINVAL;
if (is_reiserfs_priv_object(inode)) if (is_reiserfs_priv_object(inode))
return -EPERM; return 0;
return 0; if (out)
memcpy(out, name, len);
return len;
} }
static int
security_list (struct inode *inode, const char *name, int namelen, char *out)
{
int len = namelen;
if (is_reiserfs_priv_object(inode))
return 0;
if (out)
memcpy (out, name, 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,

84
fs/reiserfs/xattr_trusted.c
Просмотреть файл

@ -9,69 +9,67 @@
#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 trusted_del(struct inode *inode, const char *name)
{
if (strlen(name) < sizeof(XATTR_TRUSTED_PREFIX))
return -EINVAL;
if (!reiserfs_xattrs(inode->i_sb))
return -EOPNOTSUPP;
if (!(capable(CAP_SYS_ADMIN) || is_reiserfs_priv_object(inode)))
return -EPERM;
return 0;
} }
static int static int
trusted_del (struct inode *inode, const char *name) trusted_list(struct inode *inode, const char *name, int namelen, char *out)
{ {
if (strlen(name) < sizeof(XATTR_TRUSTED_PREFIX)) int len = namelen;
return -EINVAL;
if (!reiserfs_xattrs (inode->i_sb)) if (!reiserfs_xattrs(inode->i_sb))
return -EOPNOTSUPP; return 0;
if (!(capable(CAP_SYS_ADMIN) || is_reiserfs_priv_object(inode))) if (!(capable(CAP_SYS_ADMIN) || is_reiserfs_priv_object(inode)))
return -EPERM; return 0;
return 0; if (out)
memcpy(out, name, len);
return len;
} }
static int
trusted_list (struct inode *inode, const char *name, int namelen, char *out)
{
int len = namelen;
if (!reiserfs_xattrs (inode->i_sb))
return 0;
if (!(capable(CAP_SYS_ADMIN) || is_reiserfs_priv_object(inode)))
return 0;
if (out)
memcpy (out, name, 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,

105
fs/reiserfs/xattr_user.c
Просмотреть файл

@ -13,81 +13,80 @@
#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;
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)
{ {
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;
return reiserfs_xattr_set (inode, name, buffer, size, flags); return reiserfs_xattr_set(inode, name, buffer, size, flags);
}
static int user_del(struct inode *inode, const char *name)
{
int error;
if (strlen(name) < sizeof(XATTR_USER_PREFIX))
return -EINVAL;
if (!reiserfs_xattrs_user(inode->i_sb))
return -EOPNOTSUPP;
if (!S_ISREG(inode->i_mode) &&
(!S_ISDIR(inode->i_mode) || inode->i_mode & S_ISVTX))
return -EPERM;
error = reiserfs_permission_locked(inode, MAY_WRITE, NULL);
if (error)
return error;
return 0;
} }
static int static int
user_del (struct inode *inode, const char *name) user_list(struct inode *inode, const char *name, int namelen, char *out)
{ {
int error; int len = namelen;
if (!reiserfs_xattrs_user(inode->i_sb))
return 0;
if (strlen(name) < sizeof(XATTR_USER_PREFIX)) if (out)
return -EINVAL; memcpy(out, name, len);
if (!reiserfs_xattrs_user (inode->i_sb)) return len;
return -EOPNOTSUPP;
if (!S_ISREG (inode->i_mode) &&
(!S_ISDIR (inode->i_mode) || inode->i_mode & S_ISVTX))
return -EPERM;
error = reiserfs_permission_locked (inode, MAY_WRITE, NULL);
if (error)
return error;
return 0;
}
static int
user_list (struct inode *inode, const char *name, int namelen, char *out)
{
int len = namelen;
if (!reiserfs_xattrs_user (inode->i_sb))
return 0;
if (out)
memcpy (out, name, len);
return len;
} }
struct reiserfs_xattr_handler user_handler = { struct reiserfs_xattr_handler user_handler = {

64
include/linux/reiserfs_acl.h
Просмотреть файл

@ -4,29 +4,29 @@
#define REISERFS_ACL_VERSION 0x0001 #define REISERFS_ACL_VERSION 0x0001
typedef struct { typedef struct {
__le16 e_tag; __le16 e_tag;
__le16 e_perm; __le16 e_perm;
__le32 e_id; __le32 e_id;
} reiserfs_acl_entry; } reiserfs_acl_entry;
typedef struct { typedef struct {
__le16 e_tag; __le16 e_tag;
__le16 e_perm; __le16 e_perm;
} reiserfs_acl_entry_short; } reiserfs_acl_entry_short;
typedef struct { typedef struct {
__le32 a_version; __le32 a_version;
} reiserfs_acl_header; } reiserfs_acl_header;
static inline size_t reiserfs_acl_size(int count) static inline size_t reiserfs_acl_size(int count)
{ {
if (count <= 4) { if (count <= 4) {
return sizeof(reiserfs_acl_header) + return sizeof(reiserfs_acl_header) +
count * sizeof(reiserfs_acl_entry_short); count * sizeof(reiserfs_acl_entry_short);
} else { } else {
return sizeof(reiserfs_acl_header) + return sizeof(reiserfs_acl_header) +
4 * sizeof(reiserfs_acl_entry_short) + 4 * sizeof(reiserfs_acl_entry_short) +
(count - 4) * sizeof(reiserfs_acl_entry); (count - 4) * sizeof(reiserfs_acl_entry);
} }
} }
@ -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,28 +61,26 @@ 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; return 0;
}
static inline int reiserfs_xattr_posix_acl_exit(void)
{
return 0;
}
static inline int reiserfs_acl_chmod(struct inode *inode)
{
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; 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;
} }
#endif #endif

1521
include/linux/reiserfs_fs.h
Просмотреть файл

Разница между файлами не показана из-за своего большого размера Загрузить разницу

59
include/linux/reiserfs_fs_i.h
Просмотреть файл

@ -10,54 +10,53 @@ typedef enum {
/** this says what format of key do all items (but stat data) of /** this says what format of key do all items (but stat data) of
an object have. If this is set, that format is 3.6 otherwise an object have. If this is set, that format is 3.6 otherwise
- 3.5 */ - 3.5 */
i_item_key_version_mask = 0x0001, i_item_key_version_mask = 0x0001,
/** If this is unset, object has 3.5 stat data, otherwise, it has /** If this is unset, object has 3.5 stat data, otherwise, it has
3.6 stat data with 64bit size, 32bit nlink etc. */ 3.6 stat data with 64bit size, 32bit nlink etc. */
i_stat_data_version_mask = 0x0002, i_stat_data_version_mask = 0x0002,
/** file might need tail packing on close */ /** file might need tail packing on close */
i_pack_on_close_mask = 0x0004, i_pack_on_close_mask = 0x0004,
/** don't pack tail of file */ /** don't pack tail of file */
i_nopack_mask = 0x0008, i_nopack_mask = 0x0008,
/** If those is set, "safe link" was created for this file during /** If those is set, "safe link" was created for this file during
truncate or unlink. Safe link is used to avoid leakage of disk truncate or unlink. Safe link is used to avoid leakage of disk
space on crash with some files open, but unlinked. */ space on crash with some files open, but unlinked. */
i_link_saved_unlink_mask = 0x0010, i_link_saved_unlink_mask = 0x0010,
i_link_saved_truncate_mask = 0x0020, i_link_saved_truncate_mask = 0x0020,
i_has_xattr_dir = 0x0040, i_has_xattr_dir = 0x0040,
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;
__u32 i_first_direct_byte; // offset of first byte stored in direct item. __u32 i_first_direct_byte; // offset of first byte stored in direct item.
/* copy of persistent inode flags read from sd_attrs. */ /* copy of persistent inode flags read from sd_attrs. */
__u32 i_attrs; __u32 i_attrs;
int i_prealloc_block; /* first unused block of a sequence of unused blocks */ int i_prealloc_block; /* first unused block of a sequence of unused blocks */
int i_prealloc_count; /* length of that sequence */ int i_prealloc_count; /* length of that sequence */
struct list_head i_prealloc_list; /* per-transaction list of inodes which struct list_head i_prealloc_list; /* per-transaction list of inodes which
* have preallocated blocks */ * have preallocated blocks */
unsigned new_packing_locality:1; /* new_packig_locality is created; new blocks unsigned new_packing_locality:1; /* new_packig_locality is created; new blocks
* for the contents of this directory should be * for the contents of this directory should be
* displaced */ * displaced */
/* 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;
struct posix_acl *i_acl_default; struct posix_acl *i_acl_default;
struct rw_semaphore xattr_sem; struct rw_semaphore xattr_sem;
struct inode vfs_inode; struct inode vfs_inode;
}; };
#endif #endif

550
include/linux/reiserfs_fs_sb.h
Просмотреть файл

@ -10,7 +10,7 @@
#endif #endif
typedef enum { typedef enum {
reiserfs_attrs_cleared = 0x00000001, reiserfs_attrs_cleared = 0x00000001,
} reiserfs_super_block_flags; } reiserfs_super_block_flags;
/* struct reiserfs_super_block accessors/mutators /* struct reiserfs_super_block accessors/mutators
@ -103,10 +103,10 @@ typedef enum {
/* don't mess with these for a while */ /* don't mess with these for a while */
/* we have a node size define somewhere in reiserfs_fs.h. -Hans */ /* we have a node size define somewhere in reiserfs_fs.h. -Hans */
#define JOURNAL_BLOCK_SIZE 4096 /* BUG gotta get rid of this */ #define JOURNAL_BLOCK_SIZE 4096 /* BUG gotta get rid of this */
#define JOURNAL_MAX_CNODE 1500 /* max cnodes to allocate. */ #define JOURNAL_MAX_CNODE 1500 /* max cnodes to allocate. */
#define JOURNAL_HASH_SIZE 8192 #define JOURNAL_HASH_SIZE 8192
#define JOURNAL_NUM_BITMAPS 5 /* number of copies of the bitmaps to have floating. Must be >= 2 */ #define JOURNAL_NUM_BITMAPS 5 /* number of copies of the bitmaps to have floating. Must be >= 2 */
/* One of these for every block in every transaction /* One of these for every block in every transaction
** Each one is in two hash tables. First, a hash of the current transaction, and after journal_end, a ** Each one is in two hash tables. First, a hash of the current transaction, and after journal_end, a
@ -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,273 +146,269 @@ 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;
/* time ordered list of all transactions we haven't tried to flush yet */ /* time ordered list of all transactions we haven't tried to flush yet */
struct list_head j_working_list; struct list_head j_working_list;
/* list of tail conversion targets in need of flush before commit */ /* list of tail conversion targets in need of flush before commit */
struct list_head j_tail_bh_list; struct list_head j_tail_bh_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 */
/* debugging to make sure things are flushed in order */ /* debugging to make sure things are flushed in order */
int j_last_flush_id; int j_last_flush_id;
/* 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;
/* when flushing ordered buffers, throttle new ordered writers */ /* when flushing ordered buffers, throttle new ordered writers */
struct work_struct j_work; struct work_struct j_work;
atomic_t j_async_throttle; atomic_t j_async_throttle;
}; };
enum journal_state_bits { enum journal_state_bits {
J_WRITERS_BLOCKED = 1, /* set when new writers not allowed */ J_WRITERS_BLOCKED = 1, /* set when new writers not allowed */
J_WRITERS_QUEUED, /* set when log is full due to too many writers */ J_WRITERS_QUEUED, /* set when log is full due to too many writers */
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 {
// FIXME: Won't work with block sizes > 8K
struct reiserfs_bitmap_info __u16 first_zero_hint;
{ __u16 free_count;
// FIXME: Won't work with block sizes > 8K struct buffer_head *bh; /* the actual bitmap */
__u16 first_zero_hint;
__u16 free_count;
struct buffer_head *bh; /* the actual bitmap */
}; };
struct proc_dir_entry; 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;
stat_cnt_t breads; stat_cnt_t breads;
stat_cnt_t bread_miss; stat_cnt_t bread_miss;
stat_cnt_t search_by_key; stat_cnt_t search_by_key;
stat_cnt_t search_by_key_fs_changed; stat_cnt_t search_by_key_fs_changed;
stat_cnt_t search_by_key_restarted; stat_cnt_t search_by_key_restarted;
stat_cnt_t insert_item_restarted; stat_cnt_t insert_item_restarted;
stat_cnt_t paste_into_item_restarted; stat_cnt_t paste_into_item_restarted;
stat_cnt_t cut_from_item_restarted; stat_cnt_t cut_from_item_restarted;
stat_cnt_t delete_solid_item_restarted; stat_cnt_t delete_solid_item_restarted;
stat_cnt_t delete_item_restarted; stat_cnt_t delete_item_restarted;
stat_cnt_t leaked_oid; stat_cnt_t leaked_oid;
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 {
stat_cnt_t call; stat_cnt_t call;
stat_cnt_t wait; stat_cnt_t wait;
stat_cnt_t bmap; stat_cnt_t bmap;
stat_cnt_t retry; stat_cnt_t retry;
stat_cnt_t in_journal_hint; stat_cnt_t in_journal_hint;
stat_cnt_t in_journal_nohint; stat_cnt_t in_journal_nohint;
stat_cnt_t stolen; stat_cnt_t stolen;
} scan_bitmap; } scan_bitmap;
struct __journal_stats { struct __journal_stats {
stat_cnt_t in_journal; stat_cnt_t in_journal;
stat_cnt_t in_journal_bitmap; stat_cnt_t in_journal_bitmap;
stat_cnt_t in_journal_reusable; stat_cnt_t in_journal_reusable;
stat_cnt_t lock_journal; stat_cnt_t lock_journal;
stat_cnt_t lock_journal_wait; stat_cnt_t lock_journal_wait;
stat_cnt_t journal_being; stat_cnt_t journal_being;
stat_cnt_t journal_relock_writers; stat_cnt_t journal_relock_writers;
stat_cnt_t journal_relock_wcount; stat_cnt_t journal_relock_wcount;
stat_cnt_t mark_dirty; stat_cnt_t mark_dirty;
stat_cnt_t mark_dirty_already; stat_cnt_t mark_dirty_already;
stat_cnt_t mark_dirty_notjournal; stat_cnt_t mark_dirty_notjournal;
stat_cnt_t restore_prepared; stat_cnt_t restore_prepared;
stat_cnt_t prepare; stat_cnt_t prepare;
stat_cnt_t prepare_retry; stat_cnt_t prepare_retry;
} 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 */
unsigned long s_mount_opt; /* reiserfs's mount options are set unsigned long s_mount_opt; /* reiserfs's mount options are set
here (currently - NOTAIL, NOLOG, here (currently - NOTAIL, NOLOG,
REPLAYONLY) */ REPLAYONLY) */
struct { /* This is a structure that describes block allocator options */ struct { /* This is a structure that describes block allocator options */
unsigned long bits; /* Bitfield for enable/disable kind of options */ unsigned long bits; /* Bitfield for enable/disable kind of options */
unsigned long large_file_size; /* size started from which we consider file to be a large one(in blocks) */ unsigned long large_file_size; /* size started from which we consider file to be a large one(in blocks) */
int border; /* percentage of disk, border takes */ int border; /* percentage of disk, border takes */
int preallocmin; /* Minimal file size (in blocks) starting from which we do preallocations */ int preallocmin; /* Minimal file size (in blocks) starting from which we do preallocations */
int preallocsize; /* Number of blocks we try to prealloc when file int preallocsize; /* Number of blocks we try to prealloc when file
reaches preallocmin size (in blocks) or reaches preallocmin size (in blocks) or
prealloc_list is empty. */ prealloc_list is empty. */
} s_alloc_options; } s_alloc_options;
/* Comment? -Hans */ /* Comment? -Hans */
wait_queue_head_t s_wait; wait_queue_head_t s_wait;
/* To be obsoleted soon by per buffer seals.. -Hans */ /* To be obsoleted soon by per buffer seals.. -Hans */
atomic_t s_generation_counter; // increased by one every time the atomic_t s_generation_counter; // increased by one every time the
// tree gets re-balanced // tree gets re-balanced
unsigned long s_properties; /* File system properties. Currently holds unsigned long s_properties; /* File system properties. Currently holds
on-disk FS format */ on-disk FS format */
/* session statistics */ /* session statistics */
int s_kmallocs; int s_kmallocs;
int s_disk_reads; int s_disk_reads;
int s_disk_writes; int s_disk_writes;
int s_fix_nodes; int s_fix_nodes;
int s_do_balance; int s_do_balance;
int s_unneeded_left_neighbor; int s_unneeded_left_neighbor;
int s_good_search_by_key_reada; int s_good_search_by_key_reada;
int s_bmaps; int s_bmaps;
int s_bmaps_without_search; int s_bmaps_without_search;
int s_direct2indirect; int s_direct2indirect;
int s_indirect2direct; int s_indirect2direct;
/* set up when it's ok for reiserfs_read_inode2() to read from /* set up when it's ok for reiserfs_read_inode2() to read from
disk inode with nlink==0. Currently this is only used during disk inode with nlink==0. Currently this is only used during
finish_unfinished() processing at mount time */ finish_unfinished() processing at mount time */
int s_is_unlinked_ok; int s_is_unlinked_ok;
reiserfs_proc_info_data_t s_proc_info_data; reiserfs_proc_info_data_t s_proc_info_data;
struct proc_dir_entry *procdir; struct proc_dir_entry *procdir;
int reserved_blocks; /* amount of blocks reserved for further allocations */ int reserved_blocks; /* amount of blocks reserved for further allocations */
spinlock_t bitmap_lock; /* this lock on now only used to protect reserved_blocks variable */ spinlock_t bitmap_lock; /* this lock on now only used to protect reserved_blocks variable */
struct dentry *priv_root; /* root of /.reiserfs_priv */ struct dentry *priv_root; /* root of /.reiserfs_priv */
struct dentry *xattr_root; /* root of /.reiserfs_priv/.xa */ struct dentry *xattr_root; /* root of /.reiserfs_priv/.xa */
struct rw_semaphore xattr_dir_sem; struct rw_semaphore xattr_dir_sem;
int j_errno; int j_errno;
#ifdef CONFIG_QUOTA #ifdef CONFIG_QUOTA
char *s_qf_names[MAXQUOTAS]; char *s_qf_names[MAXQUOTAS];
int s_jquota_fmt; int s_jquota_fmt;
#endif #endif
}; };
@ -422,14 +418,14 @@ struct reiserfs_sb_info
enum reiserfs_mount_options { enum reiserfs_mount_options {
/* Mount options */ /* Mount options */
REISERFS_LARGETAIL, /* large tails will be created in a session */ REISERFS_LARGETAIL, /* large tails will be created in a session */
REISERFS_SMALLTAIL, /* small (for files less than block size) tails will be created in a session */ REISERFS_SMALLTAIL, /* small (for files less than block size) tails will be created in a session */
REPLAYONLY, /* replay journal and return 0. Use by fsck */ REPLAYONLY, /* replay journal and return 0. Use by fsck */
REISERFS_CONVERT, /* -o conv: causes conversion of old REISERFS_CONVERT, /* -o conv: causes conversion of old
format super block to the new format super block to the new
format. If not specified - old format. If not specified - old
partition will be dealt with in a partition will be dealt with in a
manner of 3.5.x */ manner of 3.5.x */
/* -o hash={tea, rupasov, r5, detect} is meant for properly mounting /* -o hash={tea, rupasov, r5, detect} is meant for properly mounting
** reiserfs disks from 3.5.19 or earlier. 99% of the time, this option ** reiserfs disks from 3.5.19 or earlier. 99% of the time, this option
@ -439,41 +435,41 @@ enum reiserfs_mount_options {
** the existing hash on the FS, so if you have a tea hash disk, and mount ** the existing hash on the FS, so if you have a tea hash disk, and mount
** with -o hash=rupasov, the mount will fail. ** with -o hash=rupasov, the mount will fail.
*/ */
FORCE_TEA_HASH, /* try to force tea hash on mount */ FORCE_TEA_HASH, /* try to force tea hash on mount */
FORCE_RUPASOV_HASH, /* try to force rupasov hash on mount */ FORCE_RUPASOV_HASH, /* try to force rupasov hash on mount */
FORCE_R5_HASH, /* try to force rupasov hash on mount */ FORCE_R5_HASH, /* try to force rupasov hash on mount */
FORCE_HASH_DETECT, /* try to detect hash function on mount */ FORCE_HASH_DETECT, /* try to detect hash function on mount */
REISERFS_DATA_LOG, REISERFS_DATA_LOG,
REISERFS_DATA_ORDERED, REISERFS_DATA_ORDERED,
REISERFS_DATA_WRITEBACK, REISERFS_DATA_WRITEBACK,
/* used for testing experimental features, makes benchmarking new /* used for testing experimental features, makes benchmarking new
features with and without more convenient, should never be used by features with and without more convenient, should never be used by
users in any code shipped to users (ideally) */ users in any code shipped to users (ideally) */
REISERFS_NO_BORDER, REISERFS_NO_BORDER,
REISERFS_NO_UNHASHED_RELOCATION, REISERFS_NO_UNHASHED_RELOCATION,
REISERFS_HASHED_RELOCATION, REISERFS_HASHED_RELOCATION,
REISERFS_ATTRS, REISERFS_ATTRS,
REISERFS_XATTRS, REISERFS_XATTRS,
REISERFS_XATTRS_USER, REISERFS_XATTRS_USER,
REISERFS_POSIXACL, REISERFS_POSIXACL,
REISERFS_BARRIER_NONE, REISERFS_BARRIER_NONE,
REISERFS_BARRIER_FLUSH, REISERFS_BARRIER_FLUSH,
/* Actions on error */ /* Actions on error */
REISERFS_ERROR_PANIC, REISERFS_ERROR_PANIC,
REISERFS_ERROR_RO, REISERFS_ERROR_RO,
REISERFS_ERROR_CONTINUE, REISERFS_ERROR_CONTINUE,
REISERFS_QUOTA, /* Some quota option specified */ REISERFS_QUOTA, /* Some quota option specified */
REISERFS_TEST1, REISERFS_TEST1,
REISERFS_TEST2, REISERFS_TEST2,
REISERFS_TEST3, REISERFS_TEST3,
REISERFS_TEST4, REISERFS_TEST4,
REISERFS_UNSUPPORTED_OPT, REISERFS_UNSUPPORTED_OPT,
}; };
#define reiserfs_r5_hash(s) (REISERFS_SB(s)->s_mount_opt & (1 << FORCE_R5_HASH)) #define reiserfs_r5_hash(s) (REISERFS_SB(s)->s_mount_opt & (1 << FORCE_R5_HASH))
@ -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 */

124
include/linux/reiserfs_xattr.h
Просмотреть файл

@ -7,48 +7,48 @@
#include <linux/xattr.h> #include <linux/xattr.h>
/* Magic value in header */ /* Magic value in header */
#define REISERFS_XATTR_MAGIC 0x52465841 /* "RFXA" */ #define REISERFS_XATTR_MAGIC 0x52465841 /* "RFXA" */
struct reiserfs_xattr_header { struct reiserfs_xattr_header {
__le32 h_magic; /* magic number for identification */ __le32 h_magic; /* magic number for identification */
__le32 h_hash; /* hash of the value */ __le32 h_hash; /* hash of the value */
}; };
#ifdef __KERNEL__ #ifdef __KERNEL__
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,
struct list_head handlers; char *out);
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,57 +56,48 @@ 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;
} }
#else #else
@ -127,13 +118,20 @@ 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)
{ {
sb->s_flags = (sb->s_flags & ~MS_POSIXACL); /* to be sure */ return 0;
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 */
return 0;
}; };
#endif #endif
#endif /* __KERNEL__ */ #endif /* __KERNEL__ */