blob: 7a88adbceef6ece45562579d2c24cdb6b196d33e [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
3 */
4
5#include <linux/time.h>
6#include <linux/reiserfs_fs.h>
7
8// this contains item handlers for old item types: sd, direct,
9// indirect, directory
10
11/* and where are the comments? how about saying where we can find an
12 explanation of each item handler method? -Hans */
13
14//////////////////////////////////////////////////////////////////////////////
15// stat data functions
16//
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070017static int sd_bytes_number(struct item_head *ih, int block_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -070018{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070019 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070020}
21
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070022static void sd_decrement_key(struct cpu_key *key)
Linus Torvalds1da177e2005-04-16 15:20:36 -070023{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070024 key->on_disk_key.k_objectid--;
25 set_cpu_key_k_type(key, TYPE_ANY);
26 set_cpu_key_k_offset(key, (loff_t) (-1));
Linus Torvalds1da177e2005-04-16 15:20:36 -070027}
28
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070029static int sd_is_left_mergeable(struct reiserfs_key *key, unsigned long bsize)
Linus Torvalds1da177e2005-04-16 15:20:36 -070030{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070031 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070032}
33
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070034static char *print_time(time_t t)
Linus Torvalds1da177e2005-04-16 15:20:36 -070035{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070036 static char timebuf[256];
Linus Torvalds1da177e2005-04-16 15:20:36 -070037
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070038 sprintf(timebuf, "%ld", t);
39 return timebuf;
Linus Torvalds1da177e2005-04-16 15:20:36 -070040}
41
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070042static void sd_print_item(struct item_head *ih, char *item)
Linus Torvalds1da177e2005-04-16 15:20:36 -070043{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070044 printk("\tmode | size | nlinks | first direct | mtime\n");
45 if (stat_data_v1(ih)) {
46 struct stat_data_v1 *sd = (struct stat_data_v1 *)item;
Linus Torvalds1da177e2005-04-16 15:20:36 -070047
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070048 printk("\t0%-6o | %6u | %2u | %d | %s\n", sd_v1_mode(sd),
49 sd_v1_size(sd), sd_v1_nlink(sd),
50 sd_v1_first_direct_byte(sd),
51 print_time(sd_v1_mtime(sd)));
52 } else {
53 struct stat_data *sd = (struct stat_data *)item;
Linus Torvalds1da177e2005-04-16 15:20:36 -070054
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070055 printk("\t0%-6o | %6Lu | %2u | %d | %s\n", sd_v2_mode(sd),
56 (unsigned long long)sd_v2_size(sd), sd_v2_nlink(sd),
57 sd_v2_rdev(sd), print_time(sd_v2_mtime(sd)));
58 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070059}
60
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070061static void sd_check_item(struct item_head *ih, char *item)
Linus Torvalds1da177e2005-04-16 15:20:36 -070062{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070063 // FIXME: type something here!
Linus Torvalds1da177e2005-04-16 15:20:36 -070064}
65
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070066static int sd_create_vi(struct virtual_node *vn,
67 struct virtual_item *vi,
68 int is_affected, int insert_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -070069{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070070 vi->vi_index = TYPE_STAT_DATA;
71 //vi->vi_type |= VI_TYPE_STAT_DATA;// not needed?
72 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070073}
74
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070075static int sd_check_left(struct virtual_item *vi, int free,
76 int start_skip, int end_skip)
Linus Torvalds1da177e2005-04-16 15:20:36 -070077{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070078 if (start_skip || end_skip)
79 BUG();
80 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -070081}
82
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070083static int sd_check_right(struct virtual_item *vi, int free)
Linus Torvalds1da177e2005-04-16 15:20:36 -070084{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070085 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -070086}
87
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070088static int sd_part_size(struct virtual_item *vi, int first, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -070089{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070090 if (count)
91 BUG();
92 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070093}
94
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070095static int sd_unit_num(struct virtual_item *vi)
Linus Torvalds1da177e2005-04-16 15:20:36 -070096{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070097 return vi->vi_item_len - IH_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -070098}
99
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700100static void sd_print_vi(struct virtual_item *vi)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700102 reiserfs_warning(NULL, "STATDATA, index %d, type 0x%x, %h",
103 vi->vi_index, vi->vi_type, vi->vi_ih);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104}
105
106static struct item_operations stat_data_ops = {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700107 .bytes_number = sd_bytes_number,
108 .decrement_key = sd_decrement_key,
109 .is_left_mergeable = sd_is_left_mergeable,
110 .print_item = sd_print_item,
111 .check_item = sd_check_item,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700113 .create_vi = sd_create_vi,
114 .check_left = sd_check_left,
115 .check_right = sd_check_right,
116 .part_size = sd_part_size,
117 .unit_num = sd_unit_num,
118 .print_vi = sd_print_vi
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119};
120
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121//////////////////////////////////////////////////////////////////////////////
122// direct item functions
123//
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700124static int direct_bytes_number(struct item_head *ih, int block_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700126 return ih_item_len(ih);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127}
128
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129// FIXME: this should probably switch to indirect as well
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700130static void direct_decrement_key(struct cpu_key *key)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700132 cpu_key_k_offset_dec(key);
133 if (cpu_key_k_offset(key) == 0)
134 set_cpu_key_k_type(key, TYPE_STAT_DATA);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135}
136
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700137static int direct_is_left_mergeable(struct reiserfs_key *key,
138 unsigned long bsize)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700140 int version = le_key_version(key);
141 return ((le_key_k_offset(version, key) & (bsize - 1)) != 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142}
143
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700144static void direct_print_item(struct item_head *ih, char *item)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700146 int j = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147
148// return;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700149 printk("\"");
150 while (j < ih_item_len(ih))
151 printk("%c", item[j++]);
152 printk("\"\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153}
154
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700155static void direct_check_item(struct item_head *ih, char *item)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700157 // FIXME: type something here!
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158}
159
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700160static int direct_create_vi(struct virtual_node *vn,
161 struct virtual_item *vi,
162 int is_affected, int insert_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700164 vi->vi_index = TYPE_DIRECT;
165 //vi->vi_type |= VI_TYPE_DIRECT;
166 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167}
168
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700169static int direct_check_left(struct virtual_item *vi, int free,
170 int start_skip, int end_skip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700172 int bytes;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700174 bytes = free - free % 8;
175 return bytes ? : -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176}
177
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700178static int direct_check_right(struct virtual_item *vi, int free)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700180 return direct_check_left(vi, free, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181}
182
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700183static int direct_part_size(struct virtual_item *vi, int first, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700185 return count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186}
187
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700188static int direct_unit_num(struct virtual_item *vi)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700190 return vi->vi_item_len - IH_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191}
192
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700193static void direct_print_vi(struct virtual_item *vi)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700195 reiserfs_warning(NULL, "DIRECT, index %d, type 0x%x, %h",
196 vi->vi_index, vi->vi_type, vi->vi_ih);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197}
198
199static struct item_operations direct_ops = {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700200 .bytes_number = direct_bytes_number,
201 .decrement_key = direct_decrement_key,
202 .is_left_mergeable = direct_is_left_mergeable,
203 .print_item = direct_print_item,
204 .check_item = direct_check_item,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700206 .create_vi = direct_create_vi,
207 .check_left = direct_check_left,
208 .check_right = direct_check_right,
209 .part_size = direct_part_size,
210 .unit_num = direct_unit_num,
211 .print_vi = direct_print_vi
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212};
213
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214//////////////////////////////////////////////////////////////////////////////
215// indirect item functions
216//
217
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700218static int indirect_bytes_number(struct item_head *ih, int block_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700220 return ih_item_len(ih) / UNFM_P_SIZE * block_size; //- get_ih_free_space (ih);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221}
222
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223// decrease offset, if it becomes 0, change type to stat data
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700224static void indirect_decrement_key(struct cpu_key *key)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700226 cpu_key_k_offset_dec(key);
227 if (cpu_key_k_offset(key) == 0)
228 set_cpu_key_k_type(key, TYPE_STAT_DATA);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229}
230
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231// if it is not first item of the body, then it is mergeable
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700232static int indirect_is_left_mergeable(struct reiserfs_key *key,
233 unsigned long bsize)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700235 int version = le_key_version(key);
236 return (le_key_k_offset(version, key) != 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237}
238
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239// printing of indirect item
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700240static void start_new_sequence(__u32 * start, int *len, __u32 new)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700242 *start = new;
243 *len = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244}
245
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700246static int sequence_finished(__u32 start, int *len, __u32 new)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700248 if (start == INT_MAX)
249 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700251 if (start == 0 && new == 0) {
252 (*len)++;
253 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700255 if (start != 0 && (start + *len) == new) {
256 (*len)++;
257 return 0;
258 }
259 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260}
261
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700262static void print_sequence(__u32 start, int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700264 if (start == INT_MAX)
265 return;
266
267 if (len == 1)
268 printk(" %d", start);
269 else
270 printk(" %d(%d)", start, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271}
272
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700273static void indirect_print_item(struct item_head *ih, char *item)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700275 int j;
276 __le32 *unp;
277 __u32 prev = INT_MAX;
Benoit Boissinotd5ee4ea2006-03-25 03:07:54 -0800278 int num = 0;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700279
280 unp = (__le32 *) item;
281
282 if (ih_item_len(ih) % UNFM_P_SIZE)
283 reiserfs_warning(NULL, "indirect_print_item: invalid item len");
284
285 printk("%d pointers\n[ ", (int)I_UNFM_NUM(ih));
286 for (j = 0; j < I_UNFM_NUM(ih); j++) {
287 if (sequence_finished(prev, &num, get_block_num(unp, j))) {
288 print_sequence(prev, num);
289 start_new_sequence(&prev, &num, get_block_num(unp, j));
290 }
291 }
292 print_sequence(prev, num);
293 printk("]\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294}
295
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700296static void indirect_check_item(struct item_head *ih, char *item)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700298 // FIXME: type something here!
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299}
300
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700301static int indirect_create_vi(struct virtual_node *vn,
302 struct virtual_item *vi,
303 int is_affected, int insert_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700305 vi->vi_index = TYPE_INDIRECT;
306 //vi->vi_type |= VI_TYPE_INDIRECT;
307 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308}
309
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700310static int indirect_check_left(struct virtual_item *vi, int free,
311 int start_skip, int end_skip)
312{
313 int bytes;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700315 bytes = free - free % UNFM_P_SIZE;
316 return bytes ? : -1;
317}
318
319static int indirect_check_right(struct virtual_item *vi, int free)
320{
321 return indirect_check_left(vi, free, 0, 0);
322}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323
324// return size in bytes of 'units' units. If first == 0 - calculate from the head (left), otherwise - from tail (right)
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700325static int indirect_part_size(struct virtual_item *vi, int first, int units)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700327 // unit of indirect item is byte (yet)
328 return units;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329}
330
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700331static int indirect_unit_num(struct virtual_item *vi)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700333 // unit of indirect item is byte (yet)
334 return vi->vi_item_len - IH_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335}
336
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700337static void indirect_print_vi(struct virtual_item *vi)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700339 reiserfs_warning(NULL, "INDIRECT, index %d, type 0x%x, %h",
340 vi->vi_index, vi->vi_type, vi->vi_ih);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341}
342
343static struct item_operations indirect_ops = {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700344 .bytes_number = indirect_bytes_number,
345 .decrement_key = indirect_decrement_key,
346 .is_left_mergeable = indirect_is_left_mergeable,
347 .print_item = indirect_print_item,
348 .check_item = indirect_check_item,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700350 .create_vi = indirect_create_vi,
351 .check_left = indirect_check_left,
352 .check_right = indirect_check_right,
353 .part_size = indirect_part_size,
354 .unit_num = indirect_unit_num,
355 .print_vi = indirect_print_vi
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356};
357
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358//////////////////////////////////////////////////////////////////////////////
359// direntry functions
360//
361
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700362static int direntry_bytes_number(struct item_head *ih, int block_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700364 reiserfs_warning(NULL, "vs-16090: direntry_bytes_number: "
365 "bytes number is asked for direntry");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367}
368
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700369static void direntry_decrement_key(struct cpu_key *key)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700371 cpu_key_k_offset_dec(key);
372 if (cpu_key_k_offset(key) == 0)
373 set_cpu_key_k_type(key, TYPE_STAT_DATA);
374}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700376static int direntry_is_left_mergeable(struct reiserfs_key *key,
377 unsigned long bsize)
378{
379 if (le32_to_cpu(key->u.k_offset_v1.k_offset) == DOT_OFFSET)
380 return 0;
381 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700383}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700385static void direntry_print_item(struct item_head *ih, char *item)
386{
387 int i;
388 int namelen;
389 struct reiserfs_de_head *deh;
390 char *name;
391 static char namebuf[80];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700393 printk("\n # %-15s%-30s%-15s%-15s%-15s\n", "Name",
394 "Key of pointed object", "Hash", "Gen number", "Status");
395
396 deh = (struct reiserfs_de_head *)item;
397
398 for (i = 0; i < I_ENTRY_COUNT(ih); i++, deh++) {
399 namelen =
400 (i ? (deh_location(deh - 1)) : ih_item_len(ih)) -
401 deh_location(deh);
402 name = item + deh_location(deh);
403 if (name[namelen - 1] == 0)
404 namelen = strlen(name);
405 namebuf[0] = '"';
406 if (namelen > sizeof(namebuf) - 3) {
407 strncpy(namebuf + 1, name, sizeof(namebuf) - 3);
408 namebuf[sizeof(namebuf) - 2] = '"';
409 namebuf[sizeof(namebuf) - 1] = 0;
410 } else {
411 memcpy(namebuf + 1, name, namelen);
412 namebuf[namelen + 1] = '"';
413 namebuf[namelen + 2] = 0;
414 }
415
416 printk("%d: %-15s%-15d%-15d%-15Ld%-15Ld(%s)\n",
417 i, namebuf,
418 deh_dir_id(deh), deh_objectid(deh),
419 GET_HASH_VALUE(deh_offset(deh)),
420 GET_GENERATION_NUMBER((deh_offset(deh))),
421 (de_hidden(deh)) ? "HIDDEN" : "VISIBLE");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423}
424
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700425static void direntry_check_item(struct item_head *ih, char *item)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700427 int i;
428 struct reiserfs_de_head *deh;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700430 // FIXME: type something here!
431 deh = (struct reiserfs_de_head *)item;
432 for (i = 0; i < I_ENTRY_COUNT(ih); i++, deh++) {
433 ;
434 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435}
436
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437#define DIRENTRY_VI_FIRST_DIRENTRY_ITEM 1
438
439/*
440 * function returns old entry number in directory item in real node
441 * using new entry number in virtual item in virtual node */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700442static inline int old_entry_num(int is_affected, int virtual_entry_num,
443 int pos_in_item, int mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700445 if (mode == M_INSERT || mode == M_DELETE)
446 return virtual_entry_num;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700448 if (!is_affected)
449 /* cut or paste is applied to another item */
450 return virtual_entry_num;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700452 if (virtual_entry_num < pos_in_item)
453 return virtual_entry_num;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700455 if (mode == M_CUT)
456 return virtual_entry_num + 1;
457
458 RFALSE(mode != M_PASTE || virtual_entry_num == 0,
459 "vs-8015: old_entry_num: mode must be M_PASTE (mode = \'%c\'",
460 mode);
461
462 return virtual_entry_num - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463}
464
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465/* Create an array of sizes of directory entries for virtual
466 item. Return space used by an item. FIXME: no control over
467 consuming of space used by this item handler */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700468static int direntry_create_vi(struct virtual_node *vn,
469 struct virtual_item *vi,
470 int is_affected, int insert_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700472 struct direntry_uarea *dir_u = vi->vi_uarea;
473 int i, j;
474 int size = sizeof(struct direntry_uarea);
475 struct reiserfs_de_head *deh;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700477 vi->vi_index = TYPE_DIRENTRY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700479 if (!(vi->vi_ih) || !vi->vi_item)
480 BUG();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700482 dir_u->flags = 0;
483 if (le_ih_k_offset(vi->vi_ih) == DOT_OFFSET)
484 dir_u->flags |= DIRENTRY_VI_FIRST_DIRENTRY_ITEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700486 deh = (struct reiserfs_de_head *)(vi->vi_item);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700488 /* virtual directory item have this amount of entry after */
489 dir_u->entry_count = ih_entry_count(vi->vi_ih) +
490 ((is_affected) ? ((vn->vn_mode == M_CUT) ? -1 :
491 (vn->vn_mode == M_PASTE ? 1 : 0)) : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700493 for (i = 0; i < dir_u->entry_count; i++) {
494 j = old_entry_num(is_affected, i, vn->vn_pos_in_item,
495 vn->vn_mode);
496 dir_u->entry_sizes[i] =
497 (j ? deh_location(&(deh[j - 1])) : ih_item_len(vi->vi_ih)) -
498 deh_location(&(deh[j])) + DEH_SIZE;
499 }
500
501 size += (dir_u->entry_count * sizeof(short));
502
503 /* set size of pasted entry */
504 if (is_affected && vn->vn_mode == M_PASTE)
505 dir_u->entry_sizes[vn->vn_pos_in_item] = insert_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506
507#ifdef CONFIG_REISERFS_CHECK
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700508 /* compare total size of entries with item length */
509 {
510 int k, l;
511
512 l = 0;
513 for (k = 0; k < dir_u->entry_count; k++)
514 l += dir_u->entry_sizes[k];
515
516 if (l + IH_SIZE != vi->vi_item_len +
517 ((is_affected
518 && (vn->vn_mode == M_PASTE
519 || vn->vn_mode == M_CUT)) ? insert_size : 0)) {
520 reiserfs_panic(NULL,
521 "vs-8025: set_entry_sizes: (mode==%c, insert_size==%d), invalid length of directory item",
522 vn->vn_mode, insert_size);
523 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525#endif
526
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700527 return size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528
529}
530
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531//
532// return number of entries which may fit into specified amount of
533// free space, or -1 if free space is not enough even for 1 entry
534//
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700535static int direntry_check_left(struct virtual_item *vi, int free,
536 int start_skip, int end_skip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700538 int i;
539 int entries = 0;
540 struct direntry_uarea *dir_u = vi->vi_uarea;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700542 for (i = start_skip; i < dir_u->entry_count - end_skip; i++) {
543 if (dir_u->entry_sizes[i] > free)
544 /* i-th entry doesn't fit into the remaining free space */
545 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700547 free -= dir_u->entry_sizes[i];
548 entries++;
549 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700551 if (entries == dir_u->entry_count) {
552 reiserfs_panic(NULL, "free space %d, entry_count %d\n", free,
553 dir_u->entry_count);
554 }
555
556 /* "." and ".." can not be separated from each other */
557 if (start_skip == 0 && (dir_u->flags & DIRENTRY_VI_FIRST_DIRENTRY_ITEM)
558 && entries < 2)
559 entries = 0;
560
561 return entries ? : -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562}
563
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700564static int direntry_check_right(struct virtual_item *vi, int free)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700566 int i;
567 int entries = 0;
568 struct direntry_uarea *dir_u = vi->vi_uarea;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700570 for (i = dir_u->entry_count - 1; i >= 0; i--) {
571 if (dir_u->entry_sizes[i] > free)
572 /* i-th entry doesn't fit into the remaining free space */
573 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700575 free -= dir_u->entry_sizes[i];
576 entries++;
577 }
578 if (entries == dir_u->entry_count)
579 BUG();
580
581 /* "." and ".." can not be separated from each other */
582 if ((dir_u->flags & DIRENTRY_VI_FIRST_DIRENTRY_ITEM)
583 && entries > dir_u->entry_count - 2)
584 entries = dir_u->entry_count - 2;
585
586 return entries ? : -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587}
588
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589/* sum of entry sizes between from-th and to-th entries including both edges */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700590static int direntry_part_size(struct virtual_item *vi, int first, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700592 int i, retval;
593 int from, to;
594 struct direntry_uarea *dir_u = vi->vi_uarea;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700596 retval = 0;
597 if (first == 0)
598 from = 0;
599 else
600 from = dir_u->entry_count - count;
601 to = from + count - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700603 for (i = from; i <= to; i++)
604 retval += dir_u->entry_sizes[i];
605
606 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607}
608
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700609static int direntry_unit_num(struct virtual_item *vi)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700611 struct direntry_uarea *dir_u = vi->vi_uarea;
612
613 return dir_u->entry_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614}
615
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700616static void direntry_print_vi(struct virtual_item *vi)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700618 int i;
619 struct direntry_uarea *dir_u = vi->vi_uarea;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700621 reiserfs_warning(NULL, "DIRENTRY, index %d, type 0x%x, %h, flags 0x%x",
622 vi->vi_index, vi->vi_type, vi->vi_ih, dir_u->flags);
623 printk("%d entries: ", dir_u->entry_count);
624 for (i = 0; i < dir_u->entry_count; i++)
625 printk("%d ", dir_u->entry_sizes[i]);
626 printk("\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627}
628
629static struct item_operations direntry_ops = {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700630 .bytes_number = direntry_bytes_number,
631 .decrement_key = direntry_decrement_key,
632 .is_left_mergeable = direntry_is_left_mergeable,
633 .print_item = direntry_print_item,
634 .check_item = direntry_check_item,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700636 .create_vi = direntry_create_vi,
637 .check_left = direntry_check_left,
638 .check_right = direntry_check_right,
639 .part_size = direntry_part_size,
640 .unit_num = direntry_unit_num,
641 .print_vi = direntry_print_vi
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642};
643
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644//////////////////////////////////////////////////////////////////////////////
645// Error catching functions to catch errors caused by incorrect item types.
646//
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700647static int errcatch_bytes_number(struct item_head *ih, int block_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700649 reiserfs_warning(NULL,
650 "green-16001: Invalid item type observed, run fsck ASAP");
651 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652}
653
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700654static void errcatch_decrement_key(struct cpu_key *key)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700656 reiserfs_warning(NULL,
657 "green-16002: Invalid item type observed, run fsck ASAP");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658}
659
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700660static int errcatch_is_left_mergeable(struct reiserfs_key *key,
661 unsigned long bsize)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700663 reiserfs_warning(NULL,
664 "green-16003: Invalid item type observed, run fsck ASAP");
665 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666}
667
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700668static void errcatch_print_item(struct item_head *ih, char *item)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700670 reiserfs_warning(NULL,
671 "green-16004: Invalid item type observed, run fsck ASAP");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672}
673
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700674static void errcatch_check_item(struct item_head *ih, char *item)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700676 reiserfs_warning(NULL,
677 "green-16005: Invalid item type observed, run fsck ASAP");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678}
679
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700680static int errcatch_create_vi(struct virtual_node *vn,
681 struct virtual_item *vi,
682 int is_affected, int insert_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700684 reiserfs_warning(NULL,
685 "green-16006: Invalid item type observed, run fsck ASAP");
686 return 0; // We might return -1 here as well, but it won't help as create_virtual_node() from where
687 // this operation is called from is of return type void.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688}
689
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700690static int errcatch_check_left(struct virtual_item *vi, int free,
691 int start_skip, int end_skip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700693 reiserfs_warning(NULL,
694 "green-16007: Invalid item type observed, run fsck ASAP");
695 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696}
697
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700698static int errcatch_check_right(struct virtual_item *vi, int free)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700700 reiserfs_warning(NULL,
701 "green-16008: Invalid item type observed, run fsck ASAP");
702 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703}
704
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700705static int errcatch_part_size(struct virtual_item *vi, int first, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700707 reiserfs_warning(NULL,
708 "green-16009: Invalid item type observed, run fsck ASAP");
709 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710}
711
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700712static int errcatch_unit_num(struct virtual_item *vi)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700714 reiserfs_warning(NULL,
715 "green-16010: Invalid item type observed, run fsck ASAP");
716 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717}
718
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700719static void errcatch_print_vi(struct virtual_item *vi)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700721 reiserfs_warning(NULL,
722 "green-16011: Invalid item type observed, run fsck ASAP");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723}
724
725static struct item_operations errcatch_ops = {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700726 errcatch_bytes_number,
727 errcatch_decrement_key,
728 errcatch_is_left_mergeable,
729 errcatch_print_item,
730 errcatch_check_item,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700732 errcatch_create_vi,
733 errcatch_check_left,
734 errcatch_check_right,
735 errcatch_part_size,
736 errcatch_unit_num,
737 errcatch_print_vi
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738};
739
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740//////////////////////////////////////////////////////////////////////////////
741//
742//
743#if ! (TYPE_STAT_DATA == 0 && TYPE_INDIRECT == 1 && TYPE_DIRECT == 2 && TYPE_DIRENTRY == 3)
Jeff Mahoney7fa94c82005-07-12 19:19:30 -0400744#error Item types must use disk-format assigned values.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745#endif
746
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700747struct item_operations *item_ops[TYPE_ANY + 1] = {
748 &stat_data_ops,
749 &indirect_ops,
750 &direct_ops,
751 &direntry_ops,
752 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
753 &errcatch_ops /* This is to catch errors with invalid type (15th entry for TYPE_ANY) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754};