blob: c1add28dd45ec144ec946b3ddba2c06a340af405 [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>
16#include <linux/reiserfs_fs.h>
17#include <linux/reiserfs_acl.h>
18#include <linux/reiserfs_xattr.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <linux/quotaops.h>
20
Dave Hansend8c76e62006-09-30 23:29:04 -070021#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 -070022#define DEC_DIR_INODE_NLINK(i) if (i->i_nlink != 1) drop_nlink(i);
Linus Torvalds1da177e2005-04-16 15:20:36 -070023
24// directory item contains array of entry headers. This performs
25// binary search through that array
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070026static int bin_search_in_dir_item(struct reiserfs_dir_entry *de, loff_t off)
Linus Torvalds1da177e2005-04-16 15:20:36 -070027{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070028 struct item_head *ih = de->de_ih;
29 struct reiserfs_de_head *deh = de->de_deh;
30 int rbound, lbound, j;
Linus Torvalds1da177e2005-04-16 15:20:36 -070031
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070032 lbound = 0;
33 rbound = I_ENTRY_COUNT(ih) - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -070034
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070035 for (j = (rbound + lbound) / 2; lbound <= rbound;
36 j = (rbound + lbound) / 2) {
37 if (off < deh_offset(deh + j)) {
38 rbound = j - 1;
39 continue;
40 }
41 if (off > deh_offset(deh + j)) {
42 lbound = j + 1;
43 continue;
44 }
45 // this is not name found, but matched third key component
46 de->de_entry_num = j;
47 return NAME_FOUND;
Linus Torvalds1da177e2005-04-16 15:20:36 -070048 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070049
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070050 de->de_entry_num = lbound;
51 return NAME_NOT_FOUND;
Linus Torvalds1da177e2005-04-16 15:20:36 -070052}
53
Linus Torvalds1da177e2005-04-16 15:20:36 -070054// comment? maybe something like set de to point to what the path points to?
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070055static inline void set_de_item_location(struct reiserfs_dir_entry *de,
Josef "Jeff" Sipekfec6d052006-12-08 02:36:32 -080056 struct treepath *path)
Linus Torvalds1da177e2005-04-16 15:20:36 -070057{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070058 de->de_bh = get_last_bh(path);
59 de->de_ih = get_ih(path);
60 de->de_deh = B_I_DEH(de->de_bh, de->de_ih);
61 de->de_item_num = PATH_LAST_POSITION(path);
62}
Linus Torvalds1da177e2005-04-16 15:20:36 -070063
64// de_bh, de_ih, de_deh (points to first element of array), de_item_num is set
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070065inline void set_de_name_and_namelen(struct reiserfs_dir_entry *de)
Linus Torvalds1da177e2005-04-16 15:20:36 -070066{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070067 struct reiserfs_de_head *deh = de->de_deh + de->de_entry_num;
Linus Torvalds1da177e2005-04-16 15:20:36 -070068
Eric Sesterhenn14a61442006-10-03 23:36:38 +020069 BUG_ON(de->de_entry_num >= ih_entry_count(de->de_ih));
Linus Torvalds1da177e2005-04-16 15:20:36 -070070
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070071 de->de_entrylen = entry_length(de->de_bh, de->de_ih, de->de_entry_num);
72 de->de_namelen = de->de_entrylen - (de_with_sd(deh) ? SD_SIZE : 0);
73 de->de_name = B_I_PITEM(de->de_bh, de->de_ih) + deh_location(deh);
74 if (de->de_name[de->de_namelen - 1] == 0)
75 de->de_namelen = strlen(de->de_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -070076}
77
Linus Torvalds1da177e2005-04-16 15:20:36 -070078// what entry points to
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070079static inline void set_de_object_key(struct reiserfs_dir_entry *de)
Linus Torvalds1da177e2005-04-16 15:20:36 -070080{
Eric Sesterhenn14a61442006-10-03 23:36:38 +020081 BUG_ON(de->de_entry_num >= ih_entry_count(de->de_ih));
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070082 de->de_dir_id = deh_dir_id(&(de->de_deh[de->de_entry_num]));
83 de->de_objectid = deh_objectid(&(de->de_deh[de->de_entry_num]));
Linus Torvalds1da177e2005-04-16 15:20:36 -070084}
85
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070086static inline void store_de_entry_key(struct reiserfs_dir_entry *de)
Linus Torvalds1da177e2005-04-16 15:20:36 -070087{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070088 struct reiserfs_de_head *deh = de->de_deh + de->de_entry_num;
Linus Torvalds1da177e2005-04-16 15:20:36 -070089
Eric Sesterhenn14a61442006-10-03 23:36:38 +020090 BUG_ON(de->de_entry_num >= ih_entry_count(de->de_ih));
Linus Torvalds1da177e2005-04-16 15:20:36 -070091
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070092 /* store key of the found entry */
93 de->de_entry_key.version = KEY_FORMAT_3_5;
94 de->de_entry_key.on_disk_key.k_dir_id =
95 le32_to_cpu(de->de_ih->ih_key.k_dir_id);
96 de->de_entry_key.on_disk_key.k_objectid =
97 le32_to_cpu(de->de_ih->ih_key.k_objectid);
98 set_cpu_key_k_offset(&(de->de_entry_key), deh_offset(deh));
99 set_cpu_key_k_type(&(de->de_entry_key), TYPE_DIRENTRY);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100}
101
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102/* We assign a key to each directory item, and place multiple entries
103in a single directory item. A directory item has a key equal to the
104key of the first directory entry in it.
105
106This function first calls search_by_key, then, if item whose first
107entry matches is not found it looks for the entry inside directory
108item found by search_by_key. Fills the path to the entry, and to the
109entry position in the item
110
111*/
112
113/* The function is NOT SCHEDULE-SAFE! */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700114int search_by_entry_key(struct super_block *sb, const struct cpu_key *key,
Josef "Jeff" Sipekfec6d052006-12-08 02:36:32 -0800115 struct treepath *path, struct reiserfs_dir_entry *de)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700117 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700119 retval = search_item(sb, key, path);
120 switch (retval) {
121 case ITEM_NOT_FOUND:
122 if (!PATH_LAST_POSITION(path)) {
123 reiserfs_warning(sb,
124 "vs-7000: search_by_entry_key: search_by_key returned item position == 0");
125 pathrelse(path);
126 return IO_ERROR;
127 }
128 PATH_LAST_POSITION(path)--;
129
130 case ITEM_FOUND:
131 break;
132
133 case IO_ERROR:
134 return retval;
135
136 default:
137 pathrelse(path);
138 reiserfs_warning(sb,
139 "vs-7002: search_by_entry_key: no path to here");
140 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);
149 reiserfs_panic(sb,
150 "vs-7005: search_by_entry_key: found item %h is not directory item or "
151 "does not belong to the same directory as key %K",
152 de->de_ih, key);
153 }
154#endif /* CONFIG_REISERFS_CHECK */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700156 /* binary search in directory item by third componen t of the
157 key. sets de->de_entry_num of de */
158 retval = bin_search_in_dir_item(de, cpu_key_k_offset(key));
159 path->pos_in_item = de->de_entry_num;
160 if (retval != NAME_NOT_FOUND) {
161 // ugly, but rename needs de_bh, de_deh, de_name, de_namelen, de_objectid set
162 set_de_name_and_namelen(de);
163 set_de_object_key(de);
164 }
165 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166}
167
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168/* Keyed 32-bit hash function using TEA in a Davis-Meyer function */
169
170/* The third component is hashed, and you can choose from more than
171 one hash function. Per directory hashes are not yet implemented
172 but are thought about. This function should be moved to hashes.c
173 Jedi, please do so. -Hans */
174
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700175static __u32 get_third_component(struct super_block *s,
176 const char *name, int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700178 __u32 res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700180 if (!len || (len == 1 && name[0] == '.'))
181 return DOT_OFFSET;
182 if (len == 2 && name[0] == '.' && name[1] == '.')
183 return DOT_DOT_OFFSET;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700185 res = REISERFS_SB(s)->s_hash_function(name, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700187 // take bits from 7-th to 30-th including both bounds
188 res = GET_HASH_VALUE(res);
189 if (res == 0)
190 // needed to have no names before "." and ".." those have hash
191 // value == 0 and generation conters 1 and 2 accordingly
192 res = 128;
193 return res + MAX_GENERATION_NUMBER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194}
195
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700196static int reiserfs_match(struct reiserfs_dir_entry *de,
197 const char *name, int namelen)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700199 int retval = NAME_NOT_FOUND;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700201 if ((namelen == de->de_namelen) &&
202 !memcmp(de->de_name, name, de->de_namelen))
203 retval =
204 (de_visible(de->de_deh + de->de_entry_num) ? NAME_FOUND :
205 NAME_FOUND_INVISIBLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700207 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208}
209
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210/* de's de_bh, de_ih, de_deh, de_item_num, de_entry_num are set already */
211
212 /* used when hash collisions exist */
213
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700214static int linear_search_in_dir_item(struct cpu_key *key,
215 struct reiserfs_dir_entry *de,
216 const char *name, int namelen)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700218 struct reiserfs_de_head *deh = de->de_deh;
219 int retval;
220 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700222 i = de->de_entry_num;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700224 if (i == I_ENTRY_COUNT(de->de_ih) ||
225 GET_HASH_VALUE(deh_offset(deh + i)) !=
226 GET_HASH_VALUE(cpu_key_k_offset(key))) {
227 i--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700230 RFALSE(de->de_deh != B_I_DEH(de->de_bh, de->de_ih),
231 "vs-7010: array of entry headers not found");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700233 deh += i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700235 for (; i >= 0; i--, deh--) {
236 if (GET_HASH_VALUE(deh_offset(deh)) !=
237 GET_HASH_VALUE(cpu_key_k_offset(key))) {
238 // hash value does not match, no need to check whole name
239 return NAME_NOT_FOUND;
240 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700242 /* mark, that this generation number is used */
243 if (de->de_gen_number_bit_string)
244 set_bit(GET_GENERATION_NUMBER(deh_offset(deh)),
Jeff Mahoney3af1efe2006-03-02 13:25:26 -0500245 de->de_gen_number_bit_string);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700247 // calculate pointer to name and namelen
248 de->de_entry_num = i;
249 set_de_name_and_namelen(de);
250
251 if ((retval =
252 reiserfs_match(de, name, namelen)) != NAME_NOT_FOUND) {
253 // de's de_name, de_namelen, de_recordlen are set. Fill the rest:
254
255 // key of pointed object
256 set_de_object_key(de);
257
258 store_de_entry_key(de);
259
260 // retval can be NAME_FOUND or NAME_FOUND_INVISIBLE
261 return retval;
262 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700265 if (GET_GENERATION_NUMBER(le_ih_k_offset(de->de_ih)) == 0)
266 /* we have reached left most entry in the node. In common we
267 have to go to the left neighbor, but if generation counter
268 is 0 already, we know for sure, that there is no name with
269 the same hash value */
270 // FIXME: this work correctly only because hash value can not
271 // be 0. Btw, in case of Yura's hash it is probably possible,
272 // so, this is a bug
273 return NAME_NOT_FOUND;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700275 RFALSE(de->de_item_num,
276 "vs-7015: two diritems of the same directory in one node?");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700278 return GOTO_PREVIOUS_ITEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279}
280
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281// may return NAME_FOUND, NAME_FOUND_INVISIBLE, NAME_NOT_FOUND
282// FIXME: should add something like IOERROR
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700283static int reiserfs_find_entry(struct inode *dir, const char *name, int namelen,
Josef "Jeff" Sipekfec6d052006-12-08 02:36:32 -0800284 struct treepath *path_to_entry,
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700285 struct reiserfs_dir_entry *de)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700287 struct cpu_key key_to_search;
288 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700290 if (namelen > REISERFS_MAX_NAME(dir->i_sb->s_blocksize))
291 return NAME_NOT_FOUND;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700293 /* we will search for this key in the tree */
294 make_cpu_key(&key_to_search, dir,
295 get_third_component(dir->i_sb, name, namelen),
296 TYPE_DIRENTRY, 3);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700298 while (1) {
299 retval =
300 search_by_entry_key(dir->i_sb, &key_to_search,
301 path_to_entry, de);
302 if (retval == IO_ERROR) {
303 reiserfs_warning(dir->i_sb, "zam-7001: io error in %s",
Harvey Harrisonfbe54982008-04-28 02:16:22 -0700304 __func__);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700305 return IO_ERROR;
306 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700308 /* compare names for all entries having given hash value */
309 retval =
310 linear_search_in_dir_item(&key_to_search, de, name,
311 namelen);
312 if (retval != GOTO_PREVIOUS_ITEM) {
313 /* there is no need to scan directory anymore. Given entry found or does not exist */
314 path_to_entry->pos_in_item = de->de_entry_num;
315 return retval;
316 }
317
318 /* there is left neighboring item of this directory and given entry can be there */
319 set_cpu_key_k_offset(&key_to_search,
320 le_ih_k_offset(de->de_ih) - 1);
321 pathrelse(path_to_entry);
322
323 } /* while (1) */
324}
325
326static struct dentry *reiserfs_lookup(struct inode *dir, struct dentry *dentry,
327 struct nameidata *nd)
328{
329 int retval;
330 struct inode *inode = NULL;
331 struct reiserfs_dir_entry de;
332 INITIALIZE_PATH(path_to_entry);
333
334 if (REISERFS_MAX_NAME(dir->i_sb->s_blocksize) < dentry->d_name.len)
335 return ERR_PTR(-ENAMETOOLONG);
336
337 reiserfs_write_lock(dir->i_sb);
338 de.de_gen_number_bit_string = NULL;
339 retval =
340 reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len,
341 &path_to_entry, &de);
342 pathrelse(&path_to_entry);
343 if (retval == NAME_FOUND) {
344 /* Hide the .reiserfs_priv directory */
345 if (reiserfs_xattrs(dir->i_sb) &&
346 !old_format_only(dir->i_sb) &&
347 REISERFS_SB(dir->i_sb)->priv_root &&
348 REISERFS_SB(dir->i_sb)->priv_root->d_inode &&
349 de.de_objectid ==
350 le32_to_cpu(INODE_PKEY
351 (REISERFS_SB(dir->i_sb)->priv_root->d_inode)->
352 k_objectid)) {
353 reiserfs_write_unlock(dir->i_sb);
354 return ERR_PTR(-EACCES);
355 }
356
357 inode =
358 reiserfs_iget(dir->i_sb, (struct cpu_key *)&(de.de_dir_id));
359 if (!inode || IS_ERR(inode)) {
360 reiserfs_write_unlock(dir->i_sb);
361 return ERR_PTR(-EACCES);
362 }
363
364 /* Propogate the priv_object flag so we know we're in the priv tree */
365 if (is_reiserfs_priv_object(dir))
366 reiserfs_mark_inode_private(inode);
367 }
368 reiserfs_write_unlock(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 if (retval == IO_ERROR) {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700370 return ERR_PTR(-EIO);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 }
372
Pekka Enbergd9975d62006-01-14 13:21:09 -0800373 return d_splice_alias(inode, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374}
375
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376/*
377** looks up the dentry of the parent directory for child.
378** taken from ext2_get_parent
379*/
380struct dentry *reiserfs_get_parent(struct dentry *child)
381{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700382 int retval;
383 struct inode *inode = NULL;
384 struct reiserfs_dir_entry de;
385 INITIALIZE_PATH(path_to_entry);
386 struct dentry *parent;
387 struct inode *dir = child->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700389 if (dir->i_nlink == 0) {
390 return ERR_PTR(-ENOENT);
391 }
392 de.de_gen_number_bit_string = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700394 reiserfs_write_lock(dir->i_sb);
395 retval = reiserfs_find_entry(dir, "..", 2, &path_to_entry, &de);
396 pathrelse(&path_to_entry);
397 if (retval != NAME_FOUND) {
398 reiserfs_write_unlock(dir->i_sb);
399 return ERR_PTR(-ENOENT);
400 }
401 inode = reiserfs_iget(dir->i_sb, (struct cpu_key *)&(de.de_dir_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 reiserfs_write_unlock(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700404 if (!inode || IS_ERR(inode)) {
405 return ERR_PTR(-EACCES);
406 }
407 parent = d_alloc_anon(inode);
408 if (!parent) {
409 iput(inode);
410 parent = ERR_PTR(-ENOMEM);
411 }
412 return parent;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413}
414
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415/* add entry to the directory (entry can be hidden).
416
417insert definition of when hidden directories are used here -Hans
418
419 Does not mark dir inode dirty, do it after successesfull call to it */
420
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700421static int reiserfs_add_entry(struct reiserfs_transaction_handle *th,
422 struct inode *dir, const char *name, int namelen,
423 struct inode *inode, int visible)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700425 struct cpu_key entry_key;
426 struct reiserfs_de_head *deh;
427 INITIALIZE_PATH(path);
428 struct reiserfs_dir_entry de;
Jeff Mahoney3af1efe2006-03-02 13:25:26 -0500429 DECLARE_BITMAP(bit_string, MAX_GENERATION_NUMBER + 1);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700430 int gen_number;
431 char small_buf[32 + DEH_SIZE]; /* 48 bytes now and we avoid kmalloc
432 if we create file with short name */
433 char *buffer;
434 int buflen, paste_size;
435 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700437 BUG_ON(!th->t_trans_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700439 /* cannot allow items to be added into a busy deleted directory */
440 if (!namelen)
441 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700443 if (namelen > REISERFS_MAX_NAME(dir->i_sb->s_blocksize))
444 return -ENAMETOOLONG;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700446 /* each entry has unique key. compose it */
447 make_cpu_key(&entry_key, dir,
448 get_third_component(dir->i_sb, name, namelen),
449 TYPE_DIRENTRY, 3);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700451 /* get memory for composing the entry */
452 buflen = DEH_SIZE + ROUND_UP(namelen);
453 if (buflen > sizeof(small_buf)) {
Pekka Enbergd739b422006-02-01 03:06:43 -0800454 buffer = kmalloc(buflen, GFP_NOFS);
Al Viro9dce07f2008-03-29 03:07:28 +0000455 if (!buffer)
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700456 return -ENOMEM;
457 } else
458 buffer = small_buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700460 paste_size =
461 (get_inode_sd_version(dir) ==
462 STAT_DATA_V1) ? (DEH_SIZE + namelen) : buflen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700464 /* fill buffer : directory entry head, name[, dir objectid | , stat data | ,stat data, dir objectid ] */
465 deh = (struct reiserfs_de_head *)buffer;
466 deh->deh_location = 0; /* JDM Endian safe if 0 */
467 put_deh_offset(deh, cpu_key_k_offset(&entry_key));
468 deh->deh_state = 0; /* JDM Endian safe if 0 */
469 /* put key (ino analog) to de */
470 deh->deh_dir_id = INODE_PKEY(inode)->k_dir_id; /* safe: k_dir_id is le */
471 deh->deh_objectid = INODE_PKEY(inode)->k_objectid; /* safe: k_objectid is le */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700473 /* copy name */
474 memcpy((char *)(deh + 1), name, namelen);
475 /* padd by 0s to the 4 byte boundary */
476 padd_item((char *)(deh + 1), ROUND_UP(namelen), namelen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700478 /* entry is ready to be pasted into tree, set 'visibility' and 'stat data in entry' attributes */
479 mark_de_without_sd(deh);
480 visible ? mark_de_visible(deh) : mark_de_hidden(deh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700482 /* find the proper place for the new entry */
483 memset(bit_string, 0, sizeof(bit_string));
Jeff Mahoney3af1efe2006-03-02 13:25:26 -0500484 de.de_gen_number_bit_string = bit_string;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700485 retval = reiserfs_find_entry(dir, name, namelen, &path, &de);
486 if (retval != NAME_NOT_FOUND) {
487 if (buffer != small_buf)
Pekka Enbergd739b422006-02-01 03:06:43 -0800488 kfree(buffer);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700489 pathrelse(&path);
490
491 if (retval == IO_ERROR) {
492 return -EIO;
493 }
494
495 if (retval != NAME_FOUND) {
496 reiserfs_warning(dir->i_sb,
497 "zam-7002:%s: \"reiserfs_find_entry\" "
498 "has returned unexpected value (%d)",
Harvey Harrisonfbe54982008-04-28 02:16:22 -0700499 __func__, retval);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700500 }
501
502 return -EEXIST;
503 }
504
505 gen_number =
Jeff Mahoney3af1efe2006-03-02 13:25:26 -0500506 find_first_zero_bit(bit_string,
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700507 MAX_GENERATION_NUMBER + 1);
508 if (gen_number > MAX_GENERATION_NUMBER) {
509 /* there is no free generation number */
510 reiserfs_warning(dir->i_sb,
511 "reiserfs_add_entry: Congratulations! we have got hash function screwed up");
512 if (buffer != small_buf)
Pekka Enbergd739b422006-02-01 03:06:43 -0800513 kfree(buffer);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700514 pathrelse(&path);
515 return -EBUSY;
516 }
517 /* adjust offset of directory enrty */
518 put_deh_offset(deh, SET_GENERATION_NUMBER(deh_offset(deh), gen_number));
519 set_cpu_key_k_offset(&entry_key, deh_offset(deh));
520
521 /* update max-hash-collisions counter in reiserfs_sb_info */
522 PROC_INFO_MAX(th->t_super, max_hash_collisions, gen_number);
523
524 if (gen_number != 0) { /* we need to re-search for the insertion point */
525 if (search_by_entry_key(dir->i_sb, &entry_key, &path, &de) !=
526 NAME_NOT_FOUND) {
527 reiserfs_warning(dir->i_sb,
528 "vs-7032: reiserfs_add_entry: "
529 "entry with this key (%K) already exists",
530 &entry_key);
531
532 if (buffer != small_buf)
Pekka Enbergd739b422006-02-01 03:06:43 -0800533 kfree(buffer);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700534 pathrelse(&path);
535 return -EBUSY;
536 }
537 }
538
539 /* perform the insertion of the entry that we have prepared */
540 retval =
541 reiserfs_paste_into_item(th, &path, &entry_key, dir, buffer,
542 paste_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 if (buffer != small_buf)
Pekka Enbergd739b422006-02-01 03:06:43 -0800544 kfree(buffer);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700545 if (retval) {
546 reiserfs_check_path(&path);
547 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548 }
549
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700550 dir->i_size += paste_size;
551 dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
552 if (!S_ISDIR(inode->i_mode) && visible)
553 // reiserfs_mkdir or reiserfs_rename will do that by itself
554 reiserfs_update_sd(th, dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700556 reiserfs_check_path(&path);
557 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558}
559
560/* quota utility function, call if you've had to abort after calling
561** new_inode_init, and have not called reiserfs_new_inode yet.
562** This should only be called on inodes that do not have stat data
563** inserted into the tree yet.
564*/
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700565static int drop_new_inode(struct inode *inode)
566{
567 DQUOT_DROP(inode);
568 make_bad_inode(inode);
569 inode->i_flags |= S_NOQUOTA;
570 iput(inode);
571 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572}
573
574/* utility function that does setup for reiserfs_new_inode.
575** DQUOT_INIT needs lots of credits so it's better to have it
576** outside of a transaction, so we had to pull some bits of
577** reiserfs_new_inode out into this func.
578*/
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700579static int new_inode_init(struct inode *inode, struct inode *dir, int mode)
580{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700582 /* the quota init calls have to know who to charge the quota to, so
583 ** we have to set uid and gid here
584 */
585 inode->i_uid = current->fsuid;
586 inode->i_mode = mode;
Jan Kara1b0a74d2005-08-13 13:15:34 +0200587 /* Make inode invalid - just in case we are going to drop it before
588 * the initialization happens */
589 INODE_PKEY(inode)->k_objectid = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700591 if (dir->i_mode & S_ISGID) {
592 inode->i_gid = dir->i_gid;
593 if (S_ISDIR(mode))
594 inode->i_mode |= S_ISGID;
595 } else {
596 inode->i_gid = current->fsgid;
597 }
598 DQUOT_INIT(inode);
599 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600}
601
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700602static int reiserfs_create(struct inode *dir, struct dentry *dentry, int mode,
603 struct nameidata *nd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700605 int retval;
606 struct inode *inode;
607 /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
608 int jbegin_count =
609 JOURNAL_PER_BALANCE_CNT * 2 +
610 2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
611 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
612 struct reiserfs_transaction_handle th;
613 int locked;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700615 if (!(inode = new_inode(dir->i_sb))) {
616 return -ENOMEM;
617 }
618 new_inode_init(inode, dir, mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700620 locked = reiserfs_cache_default_acl(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700622 reiserfs_write_lock(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700624 if (locked)
625 reiserfs_write_lock_xattrs(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700627 retval = journal_begin(&th, dir->i_sb, jbegin_count);
628 if (retval) {
629 drop_new_inode(inode);
630 goto out_failed;
631 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700633 retval =
634 reiserfs_new_inode(&th, dir, mode, NULL, 0 /*i_size */ , dentry,
635 inode);
636 if (retval)
637 goto out_failed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700639 if (locked) {
640 reiserfs_write_unlock_xattrs(dir->i_sb);
641 locked = 0;
642 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700644 inode->i_op = &reiserfs_file_inode_operations;
645 inode->i_fop = &reiserfs_file_operations;
646 inode->i_mapping->a_ops = &reiserfs_address_space_operations;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700648 retval =
649 reiserfs_add_entry(&th, dir, dentry->d_name.name,
650 dentry->d_name.len, inode, 1 /*visible */ );
651 if (retval) {
652 int err;
653 inode->i_nlink--;
654 reiserfs_update_sd(&th, inode);
655 err = journal_end(&th, dir->i_sb, jbegin_count);
656 if (err)
657 retval = err;
658 iput(inode);
659 goto out_failed;
660 }
661 reiserfs_update_inode_transaction(inode);
662 reiserfs_update_inode_transaction(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700664 d_instantiate(dentry, inode);
665 retval = journal_end(&th, dir->i_sb, jbegin_count);
666
667 out_failed:
668 if (locked)
669 reiserfs_write_unlock_xattrs(dir->i_sb);
670 reiserfs_write_unlock(dir->i_sb);
671 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672}
673
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700674static int reiserfs_mknod(struct inode *dir, struct dentry *dentry, int mode,
675 dev_t rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700677 int retval;
678 struct inode *inode;
679 struct reiserfs_transaction_handle th;
680 /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
681 int jbegin_count =
682 JOURNAL_PER_BALANCE_CNT * 3 +
683 2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
684 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
685 int locked;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700687 if (!new_valid_dev(rdev))
688 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700690 if (!(inode = new_inode(dir->i_sb))) {
691 return -ENOMEM;
692 }
693 new_inode_init(inode, dir, mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700695 locked = reiserfs_cache_default_acl(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700697 reiserfs_write_lock(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700699 if (locked)
700 reiserfs_write_lock_xattrs(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700702 retval = journal_begin(&th, dir->i_sb, jbegin_count);
703 if (retval) {
704 drop_new_inode(inode);
705 goto out_failed;
706 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700708 retval =
709 reiserfs_new_inode(&th, dir, mode, NULL, 0 /*i_size */ , dentry,
710 inode);
711 if (retval) {
712 goto out_failed;
713 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700715 if (locked) {
716 reiserfs_write_unlock_xattrs(dir->i_sb);
717 locked = 0;
718 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700720 inode->i_op = &reiserfs_special_inode_operations;
721 init_special_inode(inode, inode->i_mode, rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700723 //FIXME: needed for block and char devices only
724 reiserfs_update_sd(&th, inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700726 reiserfs_update_inode_transaction(inode);
727 reiserfs_update_inode_transaction(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700729 retval =
730 reiserfs_add_entry(&th, dir, dentry->d_name.name,
731 dentry->d_name.len, inode, 1 /*visible */ );
732 if (retval) {
733 int err;
734 inode->i_nlink--;
735 reiserfs_update_sd(&th, inode);
736 err = journal_end(&th, dir->i_sb, jbegin_count);
737 if (err)
738 retval = err;
739 iput(inode);
740 goto out_failed;
741 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700743 d_instantiate(dentry, inode);
744 retval = journal_end(&th, dir->i_sb, jbegin_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700746 out_failed:
747 if (locked)
748 reiserfs_write_unlock_xattrs(dir->i_sb);
749 reiserfs_write_unlock(dir->i_sb);
750 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751}
752
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700753static int reiserfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700755 int retval;
756 struct inode *inode;
757 struct reiserfs_transaction_handle th;
758 /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
759 int jbegin_count =
760 JOURNAL_PER_BALANCE_CNT * 3 +
761 2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
762 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
763 int locked;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764
765#ifdef DISPLACE_NEW_PACKING_LOCALITIES
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700766 /* set flag that new packing locality created and new blocks for the content * of that directory are not displaced yet */
767 REISERFS_I(dir)->new_packing_locality = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768#endif
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700769 mode = S_IFDIR | mode;
770 if (!(inode = new_inode(dir->i_sb))) {
771 return -ENOMEM;
772 }
773 new_inode_init(inode, dir, mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700775 locked = reiserfs_cache_default_acl(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700777 reiserfs_write_lock(dir->i_sb);
778 if (locked)
779 reiserfs_write_lock_xattrs(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700781 retval = journal_begin(&th, dir->i_sb, jbegin_count);
782 if (retval) {
783 drop_new_inode(inode);
784 goto out_failed;
785 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700787 /* inc the link count now, so another writer doesn't overflow it while
788 ** we sleep later on.
789 */
790 INC_DIR_INODE_NLINK(dir)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700792 retval = reiserfs_new_inode(&th, dir, mode, NULL /*symlink */ ,
793 old_format_only(dir->i_sb) ?
794 EMPTY_DIR_SIZE_V1 : EMPTY_DIR_SIZE,
795 dentry, inode);
796 if (retval) {
797 dir->i_nlink--;
798 goto out_failed;
799 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700801 if (locked) {
802 reiserfs_write_unlock_xattrs(dir->i_sb);
803 locked = 0;
804 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700806 reiserfs_update_inode_transaction(inode);
807 reiserfs_update_inode_transaction(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700809 inode->i_op = &reiserfs_dir_inode_operations;
810 inode->i_fop = &reiserfs_dir_operations;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700812 // note, _this_ add_entry will not update dir's stat data
813 retval =
814 reiserfs_add_entry(&th, dir, dentry->d_name.name,
815 dentry->d_name.len, inode, 1 /*visible */ );
816 if (retval) {
817 int err;
818 inode->i_nlink = 0;
819 DEC_DIR_INODE_NLINK(dir);
820 reiserfs_update_sd(&th, inode);
821 err = journal_end(&th, dir->i_sb, jbegin_count);
822 if (err)
823 retval = err;
824 iput(inode);
825 goto out_failed;
826 }
827 // the above add_entry did not update dir's stat data
828 reiserfs_update_sd(&th, dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700830 d_instantiate(dentry, inode);
831 retval = journal_end(&th, dir->i_sb, jbegin_count);
832 out_failed:
833 if (locked)
834 reiserfs_write_unlock_xattrs(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835 reiserfs_write_unlock(dir->i_sb);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700836 return retval;
837}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700839static inline int reiserfs_empty_dir(struct inode *inode)
840{
841 /* we can cheat because an old format dir cannot have
842 ** EMPTY_DIR_SIZE, and a new format dir cannot have
843 ** EMPTY_DIR_SIZE_V1. So, if the inode is either size,
844 ** regardless of disk format version, the directory is empty.
845 */
846 if (inode->i_size != EMPTY_DIR_SIZE &&
847 inode->i_size != EMPTY_DIR_SIZE_V1) {
848 return 0;
849 }
850 return 1;
851}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700853static int reiserfs_rmdir(struct inode *dir, struct dentry *dentry)
854{
855 int retval, err;
856 struct inode *inode;
857 struct reiserfs_transaction_handle th;
858 int jbegin_count;
859 INITIALIZE_PATH(path);
860 struct reiserfs_dir_entry de;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700862 /* we will be doing 2 balancings and update 2 stat data, we change quotas
863 * of the owner of the directory and of the owner of the parent directory.
864 * The quota structure is possibly deleted only on last iput => outside
865 * of this transaction */
866 jbegin_count =
867 JOURNAL_PER_BALANCE_CNT * 2 + 2 +
868 4 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700870 reiserfs_write_lock(dir->i_sb);
871 retval = journal_begin(&th, dir->i_sb, jbegin_count);
872 if (retval)
873 goto out_rmdir;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700875 de.de_gen_number_bit_string = NULL;
876 if ((retval =
877 reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len,
878 &path, &de)) == NAME_NOT_FOUND) {
879 retval = -ENOENT;
880 goto end_rmdir;
881 } else if (retval == IO_ERROR) {
882 retval = -EIO;
883 goto end_rmdir;
884 }
885
886 inode = dentry->d_inode;
887
888 reiserfs_update_inode_transaction(inode);
889 reiserfs_update_inode_transaction(dir);
890
891 if (de.de_objectid != inode->i_ino) {
892 // FIXME: compare key of an object and a key found in the
893 // entry
894 retval = -EIO;
895 goto end_rmdir;
896 }
897 if (!reiserfs_empty_dir(inode)) {
898 retval = -ENOTEMPTY;
899 goto end_rmdir;
900 }
901
902 /* cut entry from dir directory */
903 retval = reiserfs_cut_from_item(&th, &path, &(de.de_entry_key), dir, NULL, /* page */
904 0 /*new file size - not used here */ );
905 if (retval < 0)
906 goto end_rmdir;
907
908 if (inode->i_nlink != 2 && inode->i_nlink != 1)
909 reiserfs_warning(inode->i_sb, "%s: empty directory has nlink "
Harvey Harrisonfbe54982008-04-28 02:16:22 -0700910 "!= 2 (%d)", __func__, inode->i_nlink);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700911
Dave Hansence71ec32006-09-30 23:29:06 -0700912 clear_nlink(inode);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700913 inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME_SEC;
914 reiserfs_update_sd(&th, inode);
915
916 DEC_DIR_INODE_NLINK(dir)
917 dir->i_size -= (DEH_SIZE + de.de_entrylen);
918 reiserfs_update_sd(&th, dir);
919
920 /* prevent empty directory from getting lost */
921 add_save_link(&th, inode, 0 /* not truncate */ );
922
923 retval = journal_end(&th, dir->i_sb, jbegin_count);
924 reiserfs_check_path(&path);
925 out_rmdir:
926 reiserfs_write_unlock(dir->i_sb);
927 return retval;
928
929 end_rmdir:
930 /* we must release path, because we did not call
931 reiserfs_cut_from_item, or reiserfs_cut_from_item does not
932 release path if operation was not complete */
933 pathrelse(&path);
934 err = journal_end(&th, dir->i_sb, jbegin_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935 reiserfs_write_unlock(dir->i_sb);
936 return err ? err : retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937}
938
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700939static int reiserfs_unlink(struct inode *dir, struct dentry *dentry)
940{
941 int retval, err;
942 struct inode *inode;
943 struct reiserfs_dir_entry de;
944 INITIALIZE_PATH(path);
945 struct reiserfs_transaction_handle th;
946 int jbegin_count;
947 unsigned long savelink;
948
949 inode = dentry->d_inode;
950
951 /* in this transaction we can be doing at max two balancings and update
952 * two stat datas, we change quotas of the owner of the directory and of
953 * the owner of the parent directory. The quota structure is possibly
954 * deleted only on iput => outside of this transaction */
955 jbegin_count =
956 JOURNAL_PER_BALANCE_CNT * 2 + 2 +
957 4 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);
958
959 reiserfs_write_lock(dir->i_sb);
960 retval = journal_begin(&th, dir->i_sb, jbegin_count);
961 if (retval)
962 goto out_unlink;
963
964 de.de_gen_number_bit_string = NULL;
965 if ((retval =
966 reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len,
967 &path, &de)) == NAME_NOT_FOUND) {
968 retval = -ENOENT;
969 goto end_unlink;
970 } else if (retval == IO_ERROR) {
971 retval = -EIO;
972 goto end_unlink;
973 }
974
975 reiserfs_update_inode_transaction(inode);
976 reiserfs_update_inode_transaction(dir);
977
978 if (de.de_objectid != inode->i_ino) {
979 // FIXME: compare key of an object and a key found in the
980 // entry
981 retval = -EIO;
982 goto end_unlink;
983 }
984
985 if (!inode->i_nlink) {
986 reiserfs_warning(inode->i_sb, "%s: deleting nonexistent file "
Harvey Harrisonfbe54982008-04-28 02:16:22 -0700987 "(%s:%lu), %d", __func__,
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700988 reiserfs_bdevname(inode->i_sb), inode->i_ino,
989 inode->i_nlink);
990 inode->i_nlink = 1;
991 }
992
Dave Hansen9a53c3a2006-09-30 23:29:03 -0700993 drop_nlink(inode);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700994
995 /*
996 * we schedule before doing the add_save_link call, save the link
997 * count so we don't race
998 */
999 savelink = inode->i_nlink;
1000
1001 retval =
1002 reiserfs_cut_from_item(&th, &path, &(de.de_entry_key), dir, NULL,
1003 0);
1004 if (retval < 0) {
Dave Hansend8c76e62006-09-30 23:29:04 -07001005 inc_nlink(inode);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001006 goto end_unlink;
1007 }
1008 inode->i_ctime = CURRENT_TIME_SEC;
1009 reiserfs_update_sd(&th, inode);
1010
1011 dir->i_size -= (de.de_entrylen + DEH_SIZE);
1012 dir->i_ctime = dir->i_mtime = CURRENT_TIME_SEC;
1013 reiserfs_update_sd(&th, dir);
1014
1015 if (!savelink)
1016 /* prevent file from getting lost */
1017 add_save_link(&th, inode, 0 /* not truncate */ );
1018
1019 retval = journal_end(&th, dir->i_sb, jbegin_count);
1020 reiserfs_check_path(&path);
1021 reiserfs_write_unlock(dir->i_sb);
1022 return retval;
1023
1024 end_unlink:
1025 pathrelse(&path);
1026 err = journal_end(&th, dir->i_sb, jbegin_count);
1027 reiserfs_check_path(&path);
1028 if (err)
1029 retval = err;
1030 out_unlink:
1031 reiserfs_write_unlock(dir->i_sb);
1032 return retval;
1033}
1034
1035static int reiserfs_symlink(struct inode *parent_dir,
1036 struct dentry *dentry, const char *symname)
1037{
1038 int retval;
1039 struct inode *inode;
1040 char *name;
1041 int item_len;
1042 struct reiserfs_transaction_handle th;
1043 int mode = S_IFLNK | S_IRWXUGO;
1044 /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
1045 int jbegin_count =
1046 JOURNAL_PER_BALANCE_CNT * 3 +
1047 2 * (REISERFS_QUOTA_INIT_BLOCKS(parent_dir->i_sb) +
1048 REISERFS_QUOTA_TRANS_BLOCKS(parent_dir->i_sb));
1049
1050 if (!(inode = new_inode(parent_dir->i_sb))) {
1051 return -ENOMEM;
1052 }
1053 new_inode_init(inode, parent_dir, mode);
1054
1055 reiserfs_write_lock(parent_dir->i_sb);
1056 item_len = ROUND_UP(strlen(symname));
1057 if (item_len > MAX_DIRECT_ITEM_LEN(parent_dir->i_sb->s_blocksize)) {
1058 retval = -ENAMETOOLONG;
1059 drop_new_inode(inode);
1060 goto out_failed;
1061 }
1062
Pekka Enbergd739b422006-02-01 03:06:43 -08001063 name = kmalloc(item_len, GFP_NOFS);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001064 if (!name) {
1065 drop_new_inode(inode);
1066 retval = -ENOMEM;
1067 goto out_failed;
1068 }
1069 memcpy(name, symname, strlen(symname));
1070 padd_item(name, item_len, strlen(symname));
1071
1072 /* We would inherit the default ACL here, but symlinks don't get ACLs */
1073
1074 retval = journal_begin(&th, parent_dir->i_sb, jbegin_count);
1075 if (retval) {
1076 drop_new_inode(inode);
Pekka Enbergd739b422006-02-01 03:06:43 -08001077 kfree(name);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001078 goto out_failed;
1079 }
1080
1081 retval =
1082 reiserfs_new_inode(&th, parent_dir, mode, name, strlen(symname),
1083 dentry, inode);
Pekka Enbergd739b422006-02-01 03:06:43 -08001084 kfree(name);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001085 if (retval) { /* reiserfs_new_inode iputs for us */
1086 goto out_failed;
1087 }
1088
1089 reiserfs_update_inode_transaction(inode);
1090 reiserfs_update_inode_transaction(parent_dir);
1091
1092 inode->i_op = &reiserfs_symlink_inode_operations;
1093 inode->i_mapping->a_ops = &reiserfs_address_space_operations;
1094
1095 // must be sure this inode is written with this transaction
1096 //
1097 //reiserfs_update_sd (&th, inode, READ_BLOCKS);
1098
1099 retval = reiserfs_add_entry(&th, parent_dir, dentry->d_name.name,
1100 dentry->d_name.len, inode, 1 /*visible */ );
1101 if (retval) {
1102 int err;
1103 inode->i_nlink--;
1104 reiserfs_update_sd(&th, inode);
1105 err = journal_end(&th, parent_dir->i_sb, jbegin_count);
1106 if (err)
1107 retval = err;
1108 iput(inode);
1109 goto out_failed;
1110 }
1111
1112 d_instantiate(dentry, inode);
1113 retval = journal_end(&th, parent_dir->i_sb, jbegin_count);
1114 out_failed:
1115 reiserfs_write_unlock(parent_dir->i_sb);
1116 return retval;
1117}
1118
1119static int reiserfs_link(struct dentry *old_dentry, struct inode *dir,
1120 struct dentry *dentry)
1121{
1122 int retval;
1123 struct inode *inode = old_dentry->d_inode;
1124 struct reiserfs_transaction_handle th;
1125 /* We need blocks for transaction + update of quotas for the owners of the directory */
1126 int jbegin_count =
1127 JOURNAL_PER_BALANCE_CNT * 3 +
1128 2 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);
1129
1130 reiserfs_write_lock(dir->i_sb);
1131 if (inode->i_nlink >= REISERFS_LINK_MAX) {
1132 //FIXME: sd_nlink is 32 bit for new files
1133 reiserfs_write_unlock(dir->i_sb);
1134 return -EMLINK;
1135 }
1136 if (inode->i_nlink == 0) {
1137 reiserfs_write_unlock(dir->i_sb);
1138 return -ENOENT;
1139 }
1140
1141 /* inc before scheduling so reiserfs_unlink knows we are here */
Dave Hansend8c76e62006-09-30 23:29:04 -07001142 inc_nlink(inode);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001143
1144 retval = journal_begin(&th, dir->i_sb, jbegin_count);
1145 if (retval) {
1146 inode->i_nlink--;
1147 reiserfs_write_unlock(dir->i_sb);
1148 return retval;
1149 }
1150
1151 /* create new entry */
1152 retval =
1153 reiserfs_add_entry(&th, dir, dentry->d_name.name,
1154 dentry->d_name.len, inode, 1 /*visible */ );
1155
1156 reiserfs_update_inode_transaction(inode);
1157 reiserfs_update_inode_transaction(dir);
1158
1159 if (retval) {
1160 int err;
1161 inode->i_nlink--;
1162 err = journal_end(&th, dir->i_sb, jbegin_count);
1163 reiserfs_write_unlock(dir->i_sb);
1164 return err ? err : retval;
1165 }
1166
1167 inode->i_ctime = CURRENT_TIME_SEC;
1168 reiserfs_update_sd(&th, inode);
1169
1170 atomic_inc(&inode->i_count);
1171 d_instantiate(dentry, inode);
1172 retval = journal_end(&th, dir->i_sb, jbegin_count);
1173 reiserfs_write_unlock(dir->i_sb);
1174 return retval;
1175}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176
1177// de contains information pointing to an entry which
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001178static int de_still_valid(const char *name, int len,
1179 struct reiserfs_dir_entry *de)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001181 struct reiserfs_dir_entry tmp = *de;
1182
1183 // recalculate pointer to name and name length
1184 set_de_name_and_namelen(&tmp);
1185 // FIXME: could check more
1186 if (tmp.de_namelen != len || memcmp(name, de->de_name, len))
1187 return 0;
1188 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189}
1190
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001191static int entry_points_to_object(const char *name, int len,
1192 struct reiserfs_dir_entry *de,
1193 struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001195 if (!de_still_valid(name, len, de))
1196 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001198 if (inode) {
1199 if (!de_visible(de->de_deh + de->de_entry_num))
1200 reiserfs_panic(NULL,
1201 "vs-7042: entry_points_to_object: entry must be visible");
1202 return (de->de_objectid == inode->i_ino) ? 1 : 0;
1203 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001205 /* this must be added hidden entry */
1206 if (de_visible(de->de_deh + de->de_entry_num))
1207 reiserfs_panic(NULL,
1208 "vs-7043: entry_points_to_object: entry must be visible");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001209
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001210 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001211}
1212
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213/* sets key of objectid the entry has to point to */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001214static void set_ino_in_dir_entry(struct reiserfs_dir_entry *de,
1215 struct reiserfs_key *key)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001216{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001217 /* JDM These operations are endian safe - both are le */
1218 de->de_deh[de->de_entry_num].deh_dir_id = key->k_dir_id;
1219 de->de_deh[de->de_entry_num].deh_objectid = key->k_objectid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220}
1221
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222/*
1223 * process, that is going to call fix_nodes/do_balance must hold only
1224 * one path. If it holds 2 or more, it can get into endless waiting in
1225 * get_empty_nodes or its clones
1226 */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001227static int reiserfs_rename(struct inode *old_dir, struct dentry *old_dentry,
1228 struct inode *new_dir, struct dentry *new_dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001230 int retval;
1231 INITIALIZE_PATH(old_entry_path);
1232 INITIALIZE_PATH(new_entry_path);
1233 INITIALIZE_PATH(dot_dot_entry_path);
1234 struct item_head new_entry_ih, old_entry_ih, dot_dot_ih;
1235 struct reiserfs_dir_entry old_de, new_de, dot_dot_de;
1236 struct inode *old_inode, *new_dentry_inode;
1237 struct reiserfs_transaction_handle th;
1238 int jbegin_count;
1239 umode_t old_inode_mode;
1240 unsigned long savelink = 1;
1241 struct timespec ctime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001243 /* three balancings: (1) old name removal, (2) new name insertion
1244 and (3) maybe "save" link insertion
1245 stat data updates: (1) old directory,
1246 (2) new directory and (3) maybe old object stat data (when it is
1247 directory) and (4) maybe stat data of object to which new entry
1248 pointed initially and (5) maybe block containing ".." of
1249 renamed directory
1250 quota updates: two parent directories */
1251 jbegin_count =
1252 JOURNAL_PER_BALANCE_CNT * 3 + 5 +
1253 4 * REISERFS_QUOTA_TRANS_BLOCKS(old_dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001255 old_inode = old_dentry->d_inode;
1256 new_dentry_inode = new_dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001258 // make sure, that oldname still exists and points to an object we
1259 // are going to rename
1260 old_de.de_gen_number_bit_string = NULL;
1261 reiserfs_write_lock(old_dir->i_sb);
1262 retval =
1263 reiserfs_find_entry(old_dir, old_dentry->d_name.name,
1264 old_dentry->d_name.len, &old_entry_path,
1265 &old_de);
1266 pathrelse(&old_entry_path);
1267 if (retval == IO_ERROR) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268 reiserfs_write_unlock(old_dir->i_sb);
1269 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001271
1272 if (retval != NAME_FOUND || old_de.de_objectid != old_inode->i_ino) {
1273 reiserfs_write_unlock(old_dir->i_sb);
1274 return -ENOENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001276
1277 old_inode_mode = old_inode->i_mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278 if (S_ISDIR(old_inode_mode)) {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001279 // make sure, that directory being renamed has correct ".."
1280 // and that its new parent directory has not too many links
1281 // already
1282
1283 if (new_dentry_inode) {
1284 if (!reiserfs_empty_dir(new_dentry_inode)) {
1285 reiserfs_write_unlock(old_dir->i_sb);
1286 return -ENOTEMPTY;
1287 }
1288 }
1289
1290 /* directory is renamed, its parent directory will be changed,
1291 ** so find ".." entry
1292 */
1293 dot_dot_de.de_gen_number_bit_string = NULL;
1294 retval =
1295 reiserfs_find_entry(old_inode, "..", 2, &dot_dot_entry_path,
1296 &dot_dot_de);
1297 pathrelse(&dot_dot_entry_path);
1298 if (retval != NAME_FOUND) {
1299 reiserfs_write_unlock(old_dir->i_sb);
1300 return -EIO;
1301 }
1302
1303 /* inode number of .. must equal old_dir->i_ino */
1304 if (dot_dot_de.de_objectid != old_dir->i_ino) {
1305 reiserfs_write_unlock(old_dir->i_sb);
1306 return -EIO;
1307 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308 }
1309
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001310 retval = journal_begin(&th, old_dir->i_sb, jbegin_count);
1311 if (retval) {
1312 reiserfs_write_unlock(old_dir->i_sb);
1313 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001316 /* add new entry (or find the existing one) */
1317 retval =
1318 reiserfs_add_entry(&th, new_dir, new_dentry->d_name.name,
1319 new_dentry->d_name.len, old_inode, 0);
1320 if (retval == -EEXIST) {
1321 if (!new_dentry_inode) {
1322 reiserfs_panic(old_dir->i_sb,
1323 "vs-7050: new entry is found, new inode == 0\n");
1324 }
1325 } else if (retval) {
1326 int err = journal_end(&th, old_dir->i_sb, jbegin_count);
1327 reiserfs_write_unlock(old_dir->i_sb);
1328 return err ? err : retval;
1329 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001330
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001331 reiserfs_update_inode_transaction(old_dir);
1332 reiserfs_update_inode_transaction(new_dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001334 /* this makes it so an fsync on an open fd for the old name will
1335 ** commit the rename operation
1336 */
1337 reiserfs_update_inode_transaction(old_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001339 if (new_dentry_inode)
1340 reiserfs_update_inode_transaction(new_dentry_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001342 while (1) {
1343 // look for old name using corresponding entry key (found by reiserfs_find_entry)
1344 if ((retval =
1345 search_by_entry_key(new_dir->i_sb, &old_de.de_entry_key,
1346 &old_entry_path,
1347 &old_de)) != NAME_FOUND) {
1348 pathrelse(&old_entry_path);
1349 journal_end(&th, old_dir->i_sb, jbegin_count);
1350 reiserfs_write_unlock(old_dir->i_sb);
1351 return -EIO;
1352 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001354 copy_item_head(&old_entry_ih, get_ih(&old_entry_path));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001356 reiserfs_prepare_for_journal(old_inode->i_sb, old_de.de_bh, 1);
1357
1358 // look for new name by reiserfs_find_entry
1359 new_de.de_gen_number_bit_string = NULL;
1360 retval =
1361 reiserfs_find_entry(new_dir, new_dentry->d_name.name,
1362 new_dentry->d_name.len, &new_entry_path,
1363 &new_de);
1364 // reiserfs_add_entry should not return IO_ERROR, because it is called with essentially same parameters from
1365 // reiserfs_add_entry above, and we'll catch any i/o errors before we get here.
1366 if (retval != NAME_FOUND_INVISIBLE && retval != NAME_FOUND) {
1367 pathrelse(&new_entry_path);
1368 pathrelse(&old_entry_path);
1369 journal_end(&th, old_dir->i_sb, jbegin_count);
1370 reiserfs_write_unlock(old_dir->i_sb);
1371 return -EIO;
1372 }
1373
1374 copy_item_head(&new_entry_ih, get_ih(&new_entry_path));
1375
1376 reiserfs_prepare_for_journal(old_inode->i_sb, new_de.de_bh, 1);
1377
1378 if (S_ISDIR(old_inode->i_mode)) {
1379 if ((retval =
1380 search_by_entry_key(new_dir->i_sb,
1381 &dot_dot_de.de_entry_key,
1382 &dot_dot_entry_path,
1383 &dot_dot_de)) != NAME_FOUND) {
1384 pathrelse(&dot_dot_entry_path);
1385 pathrelse(&new_entry_path);
1386 pathrelse(&old_entry_path);
1387 journal_end(&th, old_dir->i_sb, jbegin_count);
1388 reiserfs_write_unlock(old_dir->i_sb);
1389 return -EIO;
1390 }
1391 copy_item_head(&dot_dot_ih,
1392 get_ih(&dot_dot_entry_path));
1393 // node containing ".." gets into transaction
1394 reiserfs_prepare_for_journal(old_inode->i_sb,
1395 dot_dot_de.de_bh, 1);
1396 }
1397 /* we should check seals here, not do
1398 this stuff, yes? Then, having
1399 gathered everything into RAM we
1400 should lock the buffers, yes? -Hans */
1401 /* probably. our rename needs to hold more
1402 ** than one path at once. The seals would
1403 ** have to be written to deal with multi-path
1404 ** issues -chris
1405 */
1406 /* sanity checking before doing the rename - avoid races many
1407 ** of the above checks could have scheduled. We have to be
1408 ** sure our items haven't been shifted by another process.
1409 */
1410 if (item_moved(&new_entry_ih, &new_entry_path) ||
1411 !entry_points_to_object(new_dentry->d_name.name,
1412 new_dentry->d_name.len,
1413 &new_de, new_dentry_inode) ||
1414 item_moved(&old_entry_ih, &old_entry_path) ||
1415 !entry_points_to_object(old_dentry->d_name.name,
1416 old_dentry->d_name.len,
1417 &old_de, old_inode)) {
1418 reiserfs_restore_prepared_buffer(old_inode->i_sb,
1419 new_de.de_bh);
1420 reiserfs_restore_prepared_buffer(old_inode->i_sb,
1421 old_de.de_bh);
1422 if (S_ISDIR(old_inode_mode))
1423 reiserfs_restore_prepared_buffer(old_inode->
1424 i_sb,
1425 dot_dot_de.
1426 de_bh);
1427 continue;
1428 }
1429 if (S_ISDIR(old_inode_mode)) {
1430 if (item_moved(&dot_dot_ih, &dot_dot_entry_path) ||
1431 !entry_points_to_object("..", 2, &dot_dot_de,
1432 old_dir)) {
1433 reiserfs_restore_prepared_buffer(old_inode->
1434 i_sb,
1435 old_de.de_bh);
1436 reiserfs_restore_prepared_buffer(old_inode->
1437 i_sb,
1438 new_de.de_bh);
1439 reiserfs_restore_prepared_buffer(old_inode->
1440 i_sb,
1441 dot_dot_de.
1442 de_bh);
1443 continue;
1444 }
1445 }
1446
1447 RFALSE(S_ISDIR(old_inode_mode) &&
1448 !buffer_journal_prepared(dot_dot_de.de_bh), "");
1449
1450 break;
1451 }
1452
1453 /* ok, all the changes can be done in one fell swoop when we
1454 have claimed all the buffers needed. */
1455
1456 mark_de_visible(new_de.de_deh + new_de.de_entry_num);
1457 set_ino_in_dir_entry(&new_de, INODE_PKEY(old_inode));
1458 journal_mark_dirty(&th, old_dir->i_sb, new_de.de_bh);
1459
1460 mark_de_hidden(old_de.de_deh + old_de.de_entry_num);
1461 journal_mark_dirty(&th, old_dir->i_sb, old_de.de_bh);
1462 ctime = CURRENT_TIME_SEC;
1463 old_dir->i_ctime = old_dir->i_mtime = ctime;
1464 new_dir->i_ctime = new_dir->i_mtime = ctime;
1465 /* thanks to Alex Adriaanse <alex_a@caltech.edu> for patch which adds ctime update of
1466 renamed object */
1467 old_inode->i_ctime = ctime;
1468
1469 if (new_dentry_inode) {
1470 // adjust link number of the victim
1471 if (S_ISDIR(new_dentry_inode->i_mode)) {
Dave Hansence71ec32006-09-30 23:29:06 -07001472 clear_nlink(new_dentry_inode);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001473 } else {
Dave Hansen9a53c3a2006-09-30 23:29:03 -07001474 drop_nlink(new_dentry_inode);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001475 }
1476 new_dentry_inode->i_ctime = ctime;
1477 savelink = new_dentry_inode->i_nlink;
1478 }
1479
1480 if (S_ISDIR(old_inode_mode)) {
1481 // adjust ".." of renamed directory
1482 set_ino_in_dir_entry(&dot_dot_de, INODE_PKEY(new_dir));
1483 journal_mark_dirty(&th, new_dir->i_sb, dot_dot_de.de_bh);
1484
1485 if (!new_dentry_inode)
1486 /* there (in new_dir) was no directory, so it got new link
1487 (".." of renamed directory) */
1488 INC_DIR_INODE_NLINK(new_dir);
1489
1490 /* old directory lost one link - ".. " of renamed directory */
1491 DEC_DIR_INODE_NLINK(old_dir);
1492 }
1493 // looks like in 2.3.99pre3 brelse is atomic. so we can use pathrelse
1494 pathrelse(&new_entry_path);
1495 pathrelse(&dot_dot_entry_path);
1496
1497 // FIXME: this reiserfs_cut_from_item's return value may screw up
1498 // anybody, but it will panic if will not be able to find the
1499 // entry. This needs one more clean up
1500 if (reiserfs_cut_from_item
1501 (&th, &old_entry_path, &(old_de.de_entry_key), old_dir, NULL,
1502 0) < 0)
1503 reiserfs_warning(old_dir->i_sb,
1504 "vs-7060: reiserfs_rename: couldn't not cut old name. Fsck later?");
1505
1506 old_dir->i_size -= DEH_SIZE + old_de.de_entrylen;
1507
1508 reiserfs_update_sd(&th, old_dir);
1509 reiserfs_update_sd(&th, new_dir);
1510 reiserfs_update_sd(&th, old_inode);
1511
1512 if (new_dentry_inode) {
1513 if (savelink == 0)
1514 add_save_link(&th, new_dentry_inode,
1515 0 /* not truncate */ );
1516 reiserfs_update_sd(&th, new_dentry_inode);
1517 }
1518
1519 retval = journal_end(&th, old_dir->i_sb, jbegin_count);
1520 reiserfs_write_unlock(old_dir->i_sb);
1521 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522}
1523
1524/*
1525 * directories can handle most operations...
1526 */
Arjan van de Venc5ef1c42007-02-12 00:55:40 -08001527const struct inode_operations reiserfs_dir_inode_operations = {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001528 //&reiserfs_dir_operations, /* default_file_ops */
1529 .create = reiserfs_create,
1530 .lookup = reiserfs_lookup,
1531 .link = reiserfs_link,
1532 .unlink = reiserfs_unlink,
1533 .symlink = reiserfs_symlink,
1534 .mkdir = reiserfs_mkdir,
1535 .rmdir = reiserfs_rmdir,
1536 .mknod = reiserfs_mknod,
1537 .rename = reiserfs_rename,
1538 .setattr = reiserfs_setattr,
1539 .setxattr = reiserfs_setxattr,
1540 .getxattr = reiserfs_getxattr,
1541 .listxattr = reiserfs_listxattr,
1542 .removexattr = reiserfs_removexattr,
1543 .permission = reiserfs_permission,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544};
1545
1546/*
1547 * symlink operations.. same as page_symlink_inode_operations, with xattr
1548 * stuff added
1549 */
Arjan van de Venc5ef1c42007-02-12 00:55:40 -08001550const struct inode_operations reiserfs_symlink_inode_operations = {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001551 .readlink = generic_readlink,
1552 .follow_link = page_follow_link_light,
1553 .put_link = page_put_link,
1554 .setattr = reiserfs_setattr,
1555 .setxattr = reiserfs_setxattr,
1556 .getxattr = reiserfs_getxattr,
1557 .listxattr = reiserfs_listxattr,
1558 .removexattr = reiserfs_removexattr,
1559 .permission = reiserfs_permission,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001560
1561};
1562
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563/*
1564 * special file operations.. just xattr/acl stuff
1565 */
Arjan van de Venc5ef1c42007-02-12 00:55:40 -08001566const struct inode_operations reiserfs_special_inode_operations = {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001567 .setattr = reiserfs_setattr,
1568 .setxattr = reiserfs_setxattr,
1569 .getxattr = reiserfs_getxattr,
1570 .listxattr = reiserfs_listxattr,
1571 .removexattr = reiserfs_removexattr,
1572 .permission = reiserfs_permission,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001573
1574};