blob: ba5f51ec345829499982f17196fc61ac444429a0 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070014#include <linux/time.h>
15#include <linux/bitops.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090016#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/reiserfs_fs.h>
18#include <linux/reiserfs_acl.h>
19#include <linux/reiserfs_xattr.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <linux/quotaops.h>
21
Dave Hansend8c76e62006-09-30 23:29:04 -070022#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; }
Dave Hansen9a53c3a2006-09-30 23:29:03 -070023#define DEC_DIR_INODE_NLINK(i) if (i->i_nlink != 1) drop_nlink(i);
Linus Torvalds1da177e2005-04-16 15:20:36 -070024
25// directory item contains array of entry headers. This performs
26// binary search through that array
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070027static int bin_search_in_dir_item(struct reiserfs_dir_entry *de, loff_t off)
Linus Torvalds1da177e2005-04-16 15:20:36 -070028{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070029 struct item_head *ih = de->de_ih;
30 struct reiserfs_de_head *deh = de->de_deh;
31 int rbound, lbound, j;
Linus Torvalds1da177e2005-04-16 15:20:36 -070032
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070033 lbound = 0;
34 rbound = I_ENTRY_COUNT(ih) - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -070035
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070036 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -070049 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070050
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070051 de->de_entry_num = lbound;
52 return NAME_NOT_FOUND;
Linus Torvalds1da177e2005-04-16 15:20:36 -070053}
54
Linus Torvalds1da177e2005-04-16 15:20:36 -070055// comment? maybe something like set de to point to what the path points to?
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070056static inline void set_de_item_location(struct reiserfs_dir_entry *de,
Josef "Jeff" Sipekfec6d052006-12-08 02:36:32 -080057 struct treepath *path)
Linus Torvalds1da177e2005-04-16 15:20:36 -070058{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070059 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}
Linus Torvalds1da177e2005-04-16 15:20:36 -070064
65// de_bh, de_ih, de_deh (points to first element of array), de_item_num is set
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070066inline void set_de_name_and_namelen(struct reiserfs_dir_entry *de)
Linus Torvalds1da177e2005-04-16 15:20:36 -070067{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070068 struct reiserfs_de_head *deh = de->de_deh + de->de_entry_num;
Linus Torvalds1da177e2005-04-16 15:20:36 -070069
Eric Sesterhenn14a61442006-10-03 23:36:38 +020070 BUG_ON(de->de_entry_num >= ih_entry_count(de->de_ih));
Linus Torvalds1da177e2005-04-16 15:20:36 -070071
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070072 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -070077}
78
Linus Torvalds1da177e2005-04-16 15:20:36 -070079// what entry points to
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070080static inline void set_de_object_key(struct reiserfs_dir_entry *de)
Linus Torvalds1da177e2005-04-16 15:20:36 -070081{
Eric Sesterhenn14a61442006-10-03 23:36:38 +020082 BUG_ON(de->de_entry_num >= ih_entry_count(de->de_ih));
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070083 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]));
Linus Torvalds1da177e2005-04-16 15:20:36 -070085}
86
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070087static inline void store_de_entry_key(struct reiserfs_dir_entry *de)
Linus Torvalds1da177e2005-04-16 15:20:36 -070088{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070089 struct reiserfs_de_head *deh = de->de_deh + de->de_entry_num;
Linus Torvalds1da177e2005-04-16 15:20:36 -070090
Eric Sesterhenn14a61442006-10-03 23:36:38 +020091 BUG_ON(de->de_entry_num >= ih_entry_count(de->de_ih));
Linus Torvalds1da177e2005-04-16 15:20:36 -070092
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070093 /* 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101}
102
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103/* 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
Jeff Mahoney0222e652009-03-30 14:02:44 -0400110entry position in the item
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111
112*/
113
114/* The function is NOT SCHEDULE-SAFE! */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700115int search_by_entry_key(struct super_block *sb, const struct cpu_key *key,
Josef "Jeff" Sipekfec6d052006-12-08 02:36:32 -0800116 struct treepath *path, struct reiserfs_dir_entry *de)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700118 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700120 retval = search_item(sb, key, path);
121 switch (retval) {
122 case ITEM_NOT_FOUND:
123 if (!PATH_LAST_POSITION(path)) {
Jeff Mahoney0030b642009-03-30 14:02:28 -0400124 reiserfs_error(sb, "vs-7000", "search_by_key "
125 "returned item position == 0");
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700126 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);
Jeff Mahoney0030b642009-03-30 14:02:28 -0400139 reiserfs_error(sb, "vs-7002", "no path to here");
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700140 return IO_ERROR;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700143 set_de_item_location(de, path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144
145#ifdef CONFIG_REISERFS_CHECK
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700146 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);
Jeff Mahoneyc3a9c212009-03-30 14:02:25 -0400149 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);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700152 }
153#endif /* CONFIG_REISERFS_CHECK */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700155 /* 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165}
166
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167/* 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
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700174static __u32 get_third_component(struct super_block *s,
175 const char *name, int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700177 __u32 res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700179 if (!len || (len == 1 && name[0] == '.'))
180 return DOT_OFFSET;
181 if (len == 2 && name[0] == '.' && name[1] == '.')
182 return DOT_DOT_OFFSET;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700184 res = REISERFS_SB(s)->s_hash_function(name, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700186 // 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193}
194
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700195static int reiserfs_match(struct reiserfs_dir_entry *de,
196 const char *name, int namelen)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700198 int retval = NAME_NOT_FOUND;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700200 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700206 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207}
208
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209/* 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
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700213static int linear_search_in_dir_item(struct cpu_key *key,
214 struct reiserfs_dir_entry *de,
215 const char *name, int namelen)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700217 struct reiserfs_de_head *deh = de->de_deh;
218 int retval;
219 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700221 i = de->de_entry_num;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700223 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--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700229 RFALSE(de->de_deh != B_I_DEH(de->de_bh, de->de_ih),
230 "vs-7010: array of entry headers not found");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700232 deh += i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700234 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 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700241 /* mark, that this generation number is used */
242 if (de->de_gen_number_bit_string)
243 set_bit(GET_GENERATION_NUMBER(deh_offset(deh)),
Jeff Mahoney3af1efe2006-03-02 13:25:26 -0500244 de->de_gen_number_bit_string);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700246 // 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 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700264 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700274 RFALSE(de->de_item_num,
275 "vs-7015: two diritems of the same directory in one node?");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700277 return GOTO_PREVIOUS_ITEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278}
279
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280// may return NAME_FOUND, NAME_FOUND_INVISIBLE, NAME_NOT_FOUND
281// FIXME: should add something like IOERROR
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700282static int reiserfs_find_entry(struct inode *dir, const char *name, int namelen,
Josef "Jeff" Sipekfec6d052006-12-08 02:36:32 -0800283 struct treepath *path_to_entry,
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700284 struct reiserfs_dir_entry *de)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700286 struct cpu_key key_to_search;
287 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700289 if (namelen > REISERFS_MAX_NAME(dir->i_sb->s_blocksize))
290 return NAME_NOT_FOUND;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700292 /* 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700297 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) {
Jeff Mahoney0030b642009-03-30 14:02:28 -0400302 reiserfs_error(dir->i_sb, "zam-7001", "io error");
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700303 return IO_ERROR;
304 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700306 /* 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;
Frederic Weisbeckerb1c839b2009-05-08 01:05:06 +0200328 int lock_depth;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700329 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
Frederic Weisbeckerb1c839b2009-05-08 01:05:06 +0200336 /*
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
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700343 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) {
Jeff Mahoney677c9b22009-05-05 15:30:17 -0400349 inode = reiserfs_iget(dir->i_sb,
350 (struct cpu_key *)&(de.de_dir_id));
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700351 if (!inode || IS_ERR(inode)) {
Frederic Weisbeckerb1c839b2009-05-08 01:05:06 +0200352 reiserfs_write_unlock_once(dir->i_sb, lock_depth);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700353 return ERR_PTR(-EACCES);
354 }
355
Jeff Mahoney6dfede62009-03-30 14:02:32 -0400356 /* 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;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700360 }
Frederic Weisbeckerb1c839b2009-05-08 01:05:06 +0200361 reiserfs_write_unlock_once(dir->i_sb, lock_depth);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 if (retval == IO_ERROR) {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700363 return ERR_PTR(-EIO);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 }
365
Pekka Enbergd9975d62006-01-14 13:21:09 -0800366 return d_splice_alias(inode, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367}
368
Jeff Mahoney0222e652009-03-30 14:02:44 -0400369/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370** 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{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700375 int retval;
376 struct inode *inode = NULL;
377 struct reiserfs_dir_entry de;
378 INITIALIZE_PATH(path_to_entry);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700379 struct inode *dir = child->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700381 if (dir->i_nlink == 0) {
382 return ERR_PTR(-ENOENT);
383 }
384 de.de_gen_number_bit_string = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700386 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));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 reiserfs_write_unlock(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395
Christoph Hellwig44003722008-08-11 15:49:04 +0200396 return d_obtain_alias(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397}
398
Jeff Mahoney0222e652009-03-30 14:02:44 -0400399/* add entry to the directory (entry can be hidden).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400
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
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700405static int reiserfs_add_entry(struct reiserfs_transaction_handle *th,
406 struct inode *dir, const char *name, int namelen,
407 struct inode *inode, int visible)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700409 struct cpu_key entry_key;
410 struct reiserfs_de_head *deh;
411 INITIALIZE_PATH(path);
412 struct reiserfs_dir_entry de;
Jeff Mahoney3af1efe2006-03-02 13:25:26 -0500413 DECLARE_BITMAP(bit_string, MAX_GENERATION_NUMBER + 1);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700414 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700421 BUG_ON(!th->t_trans_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700423 /* cannot allow items to be added into a busy deleted directory */
424 if (!namelen)
425 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700427 if (namelen > REISERFS_MAX_NAME(dir->i_sb->s_blocksize))
428 return -ENAMETOOLONG;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700430 /* 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700435 /* get memory for composing the entry */
436 buflen = DEH_SIZE + ROUND_UP(namelen);
437 if (buflen > sizeof(small_buf)) {
Pekka Enbergd739b422006-02-01 03:06:43 -0800438 buffer = kmalloc(buflen, GFP_NOFS);
Al Viro9dce07f2008-03-29 03:07:28 +0000439 if (!buffer)
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700440 return -ENOMEM;
441 } else
442 buffer = small_buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700444 paste_size =
445 (get_inode_sd_version(dir) ==
446 STAT_DATA_V1) ? (DEH_SIZE + namelen) : buflen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700448 /* 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 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700457 /* 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700462 /* 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700466 /* find the proper place for the new entry */
467 memset(bit_string, 0, sizeof(bit_string));
Jeff Mahoney3af1efe2006-03-02 13:25:26 -0500468 de.de_gen_number_bit_string = bit_string;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700469 retval = reiserfs_find_entry(dir, name, namelen, &path, &de);
470 if (retval != NAME_NOT_FOUND) {
471 if (buffer != small_buf)
Pekka Enbergd739b422006-02-01 03:06:43 -0800472 kfree(buffer);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700473 pathrelse(&path);
474
475 if (retval == IO_ERROR) {
476 return -EIO;
477 }
478
479 if (retval != NAME_FOUND) {
Jeff Mahoney0030b642009-03-30 14:02:28 -0400480 reiserfs_error(dir->i_sb, "zam-7002",
481 "reiserfs_find_entry() returned "
482 "unexpected value (%d)", retval);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700483 }
484
485 return -EEXIST;
486 }
487
488 gen_number =
Jeff Mahoney3af1efe2006-03-02 13:25:26 -0500489 find_first_zero_bit(bit_string,
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700490 MAX_GENERATION_NUMBER + 1);
491 if (gen_number > MAX_GENERATION_NUMBER) {
492 /* there is no free generation number */
Jeff Mahoney45b03d52009-03-30 14:02:21 -0400493 reiserfs_warning(dir->i_sb, "reiserfs-7010",
494 "Congratulations! we have got hash function "
495 "screwed up");
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700496 if (buffer != small_buf)
Pekka Enbergd739b422006-02-01 03:06:43 -0800497 kfree(buffer);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700498 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) {
Jeff Mahoney45b03d52009-03-30 14:02:21 -0400511 reiserfs_warning(dir->i_sb, "vs-7032",
512 "entry with this key (%K) already "
513 "exists", &entry_key);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700514
515 if (buffer != small_buf)
Pekka Enbergd739b422006-02-01 03:06:43 -0800516 kfree(buffer);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700517 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 if (buffer != small_buf)
Pekka Enbergd739b422006-02-01 03:06:43 -0800527 kfree(buffer);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700528 if (retval) {
529 reiserfs_check_path(&path);
530 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 }
532
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700533 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700539 reiserfs_check_path(&path);
540 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541}
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*/
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700548static int drop_new_inode(struct inode *inode)
549{
Christoph Hellwig9f754752010-03-03 09:05:05 -0500550 dquot_drop(inode);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700551 make_bad_inode(inode);
552 inode->i_flags |= S_NOQUOTA;
553 iput(inode);
554 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555}
556
Jeff Mahoney0222e652009-03-30 14:02:44 -0400557/* utility function that does setup for reiserfs_new_inode.
Christoph Hellwig871a2932010-03-03 09:05:07 -0500558** dquot_initialize needs lots of credits so it's better to have it
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559** outside of a transaction, so we had to pull some bits of
560** reiserfs_new_inode out into this func.
561*/
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700562static int new_inode_init(struct inode *inode, struct inode *dir, int mode)
563{
Jan Kara1b0a74d2005-08-13 13:15:34 +0200564 /* Make inode invalid - just in case we are going to drop it before
565 * the initialization happens */
566 INODE_PKEY(inode)->k_objectid = 0;
Dmitry Monakhov04b7ed02010-03-04 17:32:19 +0300567 /* 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);
Christoph Hellwig871a2932010-03-03 09:05:07 -0500571 dquot_initialize(inode);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700572 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573}
574
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700575static int reiserfs_create(struct inode *dir, struct dentry *dentry, int mode,
576 struct nameidata *nd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700578 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;
Jeff Mahoney57fe60d2009-03-30 14:02:41 -0400586 struct reiserfs_security_handle security;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587
Christoph Hellwig871a2932010-03-03 09:05:07 -0500588 dquot_initialize(dir);
Christoph Hellwig907f4552010-03-03 09:05:06 -0500589
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700590 if (!(inode = new_inode(dir->i_sb))) {
591 return -ENOMEM;
592 }
593 new_inode_init(inode, dir, mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594
Jeff Mahoney0ab26212009-03-30 14:02:39 -0400595 jbegin_count += reiserfs_cache_default_acl(dir);
Jeff Mahoney57fe60d2009-03-30 14:02:41 -0400596 retval = reiserfs_security_init(dir, inode, &security);
597 if (retval < 0) {
598 drop_new_inode(inode);
599 return retval;
600 }
601 jbegin_count += retval;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700602 reiserfs_write_lock(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700604 retval = journal_begin(&th, dir->i_sb, jbegin_count);
605 if (retval) {
606 drop_new_inode(inode);
607 goto out_failed;
608 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700610 retval =
611 reiserfs_new_inode(&th, dir, mode, NULL, 0 /*i_size */ , dentry,
Jeff Mahoney57fe60d2009-03-30 14:02:41 -0400612 inode, &security);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700613 if (retval)
614 goto out_failed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700616 inode->i_op = &reiserfs_file_inode_operations;
617 inode->i_fop = &reiserfs_file_operations;
618 inode->i_mapping->a_ops = &reiserfs_address_space_operations;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700620 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;
Al Viroc1eaa262008-12-30 02:03:58 -0500630 unlock_new_inode(inode);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700631 iput(inode);
632 goto out_failed;
633 }
634 reiserfs_update_inode_transaction(inode);
635 reiserfs_update_inode_transaction(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700637 d_instantiate(dentry, inode);
Al Viroc1eaa262008-12-30 02:03:58 -0500638 unlock_new_inode(inode);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700639 retval = journal_end(&th, dir->i_sb, jbegin_count);
640
641 out_failed:
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700642 reiserfs_write_unlock(dir->i_sb);
643 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644}
645
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700646static int reiserfs_mknod(struct inode *dir, struct dentry *dentry, int mode,
647 dev_t rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700649 int retval;
650 struct inode *inode;
651 struct reiserfs_transaction_handle th;
Jeff Mahoney57fe60d2009-03-30 14:02:41 -0400652 struct reiserfs_security_handle security;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700653 /* 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));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700659 if (!new_valid_dev(rdev))
660 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661
Christoph Hellwig871a2932010-03-03 09:05:07 -0500662 dquot_initialize(dir);
Christoph Hellwig907f4552010-03-03 09:05:06 -0500663
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700664 if (!(inode = new_inode(dir->i_sb))) {
665 return -ENOMEM;
666 }
667 new_inode_init(inode, dir, mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668
Jeff Mahoney0ab26212009-03-30 14:02:39 -0400669 jbegin_count += reiserfs_cache_default_acl(dir);
Jeff Mahoney57fe60d2009-03-30 14:02:41 -0400670 retval = reiserfs_security_init(dir, inode, &security);
671 if (retval < 0) {
672 drop_new_inode(inode);
673 return retval;
674 }
675 jbegin_count += retval;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700676 reiserfs_write_lock(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700678 retval = journal_begin(&th, dir->i_sb, jbegin_count);
679 if (retval) {
680 drop_new_inode(inode);
681 goto out_failed;
682 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700684 retval =
685 reiserfs_new_inode(&th, dir, mode, NULL, 0 /*i_size */ , dentry,
Jeff Mahoney57fe60d2009-03-30 14:02:41 -0400686 inode, &security);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700687 if (retval) {
688 goto out_failed;
689 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700691 inode->i_op = &reiserfs_special_inode_operations;
692 init_special_inode(inode, inode->i_mode, rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700694 //FIXME: needed for block and char devices only
695 reiserfs_update_sd(&th, inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700697 reiserfs_update_inode_transaction(inode);
698 reiserfs_update_inode_transaction(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700700 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;
Al Viroc1eaa262008-12-30 02:03:58 -0500710 unlock_new_inode(inode);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700711 iput(inode);
712 goto out_failed;
713 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700715 d_instantiate(dentry, inode);
Al Viroc1eaa262008-12-30 02:03:58 -0500716 unlock_new_inode(inode);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700717 retval = journal_end(&th, dir->i_sb, jbegin_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700719 out_failed:
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700720 reiserfs_write_unlock(dir->i_sb);
721 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722}
723
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700724static int reiserfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700726 int retval;
727 struct inode *inode;
728 struct reiserfs_transaction_handle th;
Jeff Mahoney57fe60d2009-03-30 14:02:41 -0400729 struct reiserfs_security_handle security;
Frederic Weisbeckerb10ab4c2009-08-25 02:44:21 +0200730 int lock_depth;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700731 /* 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));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736
Christoph Hellwig871a2932010-03-03 09:05:07 -0500737 dquot_initialize(dir);
Christoph Hellwig907f4552010-03-03 09:05:06 -0500738
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739#ifdef DISPLACE_NEW_PACKING_LOCALITIES
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700740 /* 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742#endif
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700743 mode = S_IFDIR | mode;
744 if (!(inode = new_inode(dir->i_sb))) {
745 return -ENOMEM;
746 }
747 new_inode_init(inode, dir, mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748
Jeff Mahoney0ab26212009-03-30 14:02:39 -0400749 jbegin_count += reiserfs_cache_default_acl(dir);
Jeff Mahoney57fe60d2009-03-30 14:02:41 -0400750 retval = reiserfs_security_init(dir, inode, &security);
751 if (retval < 0) {
752 drop_new_inode(inode);
753 return retval;
754 }
755 jbegin_count += retval;
Frederic Weisbeckerb10ab4c2009-08-25 02:44:21 +0200756 lock_depth = reiserfs_write_lock_once(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700758 retval = journal_begin(&th, dir->i_sb, jbegin_count);
759 if (retval) {
760 drop_new_inode(inode);
761 goto out_failed;
762 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700764 /* 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)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700769 retval = reiserfs_new_inode(&th, dir, mode, NULL /*symlink */ ,
770 old_format_only(dir->i_sb) ?
771 EMPTY_DIR_SIZE_V1 : EMPTY_DIR_SIZE,
Jeff Mahoney57fe60d2009-03-30 14:02:41 -0400772 dentry, inode, &security);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700773 if (retval) {
774 dir->i_nlink--;
775 goto out_failed;
776 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700778 reiserfs_update_inode_transaction(inode);
779 reiserfs_update_inode_transaction(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700781 inode->i_op = &reiserfs_dir_inode_operations;
782 inode->i_fop = &reiserfs_dir_operations;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700784 // 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;
Al Viroc1eaa262008-12-30 02:03:58 -0500796 unlock_new_inode(inode);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700797 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700803 d_instantiate(dentry, inode);
Al Viroc1eaa262008-12-30 02:03:58 -0500804 unlock_new_inode(inode);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700805 retval = journal_end(&th, dir->i_sb, jbegin_count);
Frederic Weisbeckerb10ab4c2009-08-25 02:44:21 +0200806out_failed:
807 reiserfs_write_unlock_once(dir->i_sb, lock_depth);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700808 return retval;
809}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700811static 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
Jeff Mahoney0222e652009-03-30 14:02:44 -0400815 ** EMPTY_DIR_SIZE_V1. So, if the inode is either size,
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700816 ** 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}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700825static 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700834 /* 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841
Christoph Hellwig871a2932010-03-03 09:05:07 -0500842 dquot_initialize(dir);
Christoph Hellwig907f4552010-03-03 09:05:06 -0500843
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700844 reiserfs_write_lock(dir->i_sb);
845 retval = journal_begin(&th, dir->i_sb, jbegin_count);
846 if (retval)
847 goto out_rmdir;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700849 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)
Jeff Mahoney0030b642009-03-30 14:02:28 -0400883 reiserfs_error(inode->i_sb, "reiserfs-7040",
884 "empty directory has nlink != 2 (%d)",
885 inode->i_nlink);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700886
Dave Hansence71ec32006-09-30 23:29:06 -0700887 clear_nlink(inode);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700888 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910 reiserfs_write_unlock(dir->i_sb);
911 return err ? err : retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912}
913
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700914static 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;
Frederic Weisbeckerc6749052009-12-30 07:12:03 +0100923 int depth;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700924
Christoph Hellwig871a2932010-03-03 09:05:07 -0500925 dquot_initialize(dir);
Christoph Hellwig907f4552010-03-03 09:05:06 -0500926
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700927 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
Frederic Weisbeckerc6749052009-12-30 07:12:03 +0100937 depth = reiserfs_write_lock_once(dir->i_sb);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700938 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) {
Jeff Mahoney45b03d52009-03-30 14:02:21 -0400964 reiserfs_warning(inode->i_sb, "reiserfs-7042",
965 "deleting nonexistent file (%lu), %d",
966 inode->i_ino, inode->i_nlink);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700967 inode->i_nlink = 1;
968 }
969
Dave Hansen9a53c3a2006-09-30 23:29:03 -0700970 drop_nlink(inode);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700971
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) {
Dave Hansend8c76e62006-09-30 23:29:04 -0700982 inc_nlink(inode);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700983 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);
Frederic Weisbeckerc6749052009-12-30 07:12:03 +0100998 reiserfs_write_unlock_once(dir->i_sb, depth);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700999 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:
Frederic Weisbeckerc6749052009-12-30 07:12:03 +01001008 reiserfs_write_unlock_once(dir->i_sb, depth);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001009 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;
Jeff Mahoney57fe60d2009-03-30 14:02:41 -04001020 struct reiserfs_security_handle security;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001021 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
Christoph Hellwig871a2932010-03-03 09:05:07 -05001028 dquot_initialize(parent_dir);
Christoph Hellwig907f4552010-03-03 09:05:06 -05001029
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001030 if (!(inode = new_inode(parent_dir->i_sb))) {
1031 return -ENOMEM;
1032 }
1033 new_inode_init(inode, parent_dir, mode);
1034
Jeff Mahoney57fe60d2009-03-30 14:02:41 -04001035 retval = reiserfs_security_init(parent_dir, inode, &security);
1036 if (retval < 0) {
1037 drop_new_inode(inode);
1038 return retval;
1039 }
1040 jbegin_count += retval;
1041
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001042 reiserfs_write_lock(parent_dir->i_sb);
1043 item_len = ROUND_UP(strlen(symname));
1044 if (item_len > MAX_DIRECT_ITEM_LEN(parent_dir->i_sb->s_blocksize)) {
1045 retval = -ENAMETOOLONG;
1046 drop_new_inode(inode);
1047 goto out_failed;
1048 }
1049
Pekka Enbergd739b422006-02-01 03:06:43 -08001050 name = kmalloc(item_len, GFP_NOFS);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001051 if (!name) {
1052 drop_new_inode(inode);
1053 retval = -ENOMEM;
1054 goto out_failed;
1055 }
1056 memcpy(name, symname, strlen(symname));
1057 padd_item(name, item_len, strlen(symname));
1058
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001059 retval = journal_begin(&th, parent_dir->i_sb, jbegin_count);
1060 if (retval) {
1061 drop_new_inode(inode);
Pekka Enbergd739b422006-02-01 03:06:43 -08001062 kfree(name);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001063 goto out_failed;
1064 }
1065
1066 retval =
1067 reiserfs_new_inode(&th, parent_dir, mode, name, strlen(symname),
Jeff Mahoney57fe60d2009-03-30 14:02:41 -04001068 dentry, inode, &security);
Pekka Enbergd739b422006-02-01 03:06:43 -08001069 kfree(name);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001070 if (retval) { /* reiserfs_new_inode iputs for us */
1071 goto out_failed;
1072 }
1073
1074 reiserfs_update_inode_transaction(inode);
1075 reiserfs_update_inode_transaction(parent_dir);
1076
1077 inode->i_op = &reiserfs_symlink_inode_operations;
1078 inode->i_mapping->a_ops = &reiserfs_address_space_operations;
1079
1080 // must be sure this inode is written with this transaction
1081 //
1082 //reiserfs_update_sd (&th, inode, READ_BLOCKS);
1083
1084 retval = reiserfs_add_entry(&th, parent_dir, dentry->d_name.name,
1085 dentry->d_name.len, inode, 1 /*visible */ );
1086 if (retval) {
1087 int err;
1088 inode->i_nlink--;
1089 reiserfs_update_sd(&th, inode);
1090 err = journal_end(&th, parent_dir->i_sb, jbegin_count);
1091 if (err)
1092 retval = err;
Al Viroc1eaa262008-12-30 02:03:58 -05001093 unlock_new_inode(inode);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001094 iput(inode);
1095 goto out_failed;
1096 }
1097
1098 d_instantiate(dentry, inode);
Al Viroc1eaa262008-12-30 02:03:58 -05001099 unlock_new_inode(inode);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001100 retval = journal_end(&th, parent_dir->i_sb, jbegin_count);
1101 out_failed:
1102 reiserfs_write_unlock(parent_dir->i_sb);
1103 return retval;
1104}
1105
1106static int reiserfs_link(struct dentry *old_dentry, struct inode *dir,
1107 struct dentry *dentry)
1108{
1109 int retval;
1110 struct inode *inode = old_dentry->d_inode;
1111 struct reiserfs_transaction_handle th;
1112 /* We need blocks for transaction + update of quotas for the owners of the directory */
1113 int jbegin_count =
1114 JOURNAL_PER_BALANCE_CNT * 3 +
1115 2 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);
1116
Christoph Hellwig871a2932010-03-03 09:05:07 -05001117 dquot_initialize(dir);
Christoph Hellwig907f4552010-03-03 09:05:06 -05001118
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001119 reiserfs_write_lock(dir->i_sb);
1120 if (inode->i_nlink >= REISERFS_LINK_MAX) {
1121 //FIXME: sd_nlink is 32 bit for new files
1122 reiserfs_write_unlock(dir->i_sb);
1123 return -EMLINK;
1124 }
1125 if (inode->i_nlink == 0) {
1126 reiserfs_write_unlock(dir->i_sb);
1127 return -ENOENT;
1128 }
1129
1130 /* inc before scheduling so reiserfs_unlink knows we are here */
Dave Hansend8c76e62006-09-30 23:29:04 -07001131 inc_nlink(inode);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001132
1133 retval = journal_begin(&th, dir->i_sb, jbegin_count);
1134 if (retval) {
1135 inode->i_nlink--;
1136 reiserfs_write_unlock(dir->i_sb);
1137 return retval;
1138 }
1139
1140 /* create new entry */
1141 retval =
1142 reiserfs_add_entry(&th, dir, dentry->d_name.name,
1143 dentry->d_name.len, inode, 1 /*visible */ );
1144
1145 reiserfs_update_inode_transaction(inode);
1146 reiserfs_update_inode_transaction(dir);
1147
1148 if (retval) {
1149 int err;
1150 inode->i_nlink--;
1151 err = journal_end(&th, dir->i_sb, jbegin_count);
1152 reiserfs_write_unlock(dir->i_sb);
1153 return err ? err : retval;
1154 }
1155
1156 inode->i_ctime = CURRENT_TIME_SEC;
1157 reiserfs_update_sd(&th, inode);
1158
Al Viro7de9c6e2010-10-23 11:11:40 -04001159 ihold(inode);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001160 d_instantiate(dentry, inode);
1161 retval = journal_end(&th, dir->i_sb, jbegin_count);
1162 reiserfs_write_unlock(dir->i_sb);
1163 return retval;
1164}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165
Jeff Mahoney0222e652009-03-30 14:02:44 -04001166/* de contains information pointing to an entry which */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001167static int de_still_valid(const char *name, int len,
1168 struct reiserfs_dir_entry *de)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001170 struct reiserfs_dir_entry tmp = *de;
1171
1172 // recalculate pointer to name and name length
1173 set_de_name_and_namelen(&tmp);
1174 // FIXME: could check more
1175 if (tmp.de_namelen != len || memcmp(name, de->de_name, len))
1176 return 0;
1177 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178}
1179
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001180static int entry_points_to_object(const char *name, int len,
1181 struct reiserfs_dir_entry *de,
1182 struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001184 if (!de_still_valid(name, len, de))
1185 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001187 if (inode) {
1188 if (!de_visible(de->de_deh + de->de_entry_num))
Jeff Mahoneyc3a9c212009-03-30 14:02:25 -04001189 reiserfs_panic(inode->i_sb, "vs-7042",
1190 "entry must be visible");
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001191 return (de->de_objectid == inode->i_ino) ? 1 : 0;
1192 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001194 /* this must be added hidden entry */
1195 if (de_visible(de->de_deh + de->de_entry_num))
Jeff Mahoneyc3a9c212009-03-30 14:02:25 -04001196 reiserfs_panic(NULL, "vs-7043", "entry must be visible");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001198 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199}
1200
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201/* sets key of objectid the entry has to point to */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001202static void set_ino_in_dir_entry(struct reiserfs_dir_entry *de,
1203 struct reiserfs_key *key)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001205 /* JDM These operations are endian safe - both are le */
1206 de->de_deh[de->de_entry_num].deh_dir_id = key->k_dir_id;
1207 de->de_deh[de->de_entry_num].deh_objectid = key->k_objectid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208}
1209
Jeff Mahoney0222e652009-03-30 14:02:44 -04001210/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001211 * process, that is going to call fix_nodes/do_balance must hold only
1212 * one path. If it holds 2 or more, it can get into endless waiting in
Jeff Mahoney0222e652009-03-30 14:02:44 -04001213 * get_empty_nodes or its clones
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214 */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001215static int reiserfs_rename(struct inode *old_dir, struct dentry *old_dentry,
1216 struct inode *new_dir, struct dentry *new_dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001217{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001218 int retval;
1219 INITIALIZE_PATH(old_entry_path);
1220 INITIALIZE_PATH(new_entry_path);
1221 INITIALIZE_PATH(dot_dot_entry_path);
1222 struct item_head new_entry_ih, old_entry_ih, dot_dot_ih;
1223 struct reiserfs_dir_entry old_de, new_de, dot_dot_de;
1224 struct inode *old_inode, *new_dentry_inode;
1225 struct reiserfs_transaction_handle th;
1226 int jbegin_count;
1227 umode_t old_inode_mode;
1228 unsigned long savelink = 1;
1229 struct timespec ctime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001231 /* three balancings: (1) old name removal, (2) new name insertion
1232 and (3) maybe "save" link insertion
1233 stat data updates: (1) old directory,
1234 (2) new directory and (3) maybe old object stat data (when it is
1235 directory) and (4) maybe stat data of object to which new entry
1236 pointed initially and (5) maybe block containing ".." of
1237 renamed directory
1238 quota updates: two parent directories */
1239 jbegin_count =
1240 JOURNAL_PER_BALANCE_CNT * 3 + 5 +
1241 4 * REISERFS_QUOTA_TRANS_BLOCKS(old_dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242
Christoph Hellwig871a2932010-03-03 09:05:07 -05001243 dquot_initialize(old_dir);
1244 dquot_initialize(new_dir);
Christoph Hellwig907f4552010-03-03 09:05:06 -05001245
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001246 old_inode = old_dentry->d_inode;
1247 new_dentry_inode = new_dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001249 // make sure, that oldname still exists and points to an object we
1250 // are going to rename
1251 old_de.de_gen_number_bit_string = NULL;
1252 reiserfs_write_lock(old_dir->i_sb);
1253 retval =
1254 reiserfs_find_entry(old_dir, old_dentry->d_name.name,
1255 old_dentry->d_name.len, &old_entry_path,
1256 &old_de);
1257 pathrelse(&old_entry_path);
1258 if (retval == IO_ERROR) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259 reiserfs_write_unlock(old_dir->i_sb);
1260 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001261 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001262
1263 if (retval != NAME_FOUND || old_de.de_objectid != old_inode->i_ino) {
1264 reiserfs_write_unlock(old_dir->i_sb);
1265 return -ENOENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001267
1268 old_inode_mode = old_inode->i_mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269 if (S_ISDIR(old_inode_mode)) {
Jeff Mahoney0222e652009-03-30 14:02:44 -04001270 // make sure, that directory being renamed has correct ".."
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001271 // and that its new parent directory has not too many links
1272 // already
1273
1274 if (new_dentry_inode) {
1275 if (!reiserfs_empty_dir(new_dentry_inode)) {
1276 reiserfs_write_unlock(old_dir->i_sb);
1277 return -ENOTEMPTY;
1278 }
1279 }
1280
Jeff Mahoney0222e652009-03-30 14:02:44 -04001281 /* directory is renamed, its parent directory will be changed,
1282 ** so find ".." entry
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001283 */
1284 dot_dot_de.de_gen_number_bit_string = NULL;
1285 retval =
1286 reiserfs_find_entry(old_inode, "..", 2, &dot_dot_entry_path,
1287 &dot_dot_de);
1288 pathrelse(&dot_dot_entry_path);
1289 if (retval != NAME_FOUND) {
1290 reiserfs_write_unlock(old_dir->i_sb);
1291 return -EIO;
1292 }
1293
1294 /* inode number of .. must equal old_dir->i_ino */
1295 if (dot_dot_de.de_objectid != old_dir->i_ino) {
1296 reiserfs_write_unlock(old_dir->i_sb);
1297 return -EIO;
1298 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299 }
1300
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001301 retval = journal_begin(&th, old_dir->i_sb, jbegin_count);
1302 if (retval) {
1303 reiserfs_write_unlock(old_dir->i_sb);
1304 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001307 /* add new entry (or find the existing one) */
1308 retval =
1309 reiserfs_add_entry(&th, new_dir, new_dentry->d_name.name,
1310 new_dentry->d_name.len, old_inode, 0);
1311 if (retval == -EEXIST) {
1312 if (!new_dentry_inode) {
Jeff Mahoneyc3a9c212009-03-30 14:02:25 -04001313 reiserfs_panic(old_dir->i_sb, "vs-7050",
1314 "new entry is found, new inode == 0");
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001315 }
1316 } else if (retval) {
1317 int err = journal_end(&th, old_dir->i_sb, jbegin_count);
1318 reiserfs_write_unlock(old_dir->i_sb);
1319 return err ? err : retval;
1320 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001322 reiserfs_update_inode_transaction(old_dir);
1323 reiserfs_update_inode_transaction(new_dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001325 /* this makes it so an fsync on an open fd for the old name will
1326 ** commit the rename operation
1327 */
1328 reiserfs_update_inode_transaction(old_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001329
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001330 if (new_dentry_inode)
1331 reiserfs_update_inode_transaction(new_dentry_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001333 while (1) {
1334 // look for old name using corresponding entry key (found by reiserfs_find_entry)
1335 if ((retval =
1336 search_by_entry_key(new_dir->i_sb, &old_de.de_entry_key,
1337 &old_entry_path,
1338 &old_de)) != NAME_FOUND) {
1339 pathrelse(&old_entry_path);
1340 journal_end(&th, old_dir->i_sb, jbegin_count);
1341 reiserfs_write_unlock(old_dir->i_sb);
1342 return -EIO;
1343 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001345 copy_item_head(&old_entry_ih, get_ih(&old_entry_path));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001347 reiserfs_prepare_for_journal(old_inode->i_sb, old_de.de_bh, 1);
1348
1349 // look for new name by reiserfs_find_entry
1350 new_de.de_gen_number_bit_string = NULL;
1351 retval =
1352 reiserfs_find_entry(new_dir, new_dentry->d_name.name,
1353 new_dentry->d_name.len, &new_entry_path,
1354 &new_de);
1355 // reiserfs_add_entry should not return IO_ERROR, because it is called with essentially same parameters from
1356 // reiserfs_add_entry above, and we'll catch any i/o errors before we get here.
1357 if (retval != NAME_FOUND_INVISIBLE && retval != NAME_FOUND) {
1358 pathrelse(&new_entry_path);
1359 pathrelse(&old_entry_path);
1360 journal_end(&th, old_dir->i_sb, jbegin_count);
1361 reiserfs_write_unlock(old_dir->i_sb);
1362 return -EIO;
1363 }
1364
1365 copy_item_head(&new_entry_ih, get_ih(&new_entry_path));
1366
1367 reiserfs_prepare_for_journal(old_inode->i_sb, new_de.de_bh, 1);
1368
1369 if (S_ISDIR(old_inode->i_mode)) {
1370 if ((retval =
1371 search_by_entry_key(new_dir->i_sb,
1372 &dot_dot_de.de_entry_key,
1373 &dot_dot_entry_path,
1374 &dot_dot_de)) != NAME_FOUND) {
1375 pathrelse(&dot_dot_entry_path);
1376 pathrelse(&new_entry_path);
1377 pathrelse(&old_entry_path);
1378 journal_end(&th, old_dir->i_sb, jbegin_count);
1379 reiserfs_write_unlock(old_dir->i_sb);
1380 return -EIO;
1381 }
1382 copy_item_head(&dot_dot_ih,
1383 get_ih(&dot_dot_entry_path));
1384 // node containing ".." gets into transaction
1385 reiserfs_prepare_for_journal(old_inode->i_sb,
1386 dot_dot_de.de_bh, 1);
1387 }
1388 /* we should check seals here, not do
1389 this stuff, yes? Then, having
1390 gathered everything into RAM we
1391 should lock the buffers, yes? -Hans */
Jeff Mahoney0222e652009-03-30 14:02:44 -04001392 /* probably. our rename needs to hold more
1393 ** than one path at once. The seals would
1394 ** have to be written to deal with multi-path
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001395 ** issues -chris
1396 */
1397 /* sanity checking before doing the rename - avoid races many
1398 ** of the above checks could have scheduled. We have to be
1399 ** sure our items haven't been shifted by another process.
1400 */
1401 if (item_moved(&new_entry_ih, &new_entry_path) ||
1402 !entry_points_to_object(new_dentry->d_name.name,
1403 new_dentry->d_name.len,
1404 &new_de, new_dentry_inode) ||
1405 item_moved(&old_entry_ih, &old_entry_path) ||
1406 !entry_points_to_object(old_dentry->d_name.name,
1407 old_dentry->d_name.len,
1408 &old_de, old_inode)) {
1409 reiserfs_restore_prepared_buffer(old_inode->i_sb,
1410 new_de.de_bh);
1411 reiserfs_restore_prepared_buffer(old_inode->i_sb,
1412 old_de.de_bh);
1413 if (S_ISDIR(old_inode_mode))
1414 reiserfs_restore_prepared_buffer(old_inode->
1415 i_sb,
1416 dot_dot_de.
1417 de_bh);
1418 continue;
1419 }
1420 if (S_ISDIR(old_inode_mode)) {
1421 if (item_moved(&dot_dot_ih, &dot_dot_entry_path) ||
1422 !entry_points_to_object("..", 2, &dot_dot_de,
1423 old_dir)) {
1424 reiserfs_restore_prepared_buffer(old_inode->
1425 i_sb,
1426 old_de.de_bh);
1427 reiserfs_restore_prepared_buffer(old_inode->
1428 i_sb,
1429 new_de.de_bh);
1430 reiserfs_restore_prepared_buffer(old_inode->
1431 i_sb,
1432 dot_dot_de.
1433 de_bh);
1434 continue;
1435 }
1436 }
1437
1438 RFALSE(S_ISDIR(old_inode_mode) &&
1439 !buffer_journal_prepared(dot_dot_de.de_bh), "");
1440
1441 break;
1442 }
1443
1444 /* ok, all the changes can be done in one fell swoop when we
1445 have claimed all the buffers needed. */
1446
1447 mark_de_visible(new_de.de_deh + new_de.de_entry_num);
1448 set_ino_in_dir_entry(&new_de, INODE_PKEY(old_inode));
1449 journal_mark_dirty(&th, old_dir->i_sb, new_de.de_bh);
1450
1451 mark_de_hidden(old_de.de_deh + old_de.de_entry_num);
1452 journal_mark_dirty(&th, old_dir->i_sb, old_de.de_bh);
1453 ctime = CURRENT_TIME_SEC;
1454 old_dir->i_ctime = old_dir->i_mtime = ctime;
1455 new_dir->i_ctime = new_dir->i_mtime = ctime;
1456 /* thanks to Alex Adriaanse <alex_a@caltech.edu> for patch which adds ctime update of
1457 renamed object */
1458 old_inode->i_ctime = ctime;
1459
1460 if (new_dentry_inode) {
1461 // adjust link number of the victim
1462 if (S_ISDIR(new_dentry_inode->i_mode)) {
Dave Hansence71ec32006-09-30 23:29:06 -07001463 clear_nlink(new_dentry_inode);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001464 } else {
Dave Hansen9a53c3a2006-09-30 23:29:03 -07001465 drop_nlink(new_dentry_inode);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001466 }
1467 new_dentry_inode->i_ctime = ctime;
1468 savelink = new_dentry_inode->i_nlink;
1469 }
1470
1471 if (S_ISDIR(old_inode_mode)) {
Jeff Mahoney0222e652009-03-30 14:02:44 -04001472 /* adjust ".." of renamed directory */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001473 set_ino_in_dir_entry(&dot_dot_de, INODE_PKEY(new_dir));
1474 journal_mark_dirty(&th, new_dir->i_sb, dot_dot_de.de_bh);
1475
1476 if (!new_dentry_inode)
1477 /* there (in new_dir) was no directory, so it got new link
1478 (".." of renamed directory) */
1479 INC_DIR_INODE_NLINK(new_dir);
1480
1481 /* old directory lost one link - ".. " of renamed directory */
1482 DEC_DIR_INODE_NLINK(old_dir);
1483 }
1484 // looks like in 2.3.99pre3 brelse is atomic. so we can use pathrelse
1485 pathrelse(&new_entry_path);
1486 pathrelse(&dot_dot_entry_path);
1487
1488 // FIXME: this reiserfs_cut_from_item's return value may screw up
1489 // anybody, but it will panic if will not be able to find the
1490 // entry. This needs one more clean up
1491 if (reiserfs_cut_from_item
1492 (&th, &old_entry_path, &(old_de.de_entry_key), old_dir, NULL,
1493 0) < 0)
Jeff Mahoney0030b642009-03-30 14:02:28 -04001494 reiserfs_error(old_dir->i_sb, "vs-7060",
1495 "couldn't not cut old name. Fsck later?");
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001496
1497 old_dir->i_size -= DEH_SIZE + old_de.de_entrylen;
1498
1499 reiserfs_update_sd(&th, old_dir);
1500 reiserfs_update_sd(&th, new_dir);
1501 reiserfs_update_sd(&th, old_inode);
1502
1503 if (new_dentry_inode) {
1504 if (savelink == 0)
1505 add_save_link(&th, new_dentry_inode,
1506 0 /* not truncate */ );
1507 reiserfs_update_sd(&th, new_dentry_inode);
1508 }
1509
1510 retval = journal_end(&th, old_dir->i_sb, jbegin_count);
1511 reiserfs_write_unlock(old_dir->i_sb);
1512 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513}
1514
1515/*
1516 * directories can handle most operations...
1517 */
Arjan van de Venc5ef1c42007-02-12 00:55:40 -08001518const struct inode_operations reiserfs_dir_inode_operations = {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001519 //&reiserfs_dir_operations, /* default_file_ops */
1520 .create = reiserfs_create,
1521 .lookup = reiserfs_lookup,
1522 .link = reiserfs_link,
1523 .unlink = reiserfs_unlink,
1524 .symlink = reiserfs_symlink,
1525 .mkdir = reiserfs_mkdir,
1526 .rmdir = reiserfs_rmdir,
1527 .mknod = reiserfs_mknod,
1528 .rename = reiserfs_rename,
1529 .setattr = reiserfs_setattr,
1530 .setxattr = reiserfs_setxattr,
1531 .getxattr = reiserfs_getxattr,
1532 .listxattr = reiserfs_listxattr,
1533 .removexattr = reiserfs_removexattr,
1534 .permission = reiserfs_permission,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535};
1536
1537/*
1538 * symlink operations.. same as page_symlink_inode_operations, with xattr
1539 * stuff added
1540 */
Arjan van de Venc5ef1c42007-02-12 00:55:40 -08001541const struct inode_operations reiserfs_symlink_inode_operations = {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001542 .readlink = generic_readlink,
1543 .follow_link = page_follow_link_light,
1544 .put_link = page_put_link,
1545 .setattr = reiserfs_setattr,
1546 .setxattr = reiserfs_setxattr,
1547 .getxattr = reiserfs_getxattr,
1548 .listxattr = reiserfs_listxattr,
1549 .removexattr = reiserfs_removexattr,
1550 .permission = reiserfs_permission,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001551
1552};
1553
Linus Torvalds1da177e2005-04-16 15:20:36 -07001554/*
1555 * special file operations.. just xattr/acl stuff
1556 */
Arjan van de Venc5ef1c42007-02-12 00:55:40 -08001557const struct inode_operations reiserfs_special_inode_operations = {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001558 .setattr = reiserfs_setattr,
1559 .setxattr = reiserfs_setxattr,
1560 .getxattr = reiserfs_getxattr,
1561 .listxattr = reiserfs_listxattr,
1562 .removexattr = reiserfs_removexattr,
1563 .permission = reiserfs_permission,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564
1565};