namei.c 44 KB

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