Loading...
1/*
2 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
3 *
4 * Trivial changes by Alan Cox to remove EHASHCOLLISION for compatibility
5 *
6 * Trivial Changes:
7 * Rights granted to Hans Reiser to redistribute under other terms providing
8 * he accepts all liability including but not limited to patent, fitness
9 * for purpose, and direct or indirect claims arising from failure to perform.
10 *
11 * NO WARRANTY
12 */
13
14#include <linux/time.h>
15#include <linux/bitops.h>
16#include <linux/slab.h>
17#include <linux/reiserfs_fs.h>
18#include <linux/reiserfs_acl.h>
19#include <linux/reiserfs_xattr.h>
20#include <linux/quotaops.h>
21
22#define INC_DIR_INODE_NLINK(i) if (i->i_nlink != 1) { inc_nlink(i); if (i->i_nlink >= REISERFS_LINK_MAX) i->i_nlink=1; }
23#define DEC_DIR_INODE_NLINK(i) if (i->i_nlink != 1) drop_nlink(i);
24
25// directory item contains array of entry headers. This performs
26// binary search through that array
27static int bin_search_in_dir_item(struct reiserfs_dir_entry *de, loff_t off)
28{
29 struct item_head *ih = de->de_ih;
30 struct reiserfs_de_head *deh = de->de_deh;
31 int rbound, lbound, j;
32
33 lbound = 0;
34 rbound = I_ENTRY_COUNT(ih) - 1;
35
36 for (j = (rbound + lbound) / 2; lbound <= rbound;
37 j = (rbound + lbound) / 2) {
38 if (off < deh_offset(deh + j)) {
39 rbound = j - 1;
40 continue;
41 }
42 if (off > deh_offset(deh + j)) {
43 lbound = j + 1;
44 continue;
45 }
46 // this is not name found, but matched third key component
47 de->de_entry_num = j;
48 return NAME_FOUND;
49 }
50
51 de->de_entry_num = lbound;
52 return NAME_NOT_FOUND;
53}
54
55// comment? maybe something like set de to point to what the path points to?
56static inline void set_de_item_location(struct reiserfs_dir_entry *de,
57 struct treepath *path)
58{
59 de->de_bh = get_last_bh(path);
60 de->de_ih = get_ih(path);
61 de->de_deh = B_I_DEH(de->de_bh, de->de_ih);
62 de->de_item_num = PATH_LAST_POSITION(path);
63}
64
65// de_bh, de_ih, de_deh (points to first element of array), de_item_num is set
66inline void set_de_name_and_namelen(struct reiserfs_dir_entry *de)
67{
68 struct reiserfs_de_head *deh = de->de_deh + de->de_entry_num;
69
70 BUG_ON(de->de_entry_num >= ih_entry_count(de->de_ih));
71
72 de->de_entrylen = entry_length(de->de_bh, de->de_ih, de->de_entry_num);
73 de->de_namelen = de->de_entrylen - (de_with_sd(deh) ? SD_SIZE : 0);
74 de->de_name = B_I_PITEM(de->de_bh, de->de_ih) + deh_location(deh);
75 if (de->de_name[de->de_namelen - 1] == 0)
76 de->de_namelen = strlen(de->de_name);
77}
78
79// what entry points to
80static inline void set_de_object_key(struct reiserfs_dir_entry *de)
81{
82 BUG_ON(de->de_entry_num >= ih_entry_count(de->de_ih));
83 de->de_dir_id = deh_dir_id(&(de->de_deh[de->de_entry_num]));
84 de->de_objectid = deh_objectid(&(de->de_deh[de->de_entry_num]));
85}
86
87static inline void store_de_entry_key(struct reiserfs_dir_entry *de)
88{
89 struct reiserfs_de_head *deh = de->de_deh + de->de_entry_num;
90
91 BUG_ON(de->de_entry_num >= ih_entry_count(de->de_ih));
92
93 /* store key of the found entry */
94 de->de_entry_key.version = KEY_FORMAT_3_5;
95 de->de_entry_key.on_disk_key.k_dir_id =
96 le32_to_cpu(de->de_ih->ih_key.k_dir_id);
97 de->de_entry_key.on_disk_key.k_objectid =
98 le32_to_cpu(de->de_ih->ih_key.k_objectid);
99 set_cpu_key_k_offset(&(de->de_entry_key), deh_offset(deh));
100 set_cpu_key_k_type(&(de->de_entry_key), TYPE_DIRENTRY);
101}
102
103/* We assign a key to each directory item, and place multiple entries
104in a single directory item. A directory item has a key equal to the
105key of the first directory entry in it.
106
107This function first calls search_by_key, then, if item whose first
108entry matches is not found it looks for the entry inside directory
109item found by search_by_key. Fills the path to the entry, and to the
110entry position in the item
111
112*/
113
114/* The function is NOT SCHEDULE-SAFE! */
115int search_by_entry_key(struct super_block *sb, const struct cpu_key *key,
116 struct treepath *path, struct reiserfs_dir_entry *de)
117{
118 int retval;
119
120 retval = search_item(sb, key, path);
121 switch (retval) {
122 case ITEM_NOT_FOUND:
123 if (!PATH_LAST_POSITION(path)) {
124 reiserfs_error(sb, "vs-7000", "search_by_key "
125 "returned item position == 0");
126 pathrelse(path);
127 return IO_ERROR;
128 }
129 PATH_LAST_POSITION(path)--;
130
131 case ITEM_FOUND:
132 break;
133
134 case IO_ERROR:
135 return retval;
136
137 default:
138 pathrelse(path);
139 reiserfs_error(sb, "vs-7002", "no path to here");
140 return IO_ERROR;
141 }
142
143 set_de_item_location(de, path);
144
145#ifdef CONFIG_REISERFS_CHECK
146 if (!is_direntry_le_ih(de->de_ih) ||
147 COMP_SHORT_KEYS(&(de->de_ih->ih_key), key)) {
148 print_block(de->de_bh, 0, -1, -1);
149 reiserfs_panic(sb, "vs-7005", "found item %h is not directory "
150 "item or does not belong to the same directory "
151 "as key %K", de->de_ih, key);
152 }
153#endif /* CONFIG_REISERFS_CHECK */
154
155 /* binary search in directory item by third componen t of the
156 key. sets de->de_entry_num of de */
157 retval = bin_search_in_dir_item(de, cpu_key_k_offset(key));
158 path->pos_in_item = de->de_entry_num;
159 if (retval != NAME_NOT_FOUND) {
160 // ugly, but rename needs de_bh, de_deh, de_name, de_namelen, de_objectid set
161 set_de_name_and_namelen(de);
162 set_de_object_key(de);
163 }
164 return retval;
165}
166
167/* Keyed 32-bit hash function using TEA in a Davis-Meyer function */
168
169/* The third component is hashed, and you can choose from more than
170 one hash function. Per directory hashes are not yet implemented
171 but are thought about. This function should be moved to hashes.c
172 Jedi, please do so. -Hans */
173
174static __u32 get_third_component(struct super_block *s,
175 const char *name, int len)
176{
177 __u32 res;
178
179 if (!len || (len == 1 && name[0] == '.'))
180 return DOT_OFFSET;
181 if (len == 2 && name[0] == '.' && name[1] == '.')
182 return DOT_DOT_OFFSET;
183
184 res = REISERFS_SB(s)->s_hash_function(name, len);
185
186 // take bits from 7-th to 30-th including both bounds
187 res = GET_HASH_VALUE(res);
188 if (res == 0)
189 // needed to have no names before "." and ".." those have hash
190 // value == 0 and generation conters 1 and 2 accordingly
191 res = 128;
192 return res + MAX_GENERATION_NUMBER;
193}
194
195static int reiserfs_match(struct reiserfs_dir_entry *de,
196 const char *name, int namelen)
197{
198 int retval = NAME_NOT_FOUND;
199
200 if ((namelen == de->de_namelen) &&
201 !memcmp(de->de_name, name, de->de_namelen))
202 retval =
203 (de_visible(de->de_deh + de->de_entry_num) ? NAME_FOUND :
204 NAME_FOUND_INVISIBLE);
205
206 return retval;
207}
208
209/* de's de_bh, de_ih, de_deh, de_item_num, de_entry_num are set already */
210
211 /* used when hash collisions exist */
212
213static int linear_search_in_dir_item(struct cpu_key *key,
214 struct reiserfs_dir_entry *de,
215 const char *name, int namelen)
216{
217 struct reiserfs_de_head *deh = de->de_deh;
218 int retval;
219 int i;
220
221 i = de->de_entry_num;
222
223 if (i == I_ENTRY_COUNT(de->de_ih) ||
224 GET_HASH_VALUE(deh_offset(deh + i)) !=
225 GET_HASH_VALUE(cpu_key_k_offset(key))) {
226 i--;
227 }
228
229 RFALSE(de->de_deh != B_I_DEH(de->de_bh, de->de_ih),
230 "vs-7010: array of entry headers not found");
231
232 deh += i;
233
234 for (; i >= 0; i--, deh--) {
235 if (GET_HASH_VALUE(deh_offset(deh)) !=
236 GET_HASH_VALUE(cpu_key_k_offset(key))) {
237 // hash value does not match, no need to check whole name
238 return NAME_NOT_FOUND;
239 }
240
241 /* mark, that this generation number is used */
242 if (de->de_gen_number_bit_string)
243 set_bit(GET_GENERATION_NUMBER(deh_offset(deh)),
244 de->de_gen_number_bit_string);
245
246 // calculate pointer to name and namelen
247 de->de_entry_num = i;
248 set_de_name_and_namelen(de);
249
250 if ((retval =
251 reiserfs_match(de, name, namelen)) != NAME_NOT_FOUND) {
252 // de's de_name, de_namelen, de_recordlen are set. Fill the rest:
253
254 // key of pointed object
255 set_de_object_key(de);
256
257 store_de_entry_key(de);
258
259 // retval can be NAME_FOUND or NAME_FOUND_INVISIBLE
260 return retval;
261 }
262 }
263
264 if (GET_GENERATION_NUMBER(le_ih_k_offset(de->de_ih)) == 0)
265 /* we have reached left most entry in the node. In common we
266 have to go to the left neighbor, but if generation counter
267 is 0 already, we know for sure, that there is no name with
268 the same hash value */
269 // FIXME: this work correctly only because hash value can not
270 // be 0. Btw, in case of Yura's hash it is probably possible,
271 // so, this is a bug
272 return NAME_NOT_FOUND;
273
274 RFALSE(de->de_item_num,
275 "vs-7015: two diritems of the same directory in one node?");
276
277 return GOTO_PREVIOUS_ITEM;
278}
279
280// may return NAME_FOUND, NAME_FOUND_INVISIBLE, NAME_NOT_FOUND
281// FIXME: should add something like IOERROR
282static int reiserfs_find_entry(struct inode *dir, const char *name, int namelen,
283 struct treepath *path_to_entry,
284 struct reiserfs_dir_entry *de)
285{
286 struct cpu_key key_to_search;
287 int retval;
288
289 if (namelen > REISERFS_MAX_NAME(dir->i_sb->s_blocksize))
290 return NAME_NOT_FOUND;
291
292 /* we will search for this key in the tree */
293 make_cpu_key(&key_to_search, dir,
294 get_third_component(dir->i_sb, name, namelen),
295 TYPE_DIRENTRY, 3);
296
297 while (1) {
298 retval =
299 search_by_entry_key(dir->i_sb, &key_to_search,
300 path_to_entry, de);
301 if (retval == IO_ERROR) {
302 reiserfs_error(dir->i_sb, "zam-7001", "io error");
303 return IO_ERROR;
304 }
305
306 /* compare names for all entries having given hash value */
307 retval =
308 linear_search_in_dir_item(&key_to_search, de, name,
309 namelen);
310 if (retval != GOTO_PREVIOUS_ITEM) {
311 /* there is no need to scan directory anymore. Given entry found or does not exist */
312 path_to_entry->pos_in_item = de->de_entry_num;
313 return retval;
314 }
315
316 /* there is left neighboring item of this directory and given entry can be there */
317 set_cpu_key_k_offset(&key_to_search,
318 le_ih_k_offset(de->de_ih) - 1);
319 pathrelse(path_to_entry);
320
321 } /* while (1) */
322}
323
324static struct dentry *reiserfs_lookup(struct inode *dir, struct dentry *dentry,
325 struct nameidata *nd)
326{
327 int retval;
328 int lock_depth;
329 struct inode *inode = NULL;
330 struct reiserfs_dir_entry de;
331 INITIALIZE_PATH(path_to_entry);
332
333 if (REISERFS_MAX_NAME(dir->i_sb->s_blocksize) < dentry->d_name.len)
334 return ERR_PTR(-ENAMETOOLONG);
335
336 /*
337 * Might be called with or without the write lock, must be careful
338 * to not recursively hold it in case we want to release the lock
339 * before rescheduling.
340 */
341 lock_depth = reiserfs_write_lock_once(dir->i_sb);
342
343 de.de_gen_number_bit_string = NULL;
344 retval =
345 reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len,
346 &path_to_entry, &de);
347 pathrelse(&path_to_entry);
348 if (retval == NAME_FOUND) {
349 inode = reiserfs_iget(dir->i_sb,
350 (struct cpu_key *)&(de.de_dir_id));
351 if (!inode || IS_ERR(inode)) {
352 reiserfs_write_unlock_once(dir->i_sb, lock_depth);
353 return ERR_PTR(-EACCES);
354 }
355
356 /* Propagate the private flag so we know we're
357 * in the priv tree */
358 if (IS_PRIVATE(dir))
359 inode->i_flags |= S_PRIVATE;
360 }
361 reiserfs_write_unlock_once(dir->i_sb, lock_depth);
362 if (retval == IO_ERROR) {
363 return ERR_PTR(-EIO);
364 }
365
366 return d_splice_alias(inode, dentry);
367}
368
369/*
370** looks up the dentry of the parent directory for child.
371** taken from ext2_get_parent
372*/
373struct dentry *reiserfs_get_parent(struct dentry *child)
374{
375 int retval;
376 struct inode *inode = NULL;
377 struct reiserfs_dir_entry de;
378 INITIALIZE_PATH(path_to_entry);
379 struct inode *dir = child->d_inode;
380
381 if (dir->i_nlink == 0) {
382 return ERR_PTR(-ENOENT);
383 }
384 de.de_gen_number_bit_string = NULL;
385
386 reiserfs_write_lock(dir->i_sb);
387 retval = reiserfs_find_entry(dir, "..", 2, &path_to_entry, &de);
388 pathrelse(&path_to_entry);
389 if (retval != NAME_FOUND) {
390 reiserfs_write_unlock(dir->i_sb);
391 return ERR_PTR(-ENOENT);
392 }
393 inode = reiserfs_iget(dir->i_sb, (struct cpu_key *)&(de.de_dir_id));
394 reiserfs_write_unlock(dir->i_sb);
395
396 return d_obtain_alias(inode);
397}
398
399/* add entry to the directory (entry can be hidden).
400
401insert definition of when hidden directories are used here -Hans
402
403 Does not mark dir inode dirty, do it after successesfull call to it */
404
405static int reiserfs_add_entry(struct reiserfs_transaction_handle *th,
406 struct inode *dir, const char *name, int namelen,
407 struct inode *inode, int visible)
408{
409 struct cpu_key entry_key;
410 struct reiserfs_de_head *deh;
411 INITIALIZE_PATH(path);
412 struct reiserfs_dir_entry de;
413 DECLARE_BITMAP(bit_string, MAX_GENERATION_NUMBER + 1);
414 int gen_number;
415 char small_buf[32 + DEH_SIZE]; /* 48 bytes now and we avoid kmalloc
416 if we create file with short name */
417 char *buffer;
418 int buflen, paste_size;
419 int retval;
420
421 BUG_ON(!th->t_trans_id);
422
423 /* cannot allow items to be added into a busy deleted directory */
424 if (!namelen)
425 return -EINVAL;
426
427 if (namelen > REISERFS_MAX_NAME(dir->i_sb->s_blocksize))
428 return -ENAMETOOLONG;
429
430 /* each entry has unique key. compose it */
431 make_cpu_key(&entry_key, dir,
432 get_third_component(dir->i_sb, name, namelen),
433 TYPE_DIRENTRY, 3);
434
435 /* get memory for composing the entry */
436 buflen = DEH_SIZE + ROUND_UP(namelen);
437 if (buflen > sizeof(small_buf)) {
438 buffer = kmalloc(buflen, GFP_NOFS);
439 if (!buffer)
440 return -ENOMEM;
441 } else
442 buffer = small_buf;
443
444 paste_size =
445 (get_inode_sd_version(dir) ==
446 STAT_DATA_V1) ? (DEH_SIZE + namelen) : buflen;
447
448 /* fill buffer : directory entry head, name[, dir objectid | , stat data | ,stat data, dir objectid ] */
449 deh = (struct reiserfs_de_head *)buffer;
450 deh->deh_location = 0; /* JDM Endian safe if 0 */
451 put_deh_offset(deh, cpu_key_k_offset(&entry_key));
452 deh->deh_state = 0; /* JDM Endian safe if 0 */
453 /* put key (ino analog) to de */
454 deh->deh_dir_id = INODE_PKEY(inode)->k_dir_id; /* safe: k_dir_id is le */
455 deh->deh_objectid = INODE_PKEY(inode)->k_objectid; /* safe: k_objectid is le */
456
457 /* copy name */
458 memcpy((char *)(deh + 1), name, namelen);
459 /* padd by 0s to the 4 byte boundary */
460 padd_item((char *)(deh + 1), ROUND_UP(namelen), namelen);
461
462 /* entry is ready to be pasted into tree, set 'visibility' and 'stat data in entry' attributes */
463 mark_de_without_sd(deh);
464 visible ? mark_de_visible(deh) : mark_de_hidden(deh);
465
466 /* find the proper place for the new entry */
467 memset(bit_string, 0, sizeof(bit_string));
468 de.de_gen_number_bit_string = bit_string;
469 retval = reiserfs_find_entry(dir, name, namelen, &path, &de);
470 if (retval != NAME_NOT_FOUND) {
471 if (buffer != small_buf)
472 kfree(buffer);
473 pathrelse(&path);
474
475 if (retval == IO_ERROR) {
476 return -EIO;
477 }
478
479 if (retval != NAME_FOUND) {
480 reiserfs_error(dir->i_sb, "zam-7002",
481 "reiserfs_find_entry() returned "
482 "unexpected value (%d)", retval);
483 }
484
485 return -EEXIST;
486 }
487
488 gen_number =
489 find_first_zero_bit(bit_string,
490 MAX_GENERATION_NUMBER + 1);
491 if (gen_number > MAX_GENERATION_NUMBER) {
492 /* there is no free generation number */
493 reiserfs_warning(dir->i_sb, "reiserfs-7010",
494 "Congratulations! we have got hash function "
495 "screwed up");
496 if (buffer != small_buf)
497 kfree(buffer);
498 pathrelse(&path);
499 return -EBUSY;
500 }
501 /* adjust offset of directory enrty */
502 put_deh_offset(deh, SET_GENERATION_NUMBER(deh_offset(deh), gen_number));
503 set_cpu_key_k_offset(&entry_key, deh_offset(deh));
504
505 /* update max-hash-collisions counter in reiserfs_sb_info */
506 PROC_INFO_MAX(th->t_super, max_hash_collisions, gen_number);
507
508 if (gen_number != 0) { /* we need to re-search for the insertion point */
509 if (search_by_entry_key(dir->i_sb, &entry_key, &path, &de) !=
510 NAME_NOT_FOUND) {
511 reiserfs_warning(dir->i_sb, "vs-7032",
512 "entry with this key (%K) already "
513 "exists", &entry_key);
514
515 if (buffer != small_buf)
516 kfree(buffer);
517 pathrelse(&path);
518 return -EBUSY;
519 }
520 }
521
522 /* perform the insertion of the entry that we have prepared */
523 retval =
524 reiserfs_paste_into_item(th, &path, &entry_key, dir, buffer,
525 paste_size);
526 if (buffer != small_buf)
527 kfree(buffer);
528 if (retval) {
529 reiserfs_check_path(&path);
530 return retval;
531 }
532
533 dir->i_size += paste_size;
534 dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
535 if (!S_ISDIR(inode->i_mode) && visible)
536 // reiserfs_mkdir or reiserfs_rename will do that by itself
537 reiserfs_update_sd(th, dir);
538
539 reiserfs_check_path(&path);
540 return 0;
541}
542
543/* quota utility function, call if you've had to abort after calling
544** new_inode_init, and have not called reiserfs_new_inode yet.
545** This should only be called on inodes that do not have stat data
546** inserted into the tree yet.
547*/
548static int drop_new_inode(struct inode *inode)
549{
550 dquot_drop(inode);
551 make_bad_inode(inode);
552 inode->i_flags |= S_NOQUOTA;
553 iput(inode);
554 return 0;
555}
556
557/* utility function that does setup for reiserfs_new_inode.
558** dquot_initialize needs lots of credits so it's better to have it
559** outside of a transaction, so we had to pull some bits of
560** reiserfs_new_inode out into this func.
561*/
562static int new_inode_init(struct inode *inode, struct inode *dir, int mode)
563{
564 /* Make inode invalid - just in case we are going to drop it before
565 * the initialization happens */
566 INODE_PKEY(inode)->k_objectid = 0;
567 /* the quota init calls have to know who to charge the quota to, so
568 ** we have to set uid and gid here
569 */
570 inode_init_owner(inode, dir, mode);
571 dquot_initialize(inode);
572 return 0;
573}
574
575static int reiserfs_create(struct inode *dir, struct dentry *dentry, int mode,
576 struct nameidata *nd)
577{
578 int retval;
579 struct inode *inode;
580 /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
581 int jbegin_count =
582 JOURNAL_PER_BALANCE_CNT * 2 +
583 2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
584 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
585 struct reiserfs_transaction_handle th;
586 struct reiserfs_security_handle security;
587
588 dquot_initialize(dir);
589
590 if (!(inode = new_inode(dir->i_sb))) {
591 return -ENOMEM;
592 }
593 new_inode_init(inode, dir, mode);
594
595 jbegin_count += reiserfs_cache_default_acl(dir);
596 retval = reiserfs_security_init(dir, inode, &dentry->d_name, &security);
597 if (retval < 0) {
598 drop_new_inode(inode);
599 return retval;
600 }
601 jbegin_count += retval;
602 reiserfs_write_lock(dir->i_sb);
603
604 retval = journal_begin(&th, dir->i_sb, jbegin_count);
605 if (retval) {
606 drop_new_inode(inode);
607 goto out_failed;
608 }
609
610 retval =
611 reiserfs_new_inode(&th, dir, mode, NULL, 0 /*i_size */ , dentry,
612 inode, &security);
613 if (retval)
614 goto out_failed;
615
616 inode->i_op = &reiserfs_file_inode_operations;
617 inode->i_fop = &reiserfs_file_operations;
618 inode->i_mapping->a_ops = &reiserfs_address_space_operations;
619
620 retval =
621 reiserfs_add_entry(&th, dir, dentry->d_name.name,
622 dentry->d_name.len, inode, 1 /*visible */ );
623 if (retval) {
624 int err;
625 inode->i_nlink--;
626 reiserfs_update_sd(&th, inode);
627 err = journal_end(&th, dir->i_sb, jbegin_count);
628 if (err)
629 retval = err;
630 unlock_new_inode(inode);
631 iput(inode);
632 goto out_failed;
633 }
634 reiserfs_update_inode_transaction(inode);
635 reiserfs_update_inode_transaction(dir);
636
637 d_instantiate(dentry, inode);
638 unlock_new_inode(inode);
639 retval = journal_end(&th, dir->i_sb, jbegin_count);
640
641 out_failed:
642 reiserfs_write_unlock(dir->i_sb);
643 return retval;
644}
645
646static int reiserfs_mknod(struct inode *dir, struct dentry *dentry, int mode,
647 dev_t rdev)
648{
649 int retval;
650 struct inode *inode;
651 struct reiserfs_transaction_handle th;
652 struct reiserfs_security_handle security;
653 /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
654 int jbegin_count =
655 JOURNAL_PER_BALANCE_CNT * 3 +
656 2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
657 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
658
659 if (!new_valid_dev(rdev))
660 return -EINVAL;
661
662 dquot_initialize(dir);
663
664 if (!(inode = new_inode(dir->i_sb))) {
665 return -ENOMEM;
666 }
667 new_inode_init(inode, dir, mode);
668
669 jbegin_count += reiserfs_cache_default_acl(dir);
670 retval = reiserfs_security_init(dir, inode, &dentry->d_name, &security);
671 if (retval < 0) {
672 drop_new_inode(inode);
673 return retval;
674 }
675 jbegin_count += retval;
676 reiserfs_write_lock(dir->i_sb);
677
678 retval = journal_begin(&th, dir->i_sb, jbegin_count);
679 if (retval) {
680 drop_new_inode(inode);
681 goto out_failed;
682 }
683
684 retval =
685 reiserfs_new_inode(&th, dir, mode, NULL, 0 /*i_size */ , dentry,
686 inode, &security);
687 if (retval) {
688 goto out_failed;
689 }
690
691 inode->i_op = &reiserfs_special_inode_operations;
692 init_special_inode(inode, inode->i_mode, rdev);
693
694 //FIXME: needed for block and char devices only
695 reiserfs_update_sd(&th, inode);
696
697 reiserfs_update_inode_transaction(inode);
698 reiserfs_update_inode_transaction(dir);
699
700 retval =
701 reiserfs_add_entry(&th, dir, dentry->d_name.name,
702 dentry->d_name.len, inode, 1 /*visible */ );
703 if (retval) {
704 int err;
705 inode->i_nlink--;
706 reiserfs_update_sd(&th, inode);
707 err = journal_end(&th, dir->i_sb, jbegin_count);
708 if (err)
709 retval = err;
710 unlock_new_inode(inode);
711 iput(inode);
712 goto out_failed;
713 }
714
715 d_instantiate(dentry, inode);
716 unlock_new_inode(inode);
717 retval = journal_end(&th, dir->i_sb, jbegin_count);
718
719 out_failed:
720 reiserfs_write_unlock(dir->i_sb);
721 return retval;
722}
723
724static int reiserfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
725{
726 int retval;
727 struct inode *inode;
728 struct reiserfs_transaction_handle th;
729 struct reiserfs_security_handle security;
730 int lock_depth;
731 /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
732 int jbegin_count =
733 JOURNAL_PER_BALANCE_CNT * 3 +
734 2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
735 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
736
737 dquot_initialize(dir);
738
739#ifdef DISPLACE_NEW_PACKING_LOCALITIES
740 /* set flag that new packing locality created and new blocks for the content * of that directory are not displaced yet */
741 REISERFS_I(dir)->new_packing_locality = 1;
742#endif
743 mode = S_IFDIR | mode;
744 if (!(inode = new_inode(dir->i_sb))) {
745 return -ENOMEM;
746 }
747 new_inode_init(inode, dir, mode);
748
749 jbegin_count += reiserfs_cache_default_acl(dir);
750 retval = reiserfs_security_init(dir, inode, &dentry->d_name, &security);
751 if (retval < 0) {
752 drop_new_inode(inode);
753 return retval;
754 }
755 jbegin_count += retval;
756 lock_depth = reiserfs_write_lock_once(dir->i_sb);
757
758 retval = journal_begin(&th, dir->i_sb, jbegin_count);
759 if (retval) {
760 drop_new_inode(inode);
761 goto out_failed;
762 }
763
764 /* inc the link count now, so another writer doesn't overflow it while
765 ** we sleep later on.
766 */
767 INC_DIR_INODE_NLINK(dir)
768
769 retval = reiserfs_new_inode(&th, dir, mode, NULL /*symlink */ ,
770 old_format_only(dir->i_sb) ?
771 EMPTY_DIR_SIZE_V1 : EMPTY_DIR_SIZE,
772 dentry, inode, &security);
773 if (retval) {
774 DEC_DIR_INODE_NLINK(dir)
775 goto out_failed;
776 }
777
778 reiserfs_update_inode_transaction(inode);
779 reiserfs_update_inode_transaction(dir);
780
781 inode->i_op = &reiserfs_dir_inode_operations;
782 inode->i_fop = &reiserfs_dir_operations;
783
784 // note, _this_ add_entry will not update dir's stat data
785 retval =
786 reiserfs_add_entry(&th, dir, dentry->d_name.name,
787 dentry->d_name.len, inode, 1 /*visible */ );
788 if (retval) {
789 int err;
790 inode->i_nlink = 0;
791 DEC_DIR_INODE_NLINK(dir);
792 reiserfs_update_sd(&th, inode);
793 err = journal_end(&th, dir->i_sb, jbegin_count);
794 if (err)
795 retval = err;
796 unlock_new_inode(inode);
797 iput(inode);
798 goto out_failed;
799 }
800 // the above add_entry did not update dir's stat data
801 reiserfs_update_sd(&th, dir);
802
803 d_instantiate(dentry, inode);
804 unlock_new_inode(inode);
805 retval = journal_end(&th, dir->i_sb, jbegin_count);
806out_failed:
807 reiserfs_write_unlock_once(dir->i_sb, lock_depth);
808 return retval;
809}
810
811static inline int reiserfs_empty_dir(struct inode *inode)
812{
813 /* we can cheat because an old format dir cannot have
814 ** EMPTY_DIR_SIZE, and a new format dir cannot have
815 ** EMPTY_DIR_SIZE_V1. So, if the inode is either size,
816 ** regardless of disk format version, the directory is empty.
817 */
818 if (inode->i_size != EMPTY_DIR_SIZE &&
819 inode->i_size != EMPTY_DIR_SIZE_V1) {
820 return 0;
821 }
822 return 1;
823}
824
825static int reiserfs_rmdir(struct inode *dir, struct dentry *dentry)
826{
827 int retval, err;
828 struct inode *inode;
829 struct reiserfs_transaction_handle th;
830 int jbegin_count;
831 INITIALIZE_PATH(path);
832 struct reiserfs_dir_entry de;
833
834 /* we will be doing 2 balancings and update 2 stat data, we change quotas
835 * of the owner of the directory and of the owner of the parent directory.
836 * The quota structure is possibly deleted only on last iput => outside
837 * of this transaction */
838 jbegin_count =
839 JOURNAL_PER_BALANCE_CNT * 2 + 2 +
840 4 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);
841
842 dquot_initialize(dir);
843
844 reiserfs_write_lock(dir->i_sb);
845 retval = journal_begin(&th, dir->i_sb, jbegin_count);
846 if (retval)
847 goto out_rmdir;
848
849 de.de_gen_number_bit_string = NULL;
850 if ((retval =
851 reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len,
852 &path, &de)) == NAME_NOT_FOUND) {
853 retval = -ENOENT;
854 goto end_rmdir;
855 } else if (retval == IO_ERROR) {
856 retval = -EIO;
857 goto end_rmdir;
858 }
859
860 inode = dentry->d_inode;
861
862 reiserfs_update_inode_transaction(inode);
863 reiserfs_update_inode_transaction(dir);
864
865 if (de.de_objectid != inode->i_ino) {
866 // FIXME: compare key of an object and a key found in the
867 // entry
868 retval = -EIO;
869 goto end_rmdir;
870 }
871 if (!reiserfs_empty_dir(inode)) {
872 retval = -ENOTEMPTY;
873 goto end_rmdir;
874 }
875
876 /* cut entry from dir directory */
877 retval = reiserfs_cut_from_item(&th, &path, &(de.de_entry_key), dir, NULL, /* page */
878 0 /*new file size - not used here */ );
879 if (retval < 0)
880 goto end_rmdir;
881
882 if (inode->i_nlink != 2 && inode->i_nlink != 1)
883 reiserfs_error(inode->i_sb, "reiserfs-7040",
884 "empty directory has nlink != 2 (%d)",
885 inode->i_nlink);
886
887 clear_nlink(inode);
888 inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME_SEC;
889 reiserfs_update_sd(&th, inode);
890
891 DEC_DIR_INODE_NLINK(dir)
892 dir->i_size -= (DEH_SIZE + de.de_entrylen);
893 reiserfs_update_sd(&th, dir);
894
895 /* prevent empty directory from getting lost */
896 add_save_link(&th, inode, 0 /* not truncate */ );
897
898 retval = journal_end(&th, dir->i_sb, jbegin_count);
899 reiserfs_check_path(&path);
900 out_rmdir:
901 reiserfs_write_unlock(dir->i_sb);
902 return retval;
903
904 end_rmdir:
905 /* we must release path, because we did not call
906 reiserfs_cut_from_item, or reiserfs_cut_from_item does not
907 release path if operation was not complete */
908 pathrelse(&path);
909 err = journal_end(&th, dir->i_sb, jbegin_count);
910 reiserfs_write_unlock(dir->i_sb);
911 return err ? err : retval;
912}
913
914static int reiserfs_unlink(struct inode *dir, struct dentry *dentry)
915{
916 int retval, err;
917 struct inode *inode;
918 struct reiserfs_dir_entry de;
919 INITIALIZE_PATH(path);
920 struct reiserfs_transaction_handle th;
921 int jbegin_count;
922 unsigned long savelink;
923 int depth;
924
925 dquot_initialize(dir);
926
927 inode = dentry->d_inode;
928
929 /* in this transaction we can be doing at max two balancings and update
930 * two stat datas, we change quotas of the owner of the directory and of
931 * the owner of the parent directory. The quota structure is possibly
932 * deleted only on iput => outside of this transaction */
933 jbegin_count =
934 JOURNAL_PER_BALANCE_CNT * 2 + 2 +
935 4 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);
936
937 depth = reiserfs_write_lock_once(dir->i_sb);
938 retval = journal_begin(&th, dir->i_sb, jbegin_count);
939 if (retval)
940 goto out_unlink;
941
942 de.de_gen_number_bit_string = NULL;
943 if ((retval =
944 reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len,
945 &path, &de)) == NAME_NOT_FOUND) {
946 retval = -ENOENT;
947 goto end_unlink;
948 } else if (retval == IO_ERROR) {
949 retval = -EIO;
950 goto end_unlink;
951 }
952
953 reiserfs_update_inode_transaction(inode);
954 reiserfs_update_inode_transaction(dir);
955
956 if (de.de_objectid != inode->i_ino) {
957 // FIXME: compare key of an object and a key found in the
958 // entry
959 retval = -EIO;
960 goto end_unlink;
961 }
962
963 if (!inode->i_nlink) {
964 reiserfs_warning(inode->i_sb, "reiserfs-7042",
965 "deleting nonexistent file (%lu), %d",
966 inode->i_ino, inode->i_nlink);
967 inode->i_nlink = 1;
968 }
969
970 drop_nlink(inode);
971
972 /*
973 * we schedule before doing the add_save_link call, save the link
974 * count so we don't race
975 */
976 savelink = inode->i_nlink;
977
978 retval =
979 reiserfs_cut_from_item(&th, &path, &(de.de_entry_key), dir, NULL,
980 0);
981 if (retval < 0) {
982 inc_nlink(inode);
983 goto end_unlink;
984 }
985 inode->i_ctime = CURRENT_TIME_SEC;
986 reiserfs_update_sd(&th, inode);
987
988 dir->i_size -= (de.de_entrylen + DEH_SIZE);
989 dir->i_ctime = dir->i_mtime = CURRENT_TIME_SEC;
990 reiserfs_update_sd(&th, dir);
991
992 if (!savelink)
993 /* prevent file from getting lost */
994 add_save_link(&th, inode, 0 /* not truncate */ );
995
996 retval = journal_end(&th, dir->i_sb, jbegin_count);
997 reiserfs_check_path(&path);
998 reiserfs_write_unlock_once(dir->i_sb, depth);
999 return retval;
1000
1001 end_unlink:
1002 pathrelse(&path);
1003 err = journal_end(&th, dir->i_sb, jbegin_count);
1004 reiserfs_check_path(&path);
1005 if (err)
1006 retval = err;
1007 out_unlink:
1008 reiserfs_write_unlock_once(dir->i_sb, depth);
1009 return retval;
1010}
1011
1012static int reiserfs_symlink(struct inode *parent_dir,
1013 struct dentry *dentry, const char *symname)
1014{
1015 int retval;
1016 struct inode *inode;
1017 char *name;
1018 int item_len;
1019 struct reiserfs_transaction_handle th;
1020 struct reiserfs_security_handle security;
1021 int mode = S_IFLNK | S_IRWXUGO;
1022 /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
1023 int jbegin_count =
1024 JOURNAL_PER_BALANCE_CNT * 3 +
1025 2 * (REISERFS_QUOTA_INIT_BLOCKS(parent_dir->i_sb) +
1026 REISERFS_QUOTA_TRANS_BLOCKS(parent_dir->i_sb));
1027
1028 dquot_initialize(parent_dir);
1029
1030 if (!(inode = new_inode(parent_dir->i_sb))) {
1031 return -ENOMEM;
1032 }
1033 new_inode_init(inode, parent_dir, mode);
1034
1035 retval = reiserfs_security_init(parent_dir, inode, &dentry->d_name,
1036 &security);
1037 if (retval < 0) {
1038 drop_new_inode(inode);
1039 return retval;
1040 }
1041 jbegin_count += retval;
1042
1043 reiserfs_write_lock(parent_dir->i_sb);
1044 item_len = ROUND_UP(strlen(symname));
1045 if (item_len > MAX_DIRECT_ITEM_LEN(parent_dir->i_sb->s_blocksize)) {
1046 retval = -ENAMETOOLONG;
1047 drop_new_inode(inode);
1048 goto out_failed;
1049 }
1050
1051 name = kmalloc(item_len, GFP_NOFS);
1052 if (!name) {
1053 drop_new_inode(inode);
1054 retval = -ENOMEM;
1055 goto out_failed;
1056 }
1057 memcpy(name, symname, strlen(symname));
1058 padd_item(name, item_len, strlen(symname));
1059
1060 retval = journal_begin(&th, parent_dir->i_sb, jbegin_count);
1061 if (retval) {
1062 drop_new_inode(inode);
1063 kfree(name);
1064 goto out_failed;
1065 }
1066
1067 retval =
1068 reiserfs_new_inode(&th, parent_dir, mode, name, strlen(symname),
1069 dentry, inode, &security);
1070 kfree(name);
1071 if (retval) { /* reiserfs_new_inode iputs for us */
1072 goto out_failed;
1073 }
1074
1075 reiserfs_update_inode_transaction(inode);
1076 reiserfs_update_inode_transaction(parent_dir);
1077
1078 inode->i_op = &reiserfs_symlink_inode_operations;
1079 inode->i_mapping->a_ops = &reiserfs_address_space_operations;
1080
1081 // must be sure this inode is written with this transaction
1082 //
1083 //reiserfs_update_sd (&th, inode, READ_BLOCKS);
1084
1085 retval = reiserfs_add_entry(&th, parent_dir, dentry->d_name.name,
1086 dentry->d_name.len, inode, 1 /*visible */ );
1087 if (retval) {
1088 int err;
1089 inode->i_nlink--;
1090 reiserfs_update_sd(&th, inode);
1091 err = journal_end(&th, parent_dir->i_sb, jbegin_count);
1092 if (err)
1093 retval = err;
1094 unlock_new_inode(inode);
1095 iput(inode);
1096 goto out_failed;
1097 }
1098
1099 d_instantiate(dentry, inode);
1100 unlock_new_inode(inode);
1101 retval = journal_end(&th, parent_dir->i_sb, jbegin_count);
1102 out_failed:
1103 reiserfs_write_unlock(parent_dir->i_sb);
1104 return retval;
1105}
1106
1107static int reiserfs_link(struct dentry *old_dentry, struct inode *dir,
1108 struct dentry *dentry)
1109{
1110 int retval;
1111 struct inode *inode = old_dentry->d_inode;
1112 struct reiserfs_transaction_handle th;
1113 /* We need blocks for transaction + update of quotas for the owners of the directory */
1114 int jbegin_count =
1115 JOURNAL_PER_BALANCE_CNT * 3 +
1116 2 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);
1117
1118 dquot_initialize(dir);
1119
1120 reiserfs_write_lock(dir->i_sb);
1121 if (inode->i_nlink >= REISERFS_LINK_MAX) {
1122 //FIXME: sd_nlink is 32 bit for new files
1123 reiserfs_write_unlock(dir->i_sb);
1124 return -EMLINK;
1125 }
1126
1127 /* inc before scheduling so reiserfs_unlink knows we are here */
1128 inc_nlink(inode);
1129
1130 retval = journal_begin(&th, dir->i_sb, jbegin_count);
1131 if (retval) {
1132 inode->i_nlink--;
1133 reiserfs_write_unlock(dir->i_sb);
1134 return retval;
1135 }
1136
1137 /* create new entry */
1138 retval =
1139 reiserfs_add_entry(&th, dir, dentry->d_name.name,
1140 dentry->d_name.len, inode, 1 /*visible */ );
1141
1142 reiserfs_update_inode_transaction(inode);
1143 reiserfs_update_inode_transaction(dir);
1144
1145 if (retval) {
1146 int err;
1147 inode->i_nlink--;
1148 err = journal_end(&th, dir->i_sb, jbegin_count);
1149 reiserfs_write_unlock(dir->i_sb);
1150 return err ? err : retval;
1151 }
1152
1153 inode->i_ctime = CURRENT_TIME_SEC;
1154 reiserfs_update_sd(&th, inode);
1155
1156 ihold(inode);
1157 d_instantiate(dentry, inode);
1158 retval = journal_end(&th, dir->i_sb, jbegin_count);
1159 reiserfs_write_unlock(dir->i_sb);
1160 return retval;
1161}
1162
1163/* de contains information pointing to an entry which */
1164static int de_still_valid(const char *name, int len,
1165 struct reiserfs_dir_entry *de)
1166{
1167 struct reiserfs_dir_entry tmp = *de;
1168
1169 // recalculate pointer to name and name length
1170 set_de_name_and_namelen(&tmp);
1171 // FIXME: could check more
1172 if (tmp.de_namelen != len || memcmp(name, de->de_name, len))
1173 return 0;
1174 return 1;
1175}
1176
1177static int entry_points_to_object(const char *name, int len,
1178 struct reiserfs_dir_entry *de,
1179 struct inode *inode)
1180{
1181 if (!de_still_valid(name, len, de))
1182 return 0;
1183
1184 if (inode) {
1185 if (!de_visible(de->de_deh + de->de_entry_num))
1186 reiserfs_panic(inode->i_sb, "vs-7042",
1187 "entry must be visible");
1188 return (de->de_objectid == inode->i_ino) ? 1 : 0;
1189 }
1190
1191 /* this must be added hidden entry */
1192 if (de_visible(de->de_deh + de->de_entry_num))
1193 reiserfs_panic(NULL, "vs-7043", "entry must be visible");
1194
1195 return 1;
1196}
1197
1198/* sets key of objectid the entry has to point to */
1199static void set_ino_in_dir_entry(struct reiserfs_dir_entry *de,
1200 struct reiserfs_key *key)
1201{
1202 /* JDM These operations are endian safe - both are le */
1203 de->de_deh[de->de_entry_num].deh_dir_id = key->k_dir_id;
1204 de->de_deh[de->de_entry_num].deh_objectid = key->k_objectid;
1205}
1206
1207/*
1208 * process, that is going to call fix_nodes/do_balance must hold only
1209 * one path. If it holds 2 or more, it can get into endless waiting in
1210 * get_empty_nodes or its clones
1211 */
1212static int reiserfs_rename(struct inode *old_dir, struct dentry *old_dentry,
1213 struct inode *new_dir, struct dentry *new_dentry)
1214{
1215 int retval;
1216 INITIALIZE_PATH(old_entry_path);
1217 INITIALIZE_PATH(new_entry_path);
1218 INITIALIZE_PATH(dot_dot_entry_path);
1219 struct item_head new_entry_ih, old_entry_ih, dot_dot_ih;
1220 struct reiserfs_dir_entry old_de, new_de, dot_dot_de;
1221 struct inode *old_inode, *new_dentry_inode;
1222 struct reiserfs_transaction_handle th;
1223 int jbegin_count;
1224 umode_t old_inode_mode;
1225 unsigned long savelink = 1;
1226 struct timespec ctime;
1227
1228 /* three balancings: (1) old name removal, (2) new name insertion
1229 and (3) maybe "save" link insertion
1230 stat data updates: (1) old directory,
1231 (2) new directory and (3) maybe old object stat data (when it is
1232 directory) and (4) maybe stat data of object to which new entry
1233 pointed initially and (5) maybe block containing ".." of
1234 renamed directory
1235 quota updates: two parent directories */
1236 jbegin_count =
1237 JOURNAL_PER_BALANCE_CNT * 3 + 5 +
1238 4 * REISERFS_QUOTA_TRANS_BLOCKS(old_dir->i_sb);
1239
1240 dquot_initialize(old_dir);
1241 dquot_initialize(new_dir);
1242
1243 old_inode = old_dentry->d_inode;
1244 new_dentry_inode = new_dentry->d_inode;
1245
1246 // make sure, that oldname still exists and points to an object we
1247 // are going to rename
1248 old_de.de_gen_number_bit_string = NULL;
1249 reiserfs_write_lock(old_dir->i_sb);
1250 retval =
1251 reiserfs_find_entry(old_dir, old_dentry->d_name.name,
1252 old_dentry->d_name.len, &old_entry_path,
1253 &old_de);
1254 pathrelse(&old_entry_path);
1255 if (retval == IO_ERROR) {
1256 reiserfs_write_unlock(old_dir->i_sb);
1257 return -EIO;
1258 }
1259
1260 if (retval != NAME_FOUND || old_de.de_objectid != old_inode->i_ino) {
1261 reiserfs_write_unlock(old_dir->i_sb);
1262 return -ENOENT;
1263 }
1264
1265 old_inode_mode = old_inode->i_mode;
1266 if (S_ISDIR(old_inode_mode)) {
1267 // make sure, that directory being renamed has correct ".."
1268 // and that its new parent directory has not too many links
1269 // already
1270
1271 if (new_dentry_inode) {
1272 if (!reiserfs_empty_dir(new_dentry_inode)) {
1273 reiserfs_write_unlock(old_dir->i_sb);
1274 return -ENOTEMPTY;
1275 }
1276 }
1277
1278 /* directory is renamed, its parent directory will be changed,
1279 ** so find ".." entry
1280 */
1281 dot_dot_de.de_gen_number_bit_string = NULL;
1282 retval =
1283 reiserfs_find_entry(old_inode, "..", 2, &dot_dot_entry_path,
1284 &dot_dot_de);
1285 pathrelse(&dot_dot_entry_path);
1286 if (retval != NAME_FOUND) {
1287 reiserfs_write_unlock(old_dir->i_sb);
1288 return -EIO;
1289 }
1290
1291 /* inode number of .. must equal old_dir->i_ino */
1292 if (dot_dot_de.de_objectid != old_dir->i_ino) {
1293 reiserfs_write_unlock(old_dir->i_sb);
1294 return -EIO;
1295 }
1296 }
1297
1298 retval = journal_begin(&th, old_dir->i_sb, jbegin_count);
1299 if (retval) {
1300 reiserfs_write_unlock(old_dir->i_sb);
1301 return retval;
1302 }
1303
1304 /* add new entry (or find the existing one) */
1305 retval =
1306 reiserfs_add_entry(&th, new_dir, new_dentry->d_name.name,
1307 new_dentry->d_name.len, old_inode, 0);
1308 if (retval == -EEXIST) {
1309 if (!new_dentry_inode) {
1310 reiserfs_panic(old_dir->i_sb, "vs-7050",
1311 "new entry is found, new inode == 0");
1312 }
1313 } else if (retval) {
1314 int err = journal_end(&th, old_dir->i_sb, jbegin_count);
1315 reiserfs_write_unlock(old_dir->i_sb);
1316 return err ? err : retval;
1317 }
1318
1319 reiserfs_update_inode_transaction(old_dir);
1320 reiserfs_update_inode_transaction(new_dir);
1321
1322 /* this makes it so an fsync on an open fd for the old name will
1323 ** commit the rename operation
1324 */
1325 reiserfs_update_inode_transaction(old_inode);
1326
1327 if (new_dentry_inode)
1328 reiserfs_update_inode_transaction(new_dentry_inode);
1329
1330 while (1) {
1331 // look for old name using corresponding entry key (found by reiserfs_find_entry)
1332 if ((retval =
1333 search_by_entry_key(new_dir->i_sb, &old_de.de_entry_key,
1334 &old_entry_path,
1335 &old_de)) != NAME_FOUND) {
1336 pathrelse(&old_entry_path);
1337 journal_end(&th, old_dir->i_sb, jbegin_count);
1338 reiserfs_write_unlock(old_dir->i_sb);
1339 return -EIO;
1340 }
1341
1342 copy_item_head(&old_entry_ih, get_ih(&old_entry_path));
1343
1344 reiserfs_prepare_for_journal(old_inode->i_sb, old_de.de_bh, 1);
1345
1346 // look for new name by reiserfs_find_entry
1347 new_de.de_gen_number_bit_string = NULL;
1348 retval =
1349 reiserfs_find_entry(new_dir, new_dentry->d_name.name,
1350 new_dentry->d_name.len, &new_entry_path,
1351 &new_de);
1352 // reiserfs_add_entry should not return IO_ERROR, because it is called with essentially same parameters from
1353 // reiserfs_add_entry above, and we'll catch any i/o errors before we get here.
1354 if (retval != NAME_FOUND_INVISIBLE && retval != NAME_FOUND) {
1355 pathrelse(&new_entry_path);
1356 pathrelse(&old_entry_path);
1357 journal_end(&th, old_dir->i_sb, jbegin_count);
1358 reiserfs_write_unlock(old_dir->i_sb);
1359 return -EIO;
1360 }
1361
1362 copy_item_head(&new_entry_ih, get_ih(&new_entry_path));
1363
1364 reiserfs_prepare_for_journal(old_inode->i_sb, new_de.de_bh, 1);
1365
1366 if (S_ISDIR(old_inode->i_mode)) {
1367 if ((retval =
1368 search_by_entry_key(new_dir->i_sb,
1369 &dot_dot_de.de_entry_key,
1370 &dot_dot_entry_path,
1371 &dot_dot_de)) != NAME_FOUND) {
1372 pathrelse(&dot_dot_entry_path);
1373 pathrelse(&new_entry_path);
1374 pathrelse(&old_entry_path);
1375 journal_end(&th, old_dir->i_sb, jbegin_count);
1376 reiserfs_write_unlock(old_dir->i_sb);
1377 return -EIO;
1378 }
1379 copy_item_head(&dot_dot_ih,
1380 get_ih(&dot_dot_entry_path));
1381 // node containing ".." gets into transaction
1382 reiserfs_prepare_for_journal(old_inode->i_sb,
1383 dot_dot_de.de_bh, 1);
1384 }
1385 /* we should check seals here, not do
1386 this stuff, yes? Then, having
1387 gathered everything into RAM we
1388 should lock the buffers, yes? -Hans */
1389 /* probably. our rename needs to hold more
1390 ** than one path at once. The seals would
1391 ** have to be written to deal with multi-path
1392 ** issues -chris
1393 */
1394 /* sanity checking before doing the rename - avoid races many
1395 ** of the above checks could have scheduled. We have to be
1396 ** sure our items haven't been shifted by another process.
1397 */
1398 if (item_moved(&new_entry_ih, &new_entry_path) ||
1399 !entry_points_to_object(new_dentry->d_name.name,
1400 new_dentry->d_name.len,
1401 &new_de, new_dentry_inode) ||
1402 item_moved(&old_entry_ih, &old_entry_path) ||
1403 !entry_points_to_object(old_dentry->d_name.name,
1404 old_dentry->d_name.len,
1405 &old_de, old_inode)) {
1406 reiserfs_restore_prepared_buffer(old_inode->i_sb,
1407 new_de.de_bh);
1408 reiserfs_restore_prepared_buffer(old_inode->i_sb,
1409 old_de.de_bh);
1410 if (S_ISDIR(old_inode_mode))
1411 reiserfs_restore_prepared_buffer(old_inode->
1412 i_sb,
1413 dot_dot_de.
1414 de_bh);
1415 continue;
1416 }
1417 if (S_ISDIR(old_inode_mode)) {
1418 if (item_moved(&dot_dot_ih, &dot_dot_entry_path) ||
1419 !entry_points_to_object("..", 2, &dot_dot_de,
1420 old_dir)) {
1421 reiserfs_restore_prepared_buffer(old_inode->
1422 i_sb,
1423 old_de.de_bh);
1424 reiserfs_restore_prepared_buffer(old_inode->
1425 i_sb,
1426 new_de.de_bh);
1427 reiserfs_restore_prepared_buffer(old_inode->
1428 i_sb,
1429 dot_dot_de.
1430 de_bh);
1431 continue;
1432 }
1433 }
1434
1435 RFALSE(S_ISDIR(old_inode_mode) &&
1436 !buffer_journal_prepared(dot_dot_de.de_bh), "");
1437
1438 break;
1439 }
1440
1441 /* ok, all the changes can be done in one fell swoop when we
1442 have claimed all the buffers needed. */
1443
1444 mark_de_visible(new_de.de_deh + new_de.de_entry_num);
1445 set_ino_in_dir_entry(&new_de, INODE_PKEY(old_inode));
1446 journal_mark_dirty(&th, old_dir->i_sb, new_de.de_bh);
1447
1448 mark_de_hidden(old_de.de_deh + old_de.de_entry_num);
1449 journal_mark_dirty(&th, old_dir->i_sb, old_de.de_bh);
1450 ctime = CURRENT_TIME_SEC;
1451 old_dir->i_ctime = old_dir->i_mtime = ctime;
1452 new_dir->i_ctime = new_dir->i_mtime = ctime;
1453 /* thanks to Alex Adriaanse <alex_a@caltech.edu> for patch which adds ctime update of
1454 renamed object */
1455 old_inode->i_ctime = ctime;
1456
1457 if (new_dentry_inode) {
1458 // adjust link number of the victim
1459 if (S_ISDIR(new_dentry_inode->i_mode)) {
1460 clear_nlink(new_dentry_inode);
1461 } else {
1462 drop_nlink(new_dentry_inode);
1463 }
1464 new_dentry_inode->i_ctime = ctime;
1465 savelink = new_dentry_inode->i_nlink;
1466 }
1467
1468 if (S_ISDIR(old_inode_mode)) {
1469 /* adjust ".." of renamed directory */
1470 set_ino_in_dir_entry(&dot_dot_de, INODE_PKEY(new_dir));
1471 journal_mark_dirty(&th, new_dir->i_sb, dot_dot_de.de_bh);
1472
1473 if (!new_dentry_inode)
1474 /* there (in new_dir) was no directory, so it got new link
1475 (".." of renamed directory) */
1476 INC_DIR_INODE_NLINK(new_dir);
1477
1478 /* old directory lost one link - ".. " of renamed directory */
1479 DEC_DIR_INODE_NLINK(old_dir);
1480 }
1481 // looks like in 2.3.99pre3 brelse is atomic. so we can use pathrelse
1482 pathrelse(&new_entry_path);
1483 pathrelse(&dot_dot_entry_path);
1484
1485 // FIXME: this reiserfs_cut_from_item's return value may screw up
1486 // anybody, but it will panic if will not be able to find the
1487 // entry. This needs one more clean up
1488 if (reiserfs_cut_from_item
1489 (&th, &old_entry_path, &(old_de.de_entry_key), old_dir, NULL,
1490 0) < 0)
1491 reiserfs_error(old_dir->i_sb, "vs-7060",
1492 "couldn't not cut old name. Fsck later?");
1493
1494 old_dir->i_size -= DEH_SIZE + old_de.de_entrylen;
1495
1496 reiserfs_update_sd(&th, old_dir);
1497 reiserfs_update_sd(&th, new_dir);
1498 reiserfs_update_sd(&th, old_inode);
1499
1500 if (new_dentry_inode) {
1501 if (savelink == 0)
1502 add_save_link(&th, new_dentry_inode,
1503 0 /* not truncate */ );
1504 reiserfs_update_sd(&th, new_dentry_inode);
1505 }
1506
1507 retval = journal_end(&th, old_dir->i_sb, jbegin_count);
1508 reiserfs_write_unlock(old_dir->i_sb);
1509 return retval;
1510}
1511
1512/*
1513 * directories can handle most operations...
1514 */
1515const struct inode_operations reiserfs_dir_inode_operations = {
1516 //&reiserfs_dir_operations, /* default_file_ops */
1517 .create = reiserfs_create,
1518 .lookup = reiserfs_lookup,
1519 .link = reiserfs_link,
1520 .unlink = reiserfs_unlink,
1521 .symlink = reiserfs_symlink,
1522 .mkdir = reiserfs_mkdir,
1523 .rmdir = reiserfs_rmdir,
1524 .mknod = reiserfs_mknod,
1525 .rename = reiserfs_rename,
1526 .setattr = reiserfs_setattr,
1527 .setxattr = reiserfs_setxattr,
1528 .getxattr = reiserfs_getxattr,
1529 .listxattr = reiserfs_listxattr,
1530 .removexattr = reiserfs_removexattr,
1531 .permission = reiserfs_permission,
1532 .get_acl = reiserfs_get_acl,
1533};
1534
1535/*
1536 * symlink operations.. same as page_symlink_inode_operations, with xattr
1537 * stuff added
1538 */
1539const struct inode_operations reiserfs_symlink_inode_operations = {
1540 .readlink = generic_readlink,
1541 .follow_link = page_follow_link_light,
1542 .put_link = page_put_link,
1543 .setattr = reiserfs_setattr,
1544 .setxattr = reiserfs_setxattr,
1545 .getxattr = reiserfs_getxattr,
1546 .listxattr = reiserfs_listxattr,
1547 .removexattr = reiserfs_removexattr,
1548 .permission = reiserfs_permission,
1549 .get_acl = reiserfs_get_acl,
1550
1551};
1552
1553/*
1554 * special file operations.. just xattr/acl stuff
1555 */
1556const struct inode_operations reiserfs_special_inode_operations = {
1557 .setattr = reiserfs_setattr,
1558 .setxattr = reiserfs_setxattr,
1559 .getxattr = reiserfs_getxattr,
1560 .listxattr = reiserfs_listxattr,
1561 .removexattr = reiserfs_removexattr,
1562 .permission = reiserfs_permission,
1563 .get_acl = reiserfs_get_acl,
1564};
1/*
2 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
3 *
4 * Trivial changes by Alan Cox to remove EHASHCOLLISION for compatibility
5 *
6 * Trivial Changes:
7 * Rights granted to Hans Reiser to redistribute under other terms providing
8 * he accepts all liability including but not limited to patent, fitness
9 * for purpose, and direct or indirect claims arising from failure to perform.
10 *
11 * NO WARRANTY
12 */
13
14#include <linux/time.h>
15#include <linux/bitops.h>
16#include <linux/slab.h>
17#include "reiserfs.h"
18#include "acl.h"
19#include "xattr.h"
20#include <linux/quotaops.h>
21
22#define INC_DIR_INODE_NLINK(i) if (i->i_nlink != 1) { inc_nlink(i); if (i->i_nlink >= REISERFS_LINK_MAX) set_nlink(i, 1); }
23#define DEC_DIR_INODE_NLINK(i) if (i->i_nlink != 1) drop_nlink(i);
24
25/*
26 * directory item contains array of entry headers. This performs
27 * binary search through that array
28 */
29static int bin_search_in_dir_item(struct reiserfs_dir_entry *de, loff_t off)
30{
31 struct item_head *ih = de->de_ih;
32 struct reiserfs_de_head *deh = de->de_deh;
33 int rbound, lbound, j;
34
35 lbound = 0;
36 rbound = ih_entry_count(ih) - 1;
37
38 for (j = (rbound + lbound) / 2; lbound <= rbound;
39 j = (rbound + lbound) / 2) {
40 if (off < deh_offset(deh + j)) {
41 rbound = j - 1;
42 continue;
43 }
44 if (off > deh_offset(deh + j)) {
45 lbound = j + 1;
46 continue;
47 }
48 /* this is not name found, but matched third key component */
49 de->de_entry_num = j;
50 return NAME_FOUND;
51 }
52
53 de->de_entry_num = lbound;
54 return NAME_NOT_FOUND;
55}
56
57/*
58 * comment? maybe something like set de to point to what the path points to?
59 */
60static inline void set_de_item_location(struct reiserfs_dir_entry *de,
61 struct treepath *path)
62{
63 de->de_bh = get_last_bh(path);
64 de->de_ih = tp_item_head(path);
65 de->de_deh = B_I_DEH(de->de_bh, de->de_ih);
66 de->de_item_num = PATH_LAST_POSITION(path);
67}
68
69/*
70 * de_bh, de_ih, de_deh (points to first element of array), de_item_num is set
71 */
72inline void set_de_name_and_namelen(struct reiserfs_dir_entry *de)
73{
74 struct reiserfs_de_head *deh = de->de_deh + de->de_entry_num;
75
76 BUG_ON(de->de_entry_num >= ih_entry_count(de->de_ih));
77
78 de->de_entrylen = entry_length(de->de_bh, de->de_ih, de->de_entry_num);
79 de->de_namelen = de->de_entrylen - (de_with_sd(deh) ? SD_SIZE : 0);
80 de->de_name = ih_item_body(de->de_bh, de->de_ih) + deh_location(deh);
81 if (de->de_name[de->de_namelen - 1] == 0)
82 de->de_namelen = strlen(de->de_name);
83}
84
85/* what entry points to */
86static inline void set_de_object_key(struct reiserfs_dir_entry *de)
87{
88 BUG_ON(de->de_entry_num >= ih_entry_count(de->de_ih));
89 de->de_dir_id = deh_dir_id(&de->de_deh[de->de_entry_num]);
90 de->de_objectid = deh_objectid(&de->de_deh[de->de_entry_num]);
91}
92
93static inline void store_de_entry_key(struct reiserfs_dir_entry *de)
94{
95 struct reiserfs_de_head *deh = de->de_deh + de->de_entry_num;
96
97 BUG_ON(de->de_entry_num >= ih_entry_count(de->de_ih));
98
99 /* store key of the found entry */
100 de->de_entry_key.version = KEY_FORMAT_3_5;
101 de->de_entry_key.on_disk_key.k_dir_id =
102 le32_to_cpu(de->de_ih->ih_key.k_dir_id);
103 de->de_entry_key.on_disk_key.k_objectid =
104 le32_to_cpu(de->de_ih->ih_key.k_objectid);
105 set_cpu_key_k_offset(&de->de_entry_key, deh_offset(deh));
106 set_cpu_key_k_type(&de->de_entry_key, TYPE_DIRENTRY);
107}
108
109/*
110 * We assign a key to each directory item, and place multiple entries in a
111 * single directory item. A directory item has a key equal to the key of
112 * the first directory entry in it.
113
114 * This function first calls search_by_key, then, if item whose first entry
115 * matches is not found it looks for the entry inside directory item found
116 * by search_by_key. Fills the path to the entry, and to the entry position
117 * in the item
118 */
119/* The function is NOT SCHEDULE-SAFE! */
120int search_by_entry_key(struct super_block *sb, const struct cpu_key *key,
121 struct treepath *path, struct reiserfs_dir_entry *de)
122{
123 int retval;
124
125 retval = search_item(sb, key, path);
126 switch (retval) {
127 case ITEM_NOT_FOUND:
128 if (!PATH_LAST_POSITION(path)) {
129 reiserfs_error(sb, "vs-7000", "search_by_key "
130 "returned item position == 0");
131 pathrelse(path);
132 return IO_ERROR;
133 }
134 PATH_LAST_POSITION(path)--;
135
136 case ITEM_FOUND:
137 break;
138
139 case IO_ERROR:
140 return retval;
141
142 default:
143 pathrelse(path);
144 reiserfs_error(sb, "vs-7002", "no path to here");
145 return IO_ERROR;
146 }
147
148 set_de_item_location(de, path);
149
150#ifdef CONFIG_REISERFS_CHECK
151 if (!is_direntry_le_ih(de->de_ih) ||
152 COMP_SHORT_KEYS(&de->de_ih->ih_key, key)) {
153 print_block(de->de_bh, 0, -1, -1);
154 reiserfs_panic(sb, "vs-7005", "found item %h is not directory "
155 "item or does not belong to the same directory "
156 "as key %K", de->de_ih, key);
157 }
158#endif /* CONFIG_REISERFS_CHECK */
159
160 /*
161 * binary search in directory item by third component of the
162 * key. sets de->de_entry_num of de
163 */
164 retval = bin_search_in_dir_item(de, cpu_key_k_offset(key));
165 path->pos_in_item = de->de_entry_num;
166 if (retval != NAME_NOT_FOUND) {
167 /*
168 * ugly, but rename needs de_bh, de_deh, de_name,
169 * de_namelen, de_objectid set
170 */
171 set_de_name_and_namelen(de);
172 set_de_object_key(de);
173 }
174 return retval;
175}
176
177/* Keyed 32-bit hash function using TEA in a Davis-Meyer function */
178
179/*
180 * The third component is hashed, and you can choose from more than
181 * one hash function. Per directory hashes are not yet implemented
182 * but are thought about. This function should be moved to hashes.c
183 * Jedi, please do so. -Hans
184 */
185static __u32 get_third_component(struct super_block *s,
186 const char *name, int len)
187{
188 __u32 res;
189
190 if (!len || (len == 1 && name[0] == '.'))
191 return DOT_OFFSET;
192 if (len == 2 && name[0] == '.' && name[1] == '.')
193 return DOT_DOT_OFFSET;
194
195 res = REISERFS_SB(s)->s_hash_function(name, len);
196
197 /* take bits from 7-th to 30-th including both bounds */
198 res = GET_HASH_VALUE(res);
199 if (res == 0)
200 /*
201 * needed to have no names before "." and ".." those have hash
202 * value == 0 and generation conters 1 and 2 accordingly
203 */
204 res = 128;
205 return res + MAX_GENERATION_NUMBER;
206}
207
208static int reiserfs_match(struct reiserfs_dir_entry *de,
209 const char *name, int namelen)
210{
211 int retval = NAME_NOT_FOUND;
212
213 if ((namelen == de->de_namelen) &&
214 !memcmp(de->de_name, name, de->de_namelen))
215 retval =
216 (de_visible(de->de_deh + de->de_entry_num) ? NAME_FOUND :
217 NAME_FOUND_INVISIBLE);
218
219 return retval;
220}
221
222/* de's de_bh, de_ih, de_deh, de_item_num, de_entry_num are set already */
223
224/* used when hash collisions exist */
225
226static int linear_search_in_dir_item(struct cpu_key *key,
227 struct reiserfs_dir_entry *de,
228 const char *name, int namelen)
229{
230 struct reiserfs_de_head *deh = de->de_deh;
231 int retval;
232 int i;
233
234 i = de->de_entry_num;
235
236 if (i == ih_entry_count(de->de_ih) ||
237 GET_HASH_VALUE(deh_offset(deh + i)) !=
238 GET_HASH_VALUE(cpu_key_k_offset(key))) {
239 i--;
240 }
241
242 RFALSE(de->de_deh != B_I_DEH(de->de_bh, de->de_ih),
243 "vs-7010: array of entry headers not found");
244
245 deh += i;
246
247 for (; i >= 0; i--, deh--) {
248 /* hash value does not match, no need to check whole name */
249 if (GET_HASH_VALUE(deh_offset(deh)) !=
250 GET_HASH_VALUE(cpu_key_k_offset(key))) {
251 return NAME_NOT_FOUND;
252 }
253
254 /* mark that this generation number is used */
255 if (de->de_gen_number_bit_string)
256 set_bit(GET_GENERATION_NUMBER(deh_offset(deh)),
257 de->de_gen_number_bit_string);
258
259 /* calculate pointer to name and namelen */
260 de->de_entry_num = i;
261 set_de_name_and_namelen(de);
262
263 /*
264 * de's de_name, de_namelen, de_recordlen are set.
265 * Fill the rest.
266 */
267 if ((retval =
268 reiserfs_match(de, name, namelen)) != NAME_NOT_FOUND) {
269
270 /* key of pointed object */
271 set_de_object_key(de);
272
273 store_de_entry_key(de);
274
275 /* retval can be NAME_FOUND or NAME_FOUND_INVISIBLE */
276 return retval;
277 }
278 }
279
280 if (GET_GENERATION_NUMBER(le_ih_k_offset(de->de_ih)) == 0)
281 /*
282 * we have reached left most entry in the node. In common we
283 * have to go to the left neighbor, but if generation counter
284 * is 0 already, we know for sure, that there is no name with
285 * the same hash value
286 */
287 /*
288 * FIXME: this work correctly only because hash value can not
289 * be 0. Btw, in case of Yura's hash it is probably possible,
290 * so, this is a bug
291 */
292 return NAME_NOT_FOUND;
293
294 RFALSE(de->de_item_num,
295 "vs-7015: two diritems of the same directory in one node?");
296
297 return GOTO_PREVIOUS_ITEM;
298}
299
300/*
301 * may return NAME_FOUND, NAME_FOUND_INVISIBLE, NAME_NOT_FOUND
302 * FIXME: should add something like IOERROR
303 */
304static int reiserfs_find_entry(struct inode *dir, const char *name, int namelen,
305 struct treepath *path_to_entry,
306 struct reiserfs_dir_entry *de)
307{
308 struct cpu_key key_to_search;
309 int retval;
310
311 if (namelen > REISERFS_MAX_NAME(dir->i_sb->s_blocksize))
312 return NAME_NOT_FOUND;
313
314 /* we will search for this key in the tree */
315 make_cpu_key(&key_to_search, dir,
316 get_third_component(dir->i_sb, name, namelen),
317 TYPE_DIRENTRY, 3);
318
319 while (1) {
320 retval =
321 search_by_entry_key(dir->i_sb, &key_to_search,
322 path_to_entry, de);
323 if (retval == IO_ERROR) {
324 reiserfs_error(dir->i_sb, "zam-7001", "io error");
325 return IO_ERROR;
326 }
327
328 /* compare names for all entries having given hash value */
329 retval =
330 linear_search_in_dir_item(&key_to_search, de, name,
331 namelen);
332 /*
333 * there is no need to scan directory anymore.
334 * Given entry found or does not exist
335 */
336 if (retval != GOTO_PREVIOUS_ITEM) {
337 path_to_entry->pos_in_item = de->de_entry_num;
338 return retval;
339 }
340
341 /*
342 * there is left neighboring item of this directory
343 * and given entry can be there
344 */
345 set_cpu_key_k_offset(&key_to_search,
346 le_ih_k_offset(de->de_ih) - 1);
347 pathrelse(path_to_entry);
348
349 } /* while (1) */
350}
351
352static struct dentry *reiserfs_lookup(struct inode *dir, struct dentry *dentry,
353 unsigned int flags)
354{
355 int retval;
356 struct inode *inode = NULL;
357 struct reiserfs_dir_entry de;
358 INITIALIZE_PATH(path_to_entry);
359
360 if (REISERFS_MAX_NAME(dir->i_sb->s_blocksize) < dentry->d_name.len)
361 return ERR_PTR(-ENAMETOOLONG);
362
363 reiserfs_write_lock(dir->i_sb);
364
365 de.de_gen_number_bit_string = NULL;
366 retval =
367 reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len,
368 &path_to_entry, &de);
369 pathrelse(&path_to_entry);
370 if (retval == NAME_FOUND) {
371 inode = reiserfs_iget(dir->i_sb,
372 (struct cpu_key *)&de.de_dir_id);
373 if (!inode || IS_ERR(inode)) {
374 reiserfs_write_unlock(dir->i_sb);
375 return ERR_PTR(-EACCES);
376 }
377
378 /*
379 * Propagate the private flag so we know we're
380 * in the priv tree
381 */
382 if (IS_PRIVATE(dir))
383 inode->i_flags |= S_PRIVATE;
384 }
385 reiserfs_write_unlock(dir->i_sb);
386 if (retval == IO_ERROR) {
387 return ERR_PTR(-EIO);
388 }
389
390 return d_splice_alias(inode, dentry);
391}
392
393/*
394 * looks up the dentry of the parent directory for child.
395 * taken from ext2_get_parent
396 */
397struct dentry *reiserfs_get_parent(struct dentry *child)
398{
399 int retval;
400 struct inode *inode = NULL;
401 struct reiserfs_dir_entry de;
402 INITIALIZE_PATH(path_to_entry);
403 struct inode *dir = d_inode(child);
404
405 if (dir->i_nlink == 0) {
406 return ERR_PTR(-ENOENT);
407 }
408 de.de_gen_number_bit_string = NULL;
409
410 reiserfs_write_lock(dir->i_sb);
411 retval = reiserfs_find_entry(dir, "..", 2, &path_to_entry, &de);
412 pathrelse(&path_to_entry);
413 if (retval != NAME_FOUND) {
414 reiserfs_write_unlock(dir->i_sb);
415 return ERR_PTR(-ENOENT);
416 }
417 inode = reiserfs_iget(dir->i_sb, (struct cpu_key *)&de.de_dir_id);
418 reiserfs_write_unlock(dir->i_sb);
419
420 return d_obtain_alias(inode);
421}
422
423/* add entry to the directory (entry can be hidden).
424
425insert definition of when hidden directories are used here -Hans
426
427 Does not mark dir inode dirty, do it after successesfull call to it */
428
429static int reiserfs_add_entry(struct reiserfs_transaction_handle *th,
430 struct inode *dir, const char *name, int namelen,
431 struct inode *inode, int visible)
432{
433 struct cpu_key entry_key;
434 struct reiserfs_de_head *deh;
435 INITIALIZE_PATH(path);
436 struct reiserfs_dir_entry de;
437 DECLARE_BITMAP(bit_string, MAX_GENERATION_NUMBER + 1);
438 int gen_number;
439
440 /*
441 * 48 bytes now and we avoid kmalloc if we
442 * create file with short name
443 */
444 char small_buf[32 + DEH_SIZE];
445
446 char *buffer;
447 int buflen, paste_size;
448 int retval;
449
450 BUG_ON(!th->t_trans_id);
451
452 /* cannot allow items to be added into a busy deleted directory */
453 if (!namelen)
454 return -EINVAL;
455
456 if (namelen > REISERFS_MAX_NAME(dir->i_sb->s_blocksize))
457 return -ENAMETOOLONG;
458
459 /* each entry has unique key. compose it */
460 make_cpu_key(&entry_key, dir,
461 get_third_component(dir->i_sb, name, namelen),
462 TYPE_DIRENTRY, 3);
463
464 /* get memory for composing the entry */
465 buflen = DEH_SIZE + ROUND_UP(namelen);
466 if (buflen > sizeof(small_buf)) {
467 buffer = kmalloc(buflen, GFP_NOFS);
468 if (!buffer)
469 return -ENOMEM;
470 } else
471 buffer = small_buf;
472
473 paste_size =
474 (get_inode_sd_version(dir) ==
475 STAT_DATA_V1) ? (DEH_SIZE + namelen) : buflen;
476
477 /*
478 * fill buffer : directory entry head, name[, dir objectid | ,
479 * stat data | ,stat data, dir objectid ]
480 */
481 deh = (struct reiserfs_de_head *)buffer;
482 deh->deh_location = 0; /* JDM Endian safe if 0 */
483 put_deh_offset(deh, cpu_key_k_offset(&entry_key));
484 deh->deh_state = 0; /* JDM Endian safe if 0 */
485 /* put key (ino analog) to de */
486
487 /* safe: k_dir_id is le */
488 deh->deh_dir_id = INODE_PKEY(inode)->k_dir_id;
489 /* safe: k_objectid is le */
490 deh->deh_objectid = INODE_PKEY(inode)->k_objectid;
491
492 /* copy name */
493 memcpy((char *)(deh + 1), name, namelen);
494 /* padd by 0s to the 4 byte boundary */
495 padd_item((char *)(deh + 1), ROUND_UP(namelen), namelen);
496
497 /*
498 * entry is ready to be pasted into tree, set 'visibility'
499 * and 'stat data in entry' attributes
500 */
501 mark_de_without_sd(deh);
502 visible ? mark_de_visible(deh) : mark_de_hidden(deh);
503
504 /* find the proper place for the new entry */
505 memset(bit_string, 0, sizeof(bit_string));
506 de.de_gen_number_bit_string = bit_string;
507 retval = reiserfs_find_entry(dir, name, namelen, &path, &de);
508 if (retval != NAME_NOT_FOUND) {
509 if (buffer != small_buf)
510 kfree(buffer);
511 pathrelse(&path);
512
513 if (retval == IO_ERROR) {
514 return -EIO;
515 }
516
517 if (retval != NAME_FOUND) {
518 reiserfs_error(dir->i_sb, "zam-7002",
519 "reiserfs_find_entry() returned "
520 "unexpected value (%d)", retval);
521 }
522
523 return -EEXIST;
524 }
525
526 gen_number =
527 find_first_zero_bit(bit_string,
528 MAX_GENERATION_NUMBER + 1);
529 if (gen_number > MAX_GENERATION_NUMBER) {
530 /* there is no free generation number */
531 reiserfs_warning(dir->i_sb, "reiserfs-7010",
532 "Congratulations! we have got hash function "
533 "screwed up");
534 if (buffer != small_buf)
535 kfree(buffer);
536 pathrelse(&path);
537 return -EBUSY;
538 }
539 /* adjust offset of directory enrty */
540 put_deh_offset(deh, SET_GENERATION_NUMBER(deh_offset(deh), gen_number));
541 set_cpu_key_k_offset(&entry_key, deh_offset(deh));
542
543 /* update max-hash-collisions counter in reiserfs_sb_info */
544 PROC_INFO_MAX(th->t_super, max_hash_collisions, gen_number);
545
546 /* we need to re-search for the insertion point */
547 if (gen_number != 0) {
548 if (search_by_entry_key(dir->i_sb, &entry_key, &path, &de) !=
549 NAME_NOT_FOUND) {
550 reiserfs_warning(dir->i_sb, "vs-7032",
551 "entry with this key (%K) already "
552 "exists", &entry_key);
553
554 if (buffer != small_buf)
555 kfree(buffer);
556 pathrelse(&path);
557 return -EBUSY;
558 }
559 }
560
561 /* perform the insertion of the entry that we have prepared */
562 retval =
563 reiserfs_paste_into_item(th, &path, &entry_key, dir, buffer,
564 paste_size);
565 if (buffer != small_buf)
566 kfree(buffer);
567 if (retval) {
568 reiserfs_check_path(&path);
569 return retval;
570 }
571
572 dir->i_size += paste_size;
573 dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
574 if (!S_ISDIR(inode->i_mode) && visible)
575 /* reiserfs_mkdir or reiserfs_rename will do that by itself */
576 reiserfs_update_sd(th, dir);
577
578 reiserfs_check_path(&path);
579 return 0;
580}
581
582/*
583 * quota utility function, call if you've had to abort after calling
584 * new_inode_init, and have not called reiserfs_new_inode yet.
585 * This should only be called on inodes that do not have stat data
586 * inserted into the tree yet.
587 */
588static int drop_new_inode(struct inode *inode)
589{
590 dquot_drop(inode);
591 make_bad_inode(inode);
592 inode->i_flags |= S_NOQUOTA;
593 iput(inode);
594 return 0;
595}
596
597/*
598 * utility function that does setup for reiserfs_new_inode.
599 * dquot_initialize needs lots of credits so it's better to have it
600 * outside of a transaction, so we had to pull some bits of
601 * reiserfs_new_inode out into this func.
602 */
603static int new_inode_init(struct inode *inode, struct inode *dir, umode_t mode)
604{
605 /*
606 * Make inode invalid - just in case we are going to drop it before
607 * the initialization happens
608 */
609 INODE_PKEY(inode)->k_objectid = 0;
610
611 /*
612 * the quota init calls have to know who to charge the quota to, so
613 * we have to set uid and gid here
614 */
615 inode_init_owner(inode, dir, mode);
616 return dquot_initialize(inode);
617}
618
619static int reiserfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
620 bool excl)
621{
622 int retval;
623 struct inode *inode;
624 /*
625 * We need blocks for transaction + (user+group)*(quotas
626 * for new inode + update of quota for directory owner)
627 */
628 int jbegin_count =
629 JOURNAL_PER_BALANCE_CNT * 2 +
630 2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
631 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
632 struct reiserfs_transaction_handle th;
633 struct reiserfs_security_handle security;
634
635 retval = dquot_initialize(dir);
636 if (retval)
637 return retval;
638
639 if (!(inode = new_inode(dir->i_sb))) {
640 return -ENOMEM;
641 }
642 retval = new_inode_init(inode, dir, mode);
643 if (retval) {
644 drop_new_inode(inode);
645 return retval;
646 }
647
648 jbegin_count += reiserfs_cache_default_acl(dir);
649 retval = reiserfs_security_init(dir, inode, &dentry->d_name, &security);
650 if (retval < 0) {
651 drop_new_inode(inode);
652 return retval;
653 }
654 jbegin_count += retval;
655 reiserfs_write_lock(dir->i_sb);
656
657 retval = journal_begin(&th, dir->i_sb, jbegin_count);
658 if (retval) {
659 drop_new_inode(inode);
660 goto out_failed;
661 }
662
663 retval =
664 reiserfs_new_inode(&th, dir, mode, NULL, 0 /*i_size */ , dentry,
665 inode, &security);
666 if (retval)
667 goto out_failed;
668
669 inode->i_op = &reiserfs_file_inode_operations;
670 inode->i_fop = &reiserfs_file_operations;
671 inode->i_mapping->a_ops = &reiserfs_address_space_operations;
672
673 retval =
674 reiserfs_add_entry(&th, dir, dentry->d_name.name,
675 dentry->d_name.len, inode, 1 /*visible */ );
676 if (retval) {
677 int err;
678 drop_nlink(inode);
679 reiserfs_update_sd(&th, inode);
680 err = journal_end(&th);
681 if (err)
682 retval = err;
683 unlock_new_inode(inode);
684 iput(inode);
685 goto out_failed;
686 }
687 reiserfs_update_inode_transaction(inode);
688 reiserfs_update_inode_transaction(dir);
689
690 unlock_new_inode(inode);
691 d_instantiate(dentry, inode);
692 retval = journal_end(&th);
693
694out_failed:
695 reiserfs_write_unlock(dir->i_sb);
696 return retval;
697}
698
699static int reiserfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
700 dev_t rdev)
701{
702 int retval;
703 struct inode *inode;
704 struct reiserfs_transaction_handle th;
705 struct reiserfs_security_handle security;
706 /*
707 * We need blocks for transaction + (user+group)*(quotas
708 * for new inode + update of quota for directory owner)
709 */
710 int jbegin_count =
711 JOURNAL_PER_BALANCE_CNT * 3 +
712 2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
713 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
714
715 retval = dquot_initialize(dir);
716 if (retval)
717 return retval;
718
719 if (!(inode = new_inode(dir->i_sb))) {
720 return -ENOMEM;
721 }
722 retval = new_inode_init(inode, dir, mode);
723 if (retval) {
724 drop_new_inode(inode);
725 return retval;
726 }
727
728 jbegin_count += reiserfs_cache_default_acl(dir);
729 retval = reiserfs_security_init(dir, inode, &dentry->d_name, &security);
730 if (retval < 0) {
731 drop_new_inode(inode);
732 return retval;
733 }
734 jbegin_count += retval;
735 reiserfs_write_lock(dir->i_sb);
736
737 retval = journal_begin(&th, dir->i_sb, jbegin_count);
738 if (retval) {
739 drop_new_inode(inode);
740 goto out_failed;
741 }
742
743 retval =
744 reiserfs_new_inode(&th, dir, mode, NULL, 0 /*i_size */ , dentry,
745 inode, &security);
746 if (retval) {
747 goto out_failed;
748 }
749
750 inode->i_op = &reiserfs_special_inode_operations;
751 init_special_inode(inode, inode->i_mode, rdev);
752
753 /* FIXME: needed for block and char devices only */
754 reiserfs_update_sd(&th, inode);
755
756 reiserfs_update_inode_transaction(inode);
757 reiserfs_update_inode_transaction(dir);
758
759 retval =
760 reiserfs_add_entry(&th, dir, dentry->d_name.name,
761 dentry->d_name.len, inode, 1 /*visible */ );
762 if (retval) {
763 int err;
764 drop_nlink(inode);
765 reiserfs_update_sd(&th, inode);
766 err = journal_end(&th);
767 if (err)
768 retval = err;
769 unlock_new_inode(inode);
770 iput(inode);
771 goto out_failed;
772 }
773
774 unlock_new_inode(inode);
775 d_instantiate(dentry, inode);
776 retval = journal_end(&th);
777
778out_failed:
779 reiserfs_write_unlock(dir->i_sb);
780 return retval;
781}
782
783static int reiserfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
784{
785 int retval;
786 struct inode *inode;
787 struct reiserfs_transaction_handle th;
788 struct reiserfs_security_handle security;
789 /*
790 * We need blocks for transaction + (user+group)*(quotas
791 * for new inode + update of quota for directory owner)
792 */
793 int jbegin_count =
794 JOURNAL_PER_BALANCE_CNT * 3 +
795 2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
796 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
797
798 retval = dquot_initialize(dir);
799 if (retval)
800 return retval;
801
802#ifdef DISPLACE_NEW_PACKING_LOCALITIES
803 /*
804 * set flag that new packing locality created and new blocks
805 * for the content of that directory are not displaced yet
806 */
807 REISERFS_I(dir)->new_packing_locality = 1;
808#endif
809 mode = S_IFDIR | mode;
810 if (!(inode = new_inode(dir->i_sb))) {
811 return -ENOMEM;
812 }
813 retval = new_inode_init(inode, dir, mode);
814 if (retval) {
815 drop_new_inode(inode);
816 return retval;
817 }
818
819 jbegin_count += reiserfs_cache_default_acl(dir);
820 retval = reiserfs_security_init(dir, inode, &dentry->d_name, &security);
821 if (retval < 0) {
822 drop_new_inode(inode);
823 return retval;
824 }
825 jbegin_count += retval;
826 reiserfs_write_lock(dir->i_sb);
827
828 retval = journal_begin(&th, dir->i_sb, jbegin_count);
829 if (retval) {
830 drop_new_inode(inode);
831 goto out_failed;
832 }
833
834 /*
835 * inc the link count now, so another writer doesn't overflow
836 * it while we sleep later on.
837 */
838 INC_DIR_INODE_NLINK(dir)
839
840 retval = reiserfs_new_inode(&th, dir, mode, NULL /*symlink */ ,
841 old_format_only(dir->i_sb) ?
842 EMPTY_DIR_SIZE_V1 : EMPTY_DIR_SIZE,
843 dentry, inode, &security);
844 if (retval) {
845 DEC_DIR_INODE_NLINK(dir)
846 goto out_failed;
847 }
848
849 reiserfs_update_inode_transaction(inode);
850 reiserfs_update_inode_transaction(dir);
851
852 inode->i_op = &reiserfs_dir_inode_operations;
853 inode->i_fop = &reiserfs_dir_operations;
854
855 /* note, _this_ add_entry will not update dir's stat data */
856 retval =
857 reiserfs_add_entry(&th, dir, dentry->d_name.name,
858 dentry->d_name.len, inode, 1 /*visible */ );
859 if (retval) {
860 int err;
861 clear_nlink(inode);
862 DEC_DIR_INODE_NLINK(dir);
863 reiserfs_update_sd(&th, inode);
864 err = journal_end(&th);
865 if (err)
866 retval = err;
867 unlock_new_inode(inode);
868 iput(inode);
869 goto out_failed;
870 }
871 /* the above add_entry did not update dir's stat data */
872 reiserfs_update_sd(&th, dir);
873
874 unlock_new_inode(inode);
875 d_instantiate(dentry, inode);
876 retval = journal_end(&th);
877out_failed:
878 reiserfs_write_unlock(dir->i_sb);
879 return retval;
880}
881
882static inline int reiserfs_empty_dir(struct inode *inode)
883{
884 /*
885 * we can cheat because an old format dir cannot have
886 * EMPTY_DIR_SIZE, and a new format dir cannot have
887 * EMPTY_DIR_SIZE_V1. So, if the inode is either size,
888 * regardless of disk format version, the directory is empty.
889 */
890 if (inode->i_size != EMPTY_DIR_SIZE &&
891 inode->i_size != EMPTY_DIR_SIZE_V1) {
892 return 0;
893 }
894 return 1;
895}
896
897static int reiserfs_rmdir(struct inode *dir, struct dentry *dentry)
898{
899 int retval, err;
900 struct inode *inode;
901 struct reiserfs_transaction_handle th;
902 int jbegin_count;
903 INITIALIZE_PATH(path);
904 struct reiserfs_dir_entry de;
905
906 /*
907 * we will be doing 2 balancings and update 2 stat data, we
908 * change quotas of the owner of the directory and of the owner
909 * of the parent directory. The quota structure is possibly
910 * deleted only on last iput => outside of this transaction
911 */
912 jbegin_count =
913 JOURNAL_PER_BALANCE_CNT * 2 + 2 +
914 4 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);
915
916 retval = dquot_initialize(dir);
917 if (retval)
918 return retval;
919
920 reiserfs_write_lock(dir->i_sb);
921 retval = journal_begin(&th, dir->i_sb, jbegin_count);
922 if (retval)
923 goto out_rmdir;
924
925 de.de_gen_number_bit_string = NULL;
926 if ((retval =
927 reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len,
928 &path, &de)) == NAME_NOT_FOUND) {
929 retval = -ENOENT;
930 goto end_rmdir;
931 } else if (retval == IO_ERROR) {
932 retval = -EIO;
933 goto end_rmdir;
934 }
935
936 inode = d_inode(dentry);
937
938 reiserfs_update_inode_transaction(inode);
939 reiserfs_update_inode_transaction(dir);
940
941 if (de.de_objectid != inode->i_ino) {
942 /*
943 * FIXME: compare key of an object and a key found in the entry
944 */
945 retval = -EIO;
946 goto end_rmdir;
947 }
948 if (!reiserfs_empty_dir(inode)) {
949 retval = -ENOTEMPTY;
950 goto end_rmdir;
951 }
952
953 /* cut entry from dir directory */
954 retval = reiserfs_cut_from_item(&th, &path, &de.de_entry_key,
955 dir, NULL, /* page */
956 0 /*new file size - not used here */ );
957 if (retval < 0)
958 goto end_rmdir;
959
960 if (inode->i_nlink != 2 && inode->i_nlink != 1)
961 reiserfs_error(inode->i_sb, "reiserfs-7040",
962 "empty directory has nlink != 2 (%d)",
963 inode->i_nlink);
964
965 clear_nlink(inode);
966 inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME_SEC;
967 reiserfs_update_sd(&th, inode);
968
969 DEC_DIR_INODE_NLINK(dir)
970 dir->i_size -= (DEH_SIZE + de.de_entrylen);
971 reiserfs_update_sd(&th, dir);
972
973 /* prevent empty directory from getting lost */
974 add_save_link(&th, inode, 0 /* not truncate */ );
975
976 retval = journal_end(&th);
977 reiserfs_check_path(&path);
978out_rmdir:
979 reiserfs_write_unlock(dir->i_sb);
980 return retval;
981
982end_rmdir:
983 /*
984 * we must release path, because we did not call
985 * reiserfs_cut_from_item, or reiserfs_cut_from_item does not
986 * release path if operation was not complete
987 */
988 pathrelse(&path);
989 err = journal_end(&th);
990 reiserfs_write_unlock(dir->i_sb);
991 return err ? err : retval;
992}
993
994static int reiserfs_unlink(struct inode *dir, struct dentry *dentry)
995{
996 int retval, err;
997 struct inode *inode;
998 struct reiserfs_dir_entry de;
999 INITIALIZE_PATH(path);
1000 struct reiserfs_transaction_handle th;
1001 int jbegin_count;
1002 unsigned long savelink;
1003
1004 retval = dquot_initialize(dir);
1005 if (retval)
1006 return retval;
1007
1008 inode = d_inode(dentry);
1009
1010 /*
1011 * in this transaction we can be doing at max two balancings and
1012 * update two stat datas, we change quotas of the owner of the
1013 * directory and of the owner of the parent directory. The quota
1014 * structure is possibly deleted only on iput => outside of
1015 * this transaction
1016 */
1017 jbegin_count =
1018 JOURNAL_PER_BALANCE_CNT * 2 + 2 +
1019 4 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);
1020
1021 reiserfs_write_lock(dir->i_sb);
1022 retval = journal_begin(&th, dir->i_sb, jbegin_count);
1023 if (retval)
1024 goto out_unlink;
1025
1026 de.de_gen_number_bit_string = NULL;
1027 if ((retval =
1028 reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len,
1029 &path, &de)) == NAME_NOT_FOUND) {
1030 retval = -ENOENT;
1031 goto end_unlink;
1032 } else if (retval == IO_ERROR) {
1033 retval = -EIO;
1034 goto end_unlink;
1035 }
1036
1037 reiserfs_update_inode_transaction(inode);
1038 reiserfs_update_inode_transaction(dir);
1039
1040 if (de.de_objectid != inode->i_ino) {
1041 /*
1042 * FIXME: compare key of an object and a key found in the entry
1043 */
1044 retval = -EIO;
1045 goto end_unlink;
1046 }
1047
1048 if (!inode->i_nlink) {
1049 reiserfs_warning(inode->i_sb, "reiserfs-7042",
1050 "deleting nonexistent file (%lu), %d",
1051 inode->i_ino, inode->i_nlink);
1052 set_nlink(inode, 1);
1053 }
1054
1055 drop_nlink(inode);
1056
1057 /*
1058 * we schedule before doing the add_save_link call, save the link
1059 * count so we don't race
1060 */
1061 savelink = inode->i_nlink;
1062
1063 retval =
1064 reiserfs_cut_from_item(&th, &path, &de.de_entry_key, dir, NULL,
1065 0);
1066 if (retval < 0) {
1067 inc_nlink(inode);
1068 goto end_unlink;
1069 }
1070 inode->i_ctime = CURRENT_TIME_SEC;
1071 reiserfs_update_sd(&th, inode);
1072
1073 dir->i_size -= (de.de_entrylen + DEH_SIZE);
1074 dir->i_ctime = dir->i_mtime = CURRENT_TIME_SEC;
1075 reiserfs_update_sd(&th, dir);
1076
1077 if (!savelink)
1078 /* prevent file from getting lost */
1079 add_save_link(&th, inode, 0 /* not truncate */ );
1080
1081 retval = journal_end(&th);
1082 reiserfs_check_path(&path);
1083 reiserfs_write_unlock(dir->i_sb);
1084 return retval;
1085
1086end_unlink:
1087 pathrelse(&path);
1088 err = journal_end(&th);
1089 reiserfs_check_path(&path);
1090 if (err)
1091 retval = err;
1092out_unlink:
1093 reiserfs_write_unlock(dir->i_sb);
1094 return retval;
1095}
1096
1097static int reiserfs_symlink(struct inode *parent_dir,
1098 struct dentry *dentry, const char *symname)
1099{
1100 int retval;
1101 struct inode *inode;
1102 char *name;
1103 int item_len;
1104 struct reiserfs_transaction_handle th;
1105 struct reiserfs_security_handle security;
1106 int mode = S_IFLNK | S_IRWXUGO;
1107 /*
1108 * We need blocks for transaction + (user+group)*(quotas for
1109 * new inode + update of quota for directory owner)
1110 */
1111 int jbegin_count =
1112 JOURNAL_PER_BALANCE_CNT * 3 +
1113 2 * (REISERFS_QUOTA_INIT_BLOCKS(parent_dir->i_sb) +
1114 REISERFS_QUOTA_TRANS_BLOCKS(parent_dir->i_sb));
1115
1116 retval = dquot_initialize(parent_dir);
1117 if (retval)
1118 return retval;
1119
1120 if (!(inode = new_inode(parent_dir->i_sb))) {
1121 return -ENOMEM;
1122 }
1123 retval = new_inode_init(inode, parent_dir, mode);
1124 if (retval) {
1125 drop_new_inode(inode);
1126 return retval;
1127 }
1128
1129 retval = reiserfs_security_init(parent_dir, inode, &dentry->d_name,
1130 &security);
1131 if (retval < 0) {
1132 drop_new_inode(inode);
1133 return retval;
1134 }
1135 jbegin_count += retval;
1136
1137 reiserfs_write_lock(parent_dir->i_sb);
1138 item_len = ROUND_UP(strlen(symname));
1139 if (item_len > MAX_DIRECT_ITEM_LEN(parent_dir->i_sb->s_blocksize)) {
1140 retval = -ENAMETOOLONG;
1141 drop_new_inode(inode);
1142 goto out_failed;
1143 }
1144
1145 name = kmalloc(item_len, GFP_NOFS);
1146 if (!name) {
1147 drop_new_inode(inode);
1148 retval = -ENOMEM;
1149 goto out_failed;
1150 }
1151 memcpy(name, symname, strlen(symname));
1152 padd_item(name, item_len, strlen(symname));
1153
1154 retval = journal_begin(&th, parent_dir->i_sb, jbegin_count);
1155 if (retval) {
1156 drop_new_inode(inode);
1157 kfree(name);
1158 goto out_failed;
1159 }
1160
1161 retval =
1162 reiserfs_new_inode(&th, parent_dir, mode, name, strlen(symname),
1163 dentry, inode, &security);
1164 kfree(name);
1165 if (retval) { /* reiserfs_new_inode iputs for us */
1166 goto out_failed;
1167 }
1168
1169 reiserfs_update_inode_transaction(inode);
1170 reiserfs_update_inode_transaction(parent_dir);
1171
1172 inode->i_op = &reiserfs_symlink_inode_operations;
1173 inode_nohighmem(inode);
1174 inode->i_mapping->a_ops = &reiserfs_address_space_operations;
1175
1176 retval = reiserfs_add_entry(&th, parent_dir, dentry->d_name.name,
1177 dentry->d_name.len, inode, 1 /*visible */ );
1178 if (retval) {
1179 int err;
1180 drop_nlink(inode);
1181 reiserfs_update_sd(&th, inode);
1182 err = journal_end(&th);
1183 if (err)
1184 retval = err;
1185 unlock_new_inode(inode);
1186 iput(inode);
1187 goto out_failed;
1188 }
1189
1190 unlock_new_inode(inode);
1191 d_instantiate(dentry, inode);
1192 retval = journal_end(&th);
1193out_failed:
1194 reiserfs_write_unlock(parent_dir->i_sb);
1195 return retval;
1196}
1197
1198static int reiserfs_link(struct dentry *old_dentry, struct inode *dir,
1199 struct dentry *dentry)
1200{
1201 int retval;
1202 struct inode *inode = d_inode(old_dentry);
1203 struct reiserfs_transaction_handle th;
1204 /*
1205 * We need blocks for transaction + update of quotas for
1206 * the owners of the directory
1207 */
1208 int jbegin_count =
1209 JOURNAL_PER_BALANCE_CNT * 3 +
1210 2 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);
1211
1212 retval = dquot_initialize(dir);
1213 if (retval)
1214 return retval;
1215
1216 reiserfs_write_lock(dir->i_sb);
1217 if (inode->i_nlink >= REISERFS_LINK_MAX) {
1218 /* FIXME: sd_nlink is 32 bit for new files */
1219 reiserfs_write_unlock(dir->i_sb);
1220 return -EMLINK;
1221 }
1222
1223 /* inc before scheduling so reiserfs_unlink knows we are here */
1224 inc_nlink(inode);
1225
1226 retval = journal_begin(&th, dir->i_sb, jbegin_count);
1227 if (retval) {
1228 drop_nlink(inode);
1229 reiserfs_write_unlock(dir->i_sb);
1230 return retval;
1231 }
1232
1233 /* create new entry */
1234 retval =
1235 reiserfs_add_entry(&th, dir, dentry->d_name.name,
1236 dentry->d_name.len, inode, 1 /*visible */ );
1237
1238 reiserfs_update_inode_transaction(inode);
1239 reiserfs_update_inode_transaction(dir);
1240
1241 if (retval) {
1242 int err;
1243 drop_nlink(inode);
1244 err = journal_end(&th);
1245 reiserfs_write_unlock(dir->i_sb);
1246 return err ? err : retval;
1247 }
1248
1249 inode->i_ctime = CURRENT_TIME_SEC;
1250 reiserfs_update_sd(&th, inode);
1251
1252 ihold(inode);
1253 d_instantiate(dentry, inode);
1254 retval = journal_end(&th);
1255 reiserfs_write_unlock(dir->i_sb);
1256 return retval;
1257}
1258
1259/* de contains information pointing to an entry which */
1260static int de_still_valid(const char *name, int len,
1261 struct reiserfs_dir_entry *de)
1262{
1263 struct reiserfs_dir_entry tmp = *de;
1264
1265 /* recalculate pointer to name and name length */
1266 set_de_name_and_namelen(&tmp);
1267 /* FIXME: could check more */
1268 if (tmp.de_namelen != len || memcmp(name, de->de_name, len))
1269 return 0;
1270 return 1;
1271}
1272
1273static int entry_points_to_object(const char *name, int len,
1274 struct reiserfs_dir_entry *de,
1275 struct inode *inode)
1276{
1277 if (!de_still_valid(name, len, de))
1278 return 0;
1279
1280 if (inode) {
1281 if (!de_visible(de->de_deh + de->de_entry_num))
1282 reiserfs_panic(inode->i_sb, "vs-7042",
1283 "entry must be visible");
1284 return (de->de_objectid == inode->i_ino) ? 1 : 0;
1285 }
1286
1287 /* this must be added hidden entry */
1288 if (de_visible(de->de_deh + de->de_entry_num))
1289 reiserfs_panic(NULL, "vs-7043", "entry must be visible");
1290
1291 return 1;
1292}
1293
1294/* sets key of objectid the entry has to point to */
1295static void set_ino_in_dir_entry(struct reiserfs_dir_entry *de,
1296 struct reiserfs_key *key)
1297{
1298 /* JDM These operations are endian safe - both are le */
1299 de->de_deh[de->de_entry_num].deh_dir_id = key->k_dir_id;
1300 de->de_deh[de->de_entry_num].deh_objectid = key->k_objectid;
1301}
1302
1303/*
1304 * process, that is going to call fix_nodes/do_balance must hold only
1305 * one path. If it holds 2 or more, it can get into endless waiting in
1306 * get_empty_nodes or its clones
1307 */
1308static int reiserfs_rename(struct inode *old_dir, struct dentry *old_dentry,
1309 struct inode *new_dir, struct dentry *new_dentry)
1310{
1311 int retval;
1312 INITIALIZE_PATH(old_entry_path);
1313 INITIALIZE_PATH(new_entry_path);
1314 INITIALIZE_PATH(dot_dot_entry_path);
1315 struct item_head new_entry_ih, old_entry_ih, dot_dot_ih;
1316 struct reiserfs_dir_entry old_de, new_de, dot_dot_de;
1317 struct inode *old_inode, *new_dentry_inode;
1318 struct reiserfs_transaction_handle th;
1319 int jbegin_count;
1320 umode_t old_inode_mode;
1321 unsigned long savelink = 1;
1322 struct timespec ctime;
1323
1324 /*
1325 * three balancings: (1) old name removal, (2) new name insertion
1326 * and (3) maybe "save" link insertion
1327 * stat data updates: (1) old directory,
1328 * (2) new directory and (3) maybe old object stat data (when it is
1329 * directory) and (4) maybe stat data of object to which new entry
1330 * pointed initially and (5) maybe block containing ".." of
1331 * renamed directory
1332 * quota updates: two parent directories
1333 */
1334 jbegin_count =
1335 JOURNAL_PER_BALANCE_CNT * 3 + 5 +
1336 4 * REISERFS_QUOTA_TRANS_BLOCKS(old_dir->i_sb);
1337
1338 retval = dquot_initialize(old_dir);
1339 if (retval)
1340 return retval;
1341 retval = dquot_initialize(new_dir);
1342 if (retval)
1343 return retval;
1344
1345 old_inode = d_inode(old_dentry);
1346 new_dentry_inode = d_inode(new_dentry);
1347
1348 /*
1349 * make sure that oldname still exists and points to an object we
1350 * are going to rename
1351 */
1352 old_de.de_gen_number_bit_string = NULL;
1353 reiserfs_write_lock(old_dir->i_sb);
1354 retval =
1355 reiserfs_find_entry(old_dir, old_dentry->d_name.name,
1356 old_dentry->d_name.len, &old_entry_path,
1357 &old_de);
1358 pathrelse(&old_entry_path);
1359 if (retval == IO_ERROR) {
1360 reiserfs_write_unlock(old_dir->i_sb);
1361 return -EIO;
1362 }
1363
1364 if (retval != NAME_FOUND || old_de.de_objectid != old_inode->i_ino) {
1365 reiserfs_write_unlock(old_dir->i_sb);
1366 return -ENOENT;
1367 }
1368
1369 old_inode_mode = old_inode->i_mode;
1370 if (S_ISDIR(old_inode_mode)) {
1371 /*
1372 * make sure that directory being renamed has correct ".."
1373 * and that its new parent directory has not too many links
1374 * already
1375 */
1376 if (new_dentry_inode) {
1377 if (!reiserfs_empty_dir(new_dentry_inode)) {
1378 reiserfs_write_unlock(old_dir->i_sb);
1379 return -ENOTEMPTY;
1380 }
1381 }
1382
1383 /*
1384 * directory is renamed, its parent directory will be changed,
1385 * so find ".." entry
1386 */
1387 dot_dot_de.de_gen_number_bit_string = NULL;
1388 retval =
1389 reiserfs_find_entry(old_inode, "..", 2, &dot_dot_entry_path,
1390 &dot_dot_de);
1391 pathrelse(&dot_dot_entry_path);
1392 if (retval != NAME_FOUND) {
1393 reiserfs_write_unlock(old_dir->i_sb);
1394 return -EIO;
1395 }
1396
1397 /* inode number of .. must equal old_dir->i_ino */
1398 if (dot_dot_de.de_objectid != old_dir->i_ino) {
1399 reiserfs_write_unlock(old_dir->i_sb);
1400 return -EIO;
1401 }
1402 }
1403
1404 retval = journal_begin(&th, old_dir->i_sb, jbegin_count);
1405 if (retval) {
1406 reiserfs_write_unlock(old_dir->i_sb);
1407 return retval;
1408 }
1409
1410 /* add new entry (or find the existing one) */
1411 retval =
1412 reiserfs_add_entry(&th, new_dir, new_dentry->d_name.name,
1413 new_dentry->d_name.len, old_inode, 0);
1414 if (retval == -EEXIST) {
1415 if (!new_dentry_inode) {
1416 reiserfs_panic(old_dir->i_sb, "vs-7050",
1417 "new entry is found, new inode == 0");
1418 }
1419 } else if (retval) {
1420 int err = journal_end(&th);
1421 reiserfs_write_unlock(old_dir->i_sb);
1422 return err ? err : retval;
1423 }
1424
1425 reiserfs_update_inode_transaction(old_dir);
1426 reiserfs_update_inode_transaction(new_dir);
1427
1428 /*
1429 * this makes it so an fsync on an open fd for the old name will
1430 * commit the rename operation
1431 */
1432 reiserfs_update_inode_transaction(old_inode);
1433
1434 if (new_dentry_inode)
1435 reiserfs_update_inode_transaction(new_dentry_inode);
1436
1437 while (1) {
1438 /*
1439 * look for old name using corresponding entry key
1440 * (found by reiserfs_find_entry)
1441 */
1442 if ((retval =
1443 search_by_entry_key(new_dir->i_sb, &old_de.de_entry_key,
1444 &old_entry_path,
1445 &old_de)) != NAME_FOUND) {
1446 pathrelse(&old_entry_path);
1447 journal_end(&th);
1448 reiserfs_write_unlock(old_dir->i_sb);
1449 return -EIO;
1450 }
1451
1452 copy_item_head(&old_entry_ih, tp_item_head(&old_entry_path));
1453
1454 reiserfs_prepare_for_journal(old_inode->i_sb, old_de.de_bh, 1);
1455
1456 /* look for new name by reiserfs_find_entry */
1457 new_de.de_gen_number_bit_string = NULL;
1458 retval =
1459 reiserfs_find_entry(new_dir, new_dentry->d_name.name,
1460 new_dentry->d_name.len, &new_entry_path,
1461 &new_de);
1462 /*
1463 * reiserfs_add_entry should not return IO_ERROR,
1464 * because it is called with essentially same parameters from
1465 * reiserfs_add_entry above, and we'll catch any i/o errors
1466 * before we get here.
1467 */
1468 if (retval != NAME_FOUND_INVISIBLE && retval != NAME_FOUND) {
1469 pathrelse(&new_entry_path);
1470 pathrelse(&old_entry_path);
1471 journal_end(&th);
1472 reiserfs_write_unlock(old_dir->i_sb);
1473 return -EIO;
1474 }
1475
1476 copy_item_head(&new_entry_ih, tp_item_head(&new_entry_path));
1477
1478 reiserfs_prepare_for_journal(old_inode->i_sb, new_de.de_bh, 1);
1479
1480 if (S_ISDIR(old_inode->i_mode)) {
1481 if ((retval =
1482 search_by_entry_key(new_dir->i_sb,
1483 &dot_dot_de.de_entry_key,
1484 &dot_dot_entry_path,
1485 &dot_dot_de)) != NAME_FOUND) {
1486 pathrelse(&dot_dot_entry_path);
1487 pathrelse(&new_entry_path);
1488 pathrelse(&old_entry_path);
1489 journal_end(&th);
1490 reiserfs_write_unlock(old_dir->i_sb);
1491 return -EIO;
1492 }
1493 copy_item_head(&dot_dot_ih,
1494 tp_item_head(&dot_dot_entry_path));
1495 /* node containing ".." gets into transaction */
1496 reiserfs_prepare_for_journal(old_inode->i_sb,
1497 dot_dot_de.de_bh, 1);
1498 }
1499 /*
1500 * we should check seals here, not do
1501 * this stuff, yes? Then, having
1502 * gathered everything into RAM we
1503 * should lock the buffers, yes? -Hans
1504 */
1505 /*
1506 * probably. our rename needs to hold more
1507 * than one path at once. The seals would
1508 * have to be written to deal with multi-path
1509 * issues -chris
1510 */
1511 /*
1512 * sanity checking before doing the rename - avoid races many
1513 * of the above checks could have scheduled. We have to be
1514 * sure our items haven't been shifted by another process.
1515 */
1516 if (item_moved(&new_entry_ih, &new_entry_path) ||
1517 !entry_points_to_object(new_dentry->d_name.name,
1518 new_dentry->d_name.len,
1519 &new_de, new_dentry_inode) ||
1520 item_moved(&old_entry_ih, &old_entry_path) ||
1521 !entry_points_to_object(old_dentry->d_name.name,
1522 old_dentry->d_name.len,
1523 &old_de, old_inode)) {
1524 reiserfs_restore_prepared_buffer(old_inode->i_sb,
1525 new_de.de_bh);
1526 reiserfs_restore_prepared_buffer(old_inode->i_sb,
1527 old_de.de_bh);
1528 if (S_ISDIR(old_inode_mode))
1529 reiserfs_restore_prepared_buffer(old_inode->
1530 i_sb,
1531 dot_dot_de.
1532 de_bh);
1533 continue;
1534 }
1535 if (S_ISDIR(old_inode_mode)) {
1536 if (item_moved(&dot_dot_ih, &dot_dot_entry_path) ||
1537 !entry_points_to_object("..", 2, &dot_dot_de,
1538 old_dir)) {
1539 reiserfs_restore_prepared_buffer(old_inode->
1540 i_sb,
1541 old_de.de_bh);
1542 reiserfs_restore_prepared_buffer(old_inode->
1543 i_sb,
1544 new_de.de_bh);
1545 reiserfs_restore_prepared_buffer(old_inode->
1546 i_sb,
1547 dot_dot_de.
1548 de_bh);
1549 continue;
1550 }
1551 }
1552
1553 RFALSE(S_ISDIR(old_inode_mode) &&
1554 !buffer_journal_prepared(dot_dot_de.de_bh), "");
1555
1556 break;
1557 }
1558
1559 /*
1560 * ok, all the changes can be done in one fell swoop when we
1561 * have claimed all the buffers needed.
1562 */
1563
1564 mark_de_visible(new_de.de_deh + new_de.de_entry_num);
1565 set_ino_in_dir_entry(&new_de, INODE_PKEY(old_inode));
1566 journal_mark_dirty(&th, new_de.de_bh);
1567
1568 mark_de_hidden(old_de.de_deh + old_de.de_entry_num);
1569 journal_mark_dirty(&th, old_de.de_bh);
1570 ctime = CURRENT_TIME_SEC;
1571 old_dir->i_ctime = old_dir->i_mtime = ctime;
1572 new_dir->i_ctime = new_dir->i_mtime = ctime;
1573 /*
1574 * thanks to Alex Adriaanse <alex_a@caltech.edu> for patch
1575 * which adds ctime update of renamed object
1576 */
1577 old_inode->i_ctime = ctime;
1578
1579 if (new_dentry_inode) {
1580 /* adjust link number of the victim */
1581 if (S_ISDIR(new_dentry_inode->i_mode)) {
1582 clear_nlink(new_dentry_inode);
1583 } else {
1584 drop_nlink(new_dentry_inode);
1585 }
1586 new_dentry_inode->i_ctime = ctime;
1587 savelink = new_dentry_inode->i_nlink;
1588 }
1589
1590 if (S_ISDIR(old_inode_mode)) {
1591 /* adjust ".." of renamed directory */
1592 set_ino_in_dir_entry(&dot_dot_de, INODE_PKEY(new_dir));
1593 journal_mark_dirty(&th, dot_dot_de.de_bh);
1594
1595 /*
1596 * there (in new_dir) was no directory, so it got new link
1597 * (".." of renamed directory)
1598 */
1599 if (!new_dentry_inode)
1600 INC_DIR_INODE_NLINK(new_dir);
1601
1602 /* old directory lost one link - ".. " of renamed directory */
1603 DEC_DIR_INODE_NLINK(old_dir);
1604 }
1605 /*
1606 * looks like in 2.3.99pre3 brelse is atomic.
1607 * so we can use pathrelse
1608 */
1609 pathrelse(&new_entry_path);
1610 pathrelse(&dot_dot_entry_path);
1611
1612 /*
1613 * FIXME: this reiserfs_cut_from_item's return value may screw up
1614 * anybody, but it will panic if will not be able to find the
1615 * entry. This needs one more clean up
1616 */
1617 if (reiserfs_cut_from_item
1618 (&th, &old_entry_path, &old_de.de_entry_key, old_dir, NULL,
1619 0) < 0)
1620 reiserfs_error(old_dir->i_sb, "vs-7060",
1621 "couldn't not cut old name. Fsck later?");
1622
1623 old_dir->i_size -= DEH_SIZE + old_de.de_entrylen;
1624
1625 reiserfs_update_sd(&th, old_dir);
1626 reiserfs_update_sd(&th, new_dir);
1627 reiserfs_update_sd(&th, old_inode);
1628
1629 if (new_dentry_inode) {
1630 if (savelink == 0)
1631 add_save_link(&th, new_dentry_inode,
1632 0 /* not truncate */ );
1633 reiserfs_update_sd(&th, new_dentry_inode);
1634 }
1635
1636 retval = journal_end(&th);
1637 reiserfs_write_unlock(old_dir->i_sb);
1638 return retval;
1639}
1640
1641/* directories can handle most operations... */
1642const struct inode_operations reiserfs_dir_inode_operations = {
1643 .create = reiserfs_create,
1644 .lookup = reiserfs_lookup,
1645 .link = reiserfs_link,
1646 .unlink = reiserfs_unlink,
1647 .symlink = reiserfs_symlink,
1648 .mkdir = reiserfs_mkdir,
1649 .rmdir = reiserfs_rmdir,
1650 .mknod = reiserfs_mknod,
1651 .rename = reiserfs_rename,
1652 .setattr = reiserfs_setattr,
1653 .setxattr = reiserfs_setxattr,
1654 .getxattr = reiserfs_getxattr,
1655 .listxattr = reiserfs_listxattr,
1656 .removexattr = reiserfs_removexattr,
1657 .permission = reiserfs_permission,
1658 .get_acl = reiserfs_get_acl,
1659 .set_acl = reiserfs_set_acl,
1660};
1661
1662/*
1663 * symlink operations.. same as page_symlink_inode_operations, with xattr
1664 * stuff added
1665 */
1666const struct inode_operations reiserfs_symlink_inode_operations = {
1667 .readlink = generic_readlink,
1668 .get_link = page_get_link,
1669 .setattr = reiserfs_setattr,
1670 .setxattr = reiserfs_setxattr,
1671 .getxattr = reiserfs_getxattr,
1672 .listxattr = reiserfs_listxattr,
1673 .removexattr = reiserfs_removexattr,
1674 .permission = reiserfs_permission,
1675};
1676
1677/*
1678 * special file operations.. just xattr/acl stuff
1679 */
1680const struct inode_operations reiserfs_special_inode_operations = {
1681 .setattr = reiserfs_setattr,
1682 .setxattr = reiserfs_setxattr,
1683 .getxattr = reiserfs_getxattr,
1684 .listxattr = reiserfs_listxattr,
1685 .removexattr = reiserfs_removexattr,
1686 .permission = reiserfs_permission,
1687 .get_acl = reiserfs_get_acl,
1688 .set_acl = reiserfs_set_acl,
1689};