namei.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673
  1. /*
  2. * linux/fs/hpfs/namei.c
  3. *
  4. * Mikulas Patocka (mikulas@artax.karlin.mff.cuni.cz), 1998-1999
  5. *
  6. * adding & removing files & directories
  7. */
  8. #include "hpfs_fn.h"
  9. static int hpfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
  10. {
  11. const char *name = dentry->d_name.name;
  12. unsigned len = dentry->d_name.len;
  13. struct quad_buffer_head qbh0;
  14. struct buffer_head *bh;
  15. struct hpfs_dirent *de;
  16. struct fnode *fnode;
  17. struct dnode *dnode;
  18. struct inode *result;
  19. fnode_secno fno;
  20. dnode_secno dno;
  21. int r;
  22. struct hpfs_dirent dee;
  23. int err;
  24. if ((err = hpfs_chk_name((char *)name, &len))) return err==-ENOENT ? -EINVAL : err;
  25. lock_kernel();
  26. err = -ENOSPC;
  27. fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh);
  28. if (!fnode)
  29. goto bail;
  30. dnode = hpfs_alloc_dnode(dir->i_sb, fno, &dno, &qbh0, 1);
  31. if (!dnode)
  32. goto bail1;
  33. memset(&dee, 0, sizeof dee);
  34. dee.directory = 1;
  35. if (!(mode & 0222)) dee.read_only = 1;
  36. /*dee.archive = 0;*/
  37. dee.hidden = name[0] == '.';
  38. dee.fnode = fno;
  39. dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, get_seconds());
  40. result = new_inode(dir->i_sb);
  41. if (!result)
  42. goto bail2;
  43. hpfs_init_inode(result);
  44. result->i_ino = fno;
  45. hpfs_i(result)->i_parent_dir = dir->i_ino;
  46. hpfs_i(result)->i_dno = dno;
  47. result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, dee.creation_date);
  48. result->i_ctime.tv_nsec = 0;
  49. result->i_mtime.tv_nsec = 0;
  50. result->i_atime.tv_nsec = 0;
  51. hpfs_i(result)->i_ea_size = 0;
  52. result->i_mode |= S_IFDIR;
  53. result->i_op = &hpfs_dir_iops;
  54. result->i_fop = &hpfs_dir_ops;
  55. result->i_blocks = 4;
  56. result->i_size = 2048;
  57. result->i_nlink = 2;
  58. if (dee.read_only)
  59. result->i_mode &= ~0222;
  60. mutex_lock(&hpfs_i(dir)->i_mutex);
  61. r = hpfs_add_dirent(dir, (char *)name, len, &dee, 0);
  62. if (r == 1)
  63. goto bail3;
  64. if (r == -1) {
  65. err = -EEXIST;
  66. goto bail3;
  67. }
  68. fnode->len = len;
  69. memcpy(fnode->name, name, len > 15 ? 15 : len);
  70. fnode->up = dir->i_ino;
  71. fnode->dirflag = 1;
  72. fnode->btree.n_free_nodes = 7;
  73. fnode->btree.n_used_nodes = 1;
  74. fnode->btree.first_free = 0x14;
  75. fnode->u.external[0].disk_secno = dno;
  76. fnode->u.external[0].file_secno = -1;
  77. dnode->root_dnode = 1;
  78. dnode->up = fno;
  79. de = hpfs_add_de(dir->i_sb, dnode, "\001\001", 2, 0);
  80. de->creation_date = de->write_date = de->read_date = gmt_to_local(dir->i_sb, get_seconds());
  81. if (!(mode & 0222)) de->read_only = 1;
  82. de->first = de->directory = 1;
  83. /*de->hidden = de->system = 0;*/
  84. de->fnode = fno;
  85. mark_buffer_dirty(bh);
  86. brelse(bh);
  87. hpfs_mark_4buffers_dirty(&qbh0);
  88. hpfs_brelse4(&qbh0);
  89. inc_nlink(dir);
  90. insert_inode_hash(result);
  91. if (result->i_uid != current->fsuid ||
  92. result->i_gid != current->fsgid ||
  93. result->i_mode != (mode | S_IFDIR)) {
  94. result->i_uid = current->fsuid;
  95. result->i_gid = current->fsgid;
  96. result->i_mode = mode | S_IFDIR;
  97. hpfs_write_inode_nolock(result);
  98. }
  99. d_instantiate(dentry, result);
  100. mutex_unlock(&hpfs_i(dir)->i_mutex);
  101. unlock_kernel();
  102. return 0;
  103. bail3:
  104. mutex_unlock(&hpfs_i(dir)->i_mutex);
  105. iput(result);
  106. bail2:
  107. hpfs_brelse4(&qbh0);
  108. hpfs_free_dnode(dir->i_sb, dno);
  109. bail1:
  110. brelse(bh);
  111. hpfs_free_sectors(dir->i_sb, fno, 1);
  112. bail:
  113. unlock_kernel();
  114. return err;
  115. }
  116. static int hpfs_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd)
  117. {
  118. const char *name = dentry->d_name.name;
  119. unsigned len = dentry->d_name.len;
  120. struct inode *result = NULL;
  121. struct buffer_head *bh;
  122. struct fnode *fnode;
  123. fnode_secno fno;
  124. int r;
  125. struct hpfs_dirent dee;
  126. int err;
  127. if ((err = hpfs_chk_name((char *)name, &len)))
  128. return err==-ENOENT ? -EINVAL : err;
  129. lock_kernel();
  130. err = -ENOSPC;
  131. fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh);
  132. if (!fnode)
  133. goto bail;
  134. memset(&dee, 0, sizeof dee);
  135. if (!(mode & 0222)) dee.read_only = 1;
  136. dee.archive = 1;
  137. dee.hidden = name[0] == '.';
  138. dee.fnode = fno;
  139. dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, get_seconds());
  140. result = new_inode(dir->i_sb);
  141. if (!result)
  142. goto bail1;
  143. hpfs_init_inode(result);
  144. result->i_ino = fno;
  145. result->i_mode |= S_IFREG;
  146. result->i_mode &= ~0111;
  147. result->i_op = &hpfs_file_iops;
  148. result->i_fop = &hpfs_file_ops;
  149. result->i_nlink = 1;
  150. hpfs_decide_conv(result, (char *)name, len);
  151. hpfs_i(result)->i_parent_dir = dir->i_ino;
  152. result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, dee.creation_date);
  153. result->i_ctime.tv_nsec = 0;
  154. result->i_mtime.tv_nsec = 0;
  155. result->i_atime.tv_nsec = 0;
  156. hpfs_i(result)->i_ea_size = 0;
  157. if (dee.read_only)
  158. result->i_mode &= ~0222;
  159. result->i_blocks = 1;
  160. result->i_size = 0;
  161. result->i_data.a_ops = &hpfs_aops;
  162. hpfs_i(result)->mmu_private = 0;
  163. mutex_lock(&hpfs_i(dir)->i_mutex);
  164. r = hpfs_add_dirent(dir, (char *)name, len, &dee, 0);
  165. if (r == 1)
  166. goto bail2;
  167. if (r == -1) {
  168. err = -EEXIST;
  169. goto bail2;
  170. }
  171. fnode->len = len;
  172. memcpy(fnode->name, name, len > 15 ? 15 : len);
  173. fnode->up = dir->i_ino;
  174. mark_buffer_dirty(bh);
  175. brelse(bh);
  176. insert_inode_hash(result);
  177. if (result->i_uid != current->fsuid ||
  178. result->i_gid != current->fsgid ||
  179. result->i_mode != (mode | S_IFREG)) {
  180. result->i_uid = current->fsuid;
  181. result->i_gid = current->fsgid;
  182. result->i_mode = mode | S_IFREG;
  183. hpfs_write_inode_nolock(result);
  184. }
  185. d_instantiate(dentry, result);
  186. mutex_unlock(&hpfs_i(dir)->i_mutex);
  187. unlock_kernel();
  188. return 0;
  189. bail2:
  190. mutex_unlock(&hpfs_i(dir)->i_mutex);
  191. iput(result);
  192. bail1:
  193. brelse(bh);
  194. hpfs_free_sectors(dir->i_sb, fno, 1);
  195. bail:
  196. unlock_kernel();
  197. return err;
  198. }
  199. static int hpfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
  200. {
  201. const char *name = dentry->d_name.name;
  202. unsigned len = dentry->d_name.len;
  203. struct buffer_head *bh;
  204. struct fnode *fnode;
  205. fnode_secno fno;
  206. int r;
  207. struct hpfs_dirent dee;
  208. struct inode *result = NULL;
  209. int err;
  210. if ((err = hpfs_chk_name((char *)name, &len))) return err==-ENOENT ? -EINVAL : err;
  211. if (hpfs_sb(dir->i_sb)->sb_eas < 2) return -EPERM;
  212. if (!new_valid_dev(rdev))
  213. return -EINVAL;
  214. lock_kernel();
  215. err = -ENOSPC;
  216. fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh);
  217. if (!fnode)
  218. goto bail;
  219. memset(&dee, 0, sizeof dee);
  220. if (!(mode & 0222)) dee.read_only = 1;
  221. dee.archive = 1;
  222. dee.hidden = name[0] == '.';
  223. dee.fnode = fno;
  224. dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, get_seconds());
  225. result = new_inode(dir->i_sb);
  226. if (!result)
  227. goto bail1;
  228. hpfs_init_inode(result);
  229. result->i_ino = fno;
  230. hpfs_i(result)->i_parent_dir = dir->i_ino;
  231. result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, dee.creation_date);
  232. result->i_ctime.tv_nsec = 0;
  233. result->i_mtime.tv_nsec = 0;
  234. result->i_atime.tv_nsec = 0;
  235. hpfs_i(result)->i_ea_size = 0;
  236. result->i_uid = current->fsuid;
  237. result->i_gid = current->fsgid;
  238. result->i_nlink = 1;
  239. result->i_size = 0;
  240. result->i_blocks = 1;
  241. init_special_inode(result, mode, rdev);
  242. mutex_lock(&hpfs_i(dir)->i_mutex);
  243. r = hpfs_add_dirent(dir, (char *)name, len, &dee, 0);
  244. if (r == 1)
  245. goto bail2;
  246. if (r == -1) {
  247. err = -EEXIST;
  248. goto bail2;
  249. }
  250. fnode->len = len;
  251. memcpy(fnode->name, name, len > 15 ? 15 : len);
  252. fnode->up = dir->i_ino;
  253. mark_buffer_dirty(bh);
  254. insert_inode_hash(result);
  255. hpfs_write_inode_nolock(result);
  256. d_instantiate(dentry, result);
  257. mutex_unlock(&hpfs_i(dir)->i_mutex);
  258. brelse(bh);
  259. unlock_kernel();
  260. return 0;
  261. bail2:
  262. mutex_unlock(&hpfs_i(dir)->i_mutex);
  263. iput(result);
  264. bail1:
  265. brelse(bh);
  266. hpfs_free_sectors(dir->i_sb, fno, 1);
  267. bail:
  268. unlock_kernel();
  269. return err;
  270. }
  271. static int hpfs_symlink(struct inode *dir, struct dentry *dentry, const char *symlink)
  272. {
  273. const char *name = dentry->d_name.name;
  274. unsigned len = dentry->d_name.len;
  275. struct buffer_head *bh;
  276. struct fnode *fnode;
  277. fnode_secno fno;
  278. int r;
  279. struct hpfs_dirent dee;
  280. struct inode *result;
  281. int err;
  282. if ((err = hpfs_chk_name((char *)name, &len))) return err==-ENOENT ? -EINVAL : err;
  283. lock_kernel();
  284. if (hpfs_sb(dir->i_sb)->sb_eas < 2) {
  285. unlock_kernel();
  286. return -EPERM;
  287. }
  288. err = -ENOSPC;
  289. fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh);
  290. if (!fnode)
  291. goto bail;
  292. memset(&dee, 0, sizeof dee);
  293. dee.archive = 1;
  294. dee.hidden = name[0] == '.';
  295. dee.fnode = fno;
  296. dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, get_seconds());
  297. result = new_inode(dir->i_sb);
  298. if (!result)
  299. goto bail1;
  300. result->i_ino = fno;
  301. hpfs_init_inode(result);
  302. hpfs_i(result)->i_parent_dir = dir->i_ino;
  303. result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, dee.creation_date);
  304. result->i_ctime.tv_nsec = 0;
  305. result->i_mtime.tv_nsec = 0;
  306. result->i_atime.tv_nsec = 0;
  307. hpfs_i(result)->i_ea_size = 0;
  308. result->i_mode = S_IFLNK | 0777;
  309. result->i_uid = current->fsuid;
  310. result->i_gid = current->fsgid;
  311. result->i_blocks = 1;
  312. result->i_nlink = 1;
  313. result->i_size = strlen(symlink);
  314. result->i_op = &page_symlink_inode_operations;
  315. result->i_data.a_ops = &hpfs_symlink_aops;
  316. mutex_lock(&hpfs_i(dir)->i_mutex);
  317. r = hpfs_add_dirent(dir, (char *)name, len, &dee, 0);
  318. if (r == 1)
  319. goto bail2;
  320. if (r == -1) {
  321. err = -EEXIST;
  322. goto bail2;
  323. }
  324. fnode->len = len;
  325. memcpy(fnode->name, name, len > 15 ? 15 : len);
  326. fnode->up = dir->i_ino;
  327. hpfs_set_ea(result, fnode, "SYMLINK", (char *)symlink, strlen(symlink));
  328. mark_buffer_dirty(bh);
  329. brelse(bh);
  330. insert_inode_hash(result);
  331. hpfs_write_inode_nolock(result);
  332. d_instantiate(dentry, result);
  333. mutex_unlock(&hpfs_i(dir)->i_mutex);
  334. unlock_kernel();
  335. return 0;
  336. bail2:
  337. mutex_unlock(&hpfs_i(dir)->i_mutex);
  338. iput(result);
  339. bail1:
  340. brelse(bh);
  341. hpfs_free_sectors(dir->i_sb, fno, 1);
  342. bail:
  343. unlock_kernel();
  344. return err;
  345. }
  346. static int hpfs_unlink(struct inode *dir, struct dentry *dentry)
  347. {
  348. const char *name = dentry->d_name.name;
  349. unsigned len = dentry->d_name.len;
  350. struct quad_buffer_head qbh;
  351. struct hpfs_dirent *de;
  352. struct inode *inode = dentry->d_inode;
  353. dnode_secno dno;
  354. fnode_secno fno;
  355. int r;
  356. int rep = 0;
  357. int err;
  358. lock_kernel();
  359. hpfs_adjust_length((char *)name, &len);
  360. again:
  361. mutex_lock(&hpfs_i(inode)->i_parent_mutex);
  362. mutex_lock(&hpfs_i(dir)->i_mutex);
  363. err = -ENOENT;
  364. de = map_dirent(dir, hpfs_i(dir)->i_dno, (char *)name, len, &dno, &qbh);
  365. if (!de)
  366. goto out;
  367. err = -EPERM;
  368. if (de->first)
  369. goto out1;
  370. err = -EISDIR;
  371. if (de->directory)
  372. goto out1;
  373. fno = de->fnode;
  374. r = hpfs_remove_dirent(dir, dno, de, &qbh, 1);
  375. switch (r) {
  376. case 1:
  377. hpfs_error(dir->i_sb, "there was error when removing dirent");
  378. err = -EFSERROR;
  379. break;
  380. case 2: /* no space for deleting, try to truncate file */
  381. err = -ENOSPC;
  382. if (rep++)
  383. break;
  384. mutex_unlock(&hpfs_i(dir)->i_mutex);
  385. mutex_unlock(&hpfs_i(inode)->i_parent_mutex);
  386. d_drop(dentry);
  387. spin_lock(&dentry->d_lock);
  388. if (atomic_read(&dentry->d_count) > 1 ||
  389. permission(inode, MAY_WRITE, NULL) ||
  390. !S_ISREG(inode->i_mode) ||
  391. get_write_access(inode)) {
  392. spin_unlock(&dentry->d_lock);
  393. d_rehash(dentry);
  394. } else {
  395. struct iattr newattrs;
  396. spin_unlock(&dentry->d_lock);
  397. /*printk("HPFS: truncating file before delete.\n");*/
  398. newattrs.ia_size = 0;
  399. newattrs.ia_valid = ATTR_SIZE | ATTR_CTIME;
  400. err = notify_change(dentry, &newattrs);
  401. put_write_access(inode);
  402. if (!err)
  403. goto again;
  404. }
  405. unlock_kernel();
  406. return -ENOSPC;
  407. default:
  408. drop_nlink(inode);
  409. err = 0;
  410. }
  411. goto out;
  412. out1:
  413. hpfs_brelse4(&qbh);
  414. out:
  415. mutex_unlock(&hpfs_i(dir)->i_mutex);
  416. mutex_unlock(&hpfs_i(inode)->i_parent_mutex);
  417. unlock_kernel();
  418. return err;
  419. }
  420. static int hpfs_rmdir(struct inode *dir, struct dentry *dentry)
  421. {
  422. const char *name = dentry->d_name.name;
  423. unsigned len = dentry->d_name.len;
  424. struct quad_buffer_head qbh;
  425. struct hpfs_dirent *de;
  426. struct inode *inode = dentry->d_inode;
  427. dnode_secno dno;
  428. fnode_secno fno;
  429. int n_items = 0;
  430. int err;
  431. int r;
  432. hpfs_adjust_length((char *)name, &len);
  433. lock_kernel();
  434. mutex_lock(&hpfs_i(inode)->i_parent_mutex);
  435. mutex_lock(&hpfs_i(dir)->i_mutex);
  436. err = -ENOENT;
  437. de = map_dirent(dir, hpfs_i(dir)->i_dno, (char *)name, len, &dno, &qbh);
  438. if (!de)
  439. goto out;
  440. err = -EPERM;
  441. if (de->first)
  442. goto out1;
  443. err = -ENOTDIR;
  444. if (!de->directory)
  445. goto out1;
  446. hpfs_count_dnodes(dir->i_sb, hpfs_i(inode)->i_dno, NULL, NULL, &n_items);
  447. err = -ENOTEMPTY;
  448. if (n_items)
  449. goto out1;
  450. fno = de->fnode;
  451. r = hpfs_remove_dirent(dir, dno, de, &qbh, 1);
  452. switch (r) {
  453. case 1:
  454. hpfs_error(dir->i_sb, "there was error when removing dirent");
  455. err = -EFSERROR;
  456. break;
  457. case 2:
  458. err = -ENOSPC;
  459. break;
  460. default:
  461. drop_nlink(dir);
  462. clear_nlink(inode);
  463. err = 0;
  464. }
  465. goto out;
  466. out1:
  467. hpfs_brelse4(&qbh);
  468. out:
  469. mutex_unlock(&hpfs_i(dir)->i_mutex);
  470. mutex_unlock(&hpfs_i(inode)->i_parent_mutex);
  471. unlock_kernel();
  472. return err;
  473. }
  474. static int hpfs_symlink_readpage(struct file *file, struct page *page)
  475. {
  476. char *link = kmap(page);
  477. struct inode *i = page->mapping->host;
  478. struct fnode *fnode;
  479. struct buffer_head *bh;
  480. int err;
  481. err = -EIO;
  482. lock_kernel();
  483. if (!(fnode = hpfs_map_fnode(i->i_sb, i->i_ino, &bh)))
  484. goto fail;
  485. err = hpfs_read_ea(i->i_sb, fnode, "SYMLINK", link, PAGE_SIZE);
  486. brelse(bh);
  487. if (err)
  488. goto fail;
  489. unlock_kernel();
  490. SetPageUptodate(page);
  491. kunmap(page);
  492. unlock_page(page);
  493. return 0;
  494. fail:
  495. unlock_kernel();
  496. SetPageError(page);
  497. kunmap(page);
  498. unlock_page(page);
  499. return err;
  500. }
  501. const struct address_space_operations hpfs_symlink_aops = {
  502. .readpage = hpfs_symlink_readpage
  503. };
  504. static int hpfs_rename(struct inode *old_dir, struct dentry *old_dentry,
  505. struct inode *new_dir, struct dentry *new_dentry)
  506. {
  507. char *old_name = (char *)old_dentry->d_name.name;
  508. int old_len = old_dentry->d_name.len;
  509. char *new_name = (char *)new_dentry->d_name.name;
  510. int new_len = new_dentry->d_name.len;
  511. struct inode *i = old_dentry->d_inode;
  512. struct inode *new_inode = new_dentry->d_inode;
  513. struct quad_buffer_head qbh, qbh1;
  514. struct hpfs_dirent *dep, *nde;
  515. struct hpfs_dirent de;
  516. dnode_secno dno;
  517. int r;
  518. struct buffer_head *bh;
  519. struct fnode *fnode;
  520. int err;
  521. if ((err = hpfs_chk_name((char *)new_name, &new_len))) return err;
  522. err = 0;
  523. hpfs_adjust_length((char *)old_name, &old_len);
  524. lock_kernel();
  525. /* order doesn't matter, due to VFS exclusion */
  526. mutex_lock(&hpfs_i(i)->i_parent_mutex);
  527. if (new_inode)
  528. mutex_lock(&hpfs_i(new_inode)->i_parent_mutex);
  529. mutex_lock(&hpfs_i(old_dir)->i_mutex);
  530. if (new_dir != old_dir)
  531. mutex_lock(&hpfs_i(new_dir)->i_mutex);
  532. /* Erm? Moving over the empty non-busy directory is perfectly legal */
  533. if (new_inode && S_ISDIR(new_inode->i_mode)) {
  534. err = -EINVAL;
  535. goto end1;
  536. }
  537. if (!(dep = map_dirent(old_dir, hpfs_i(old_dir)->i_dno, (char *)old_name, old_len, &dno, &qbh))) {
  538. hpfs_error(i->i_sb, "lookup succeeded but map dirent failed");
  539. err = -ENOENT;
  540. goto end1;
  541. }
  542. copy_de(&de, dep);
  543. de.hidden = new_name[0] == '.';
  544. if (new_inode) {
  545. int r;
  546. if ((r = hpfs_remove_dirent(old_dir, dno, dep, &qbh, 1)) != 2) {
  547. if ((nde = map_dirent(new_dir, hpfs_i(new_dir)->i_dno, (char *)new_name, new_len, NULL, &qbh1))) {
  548. clear_nlink(new_inode);
  549. copy_de(nde, &de);
  550. memcpy(nde->name, new_name, new_len);
  551. hpfs_mark_4buffers_dirty(&qbh1);
  552. hpfs_brelse4(&qbh1);
  553. goto end;
  554. }
  555. hpfs_error(new_dir->i_sb, "hpfs_rename: could not find dirent");
  556. err = -EFSERROR;
  557. goto end1;
  558. }
  559. err = r == 2 ? -ENOSPC : r == 1 ? -EFSERROR : 0;
  560. goto end1;
  561. }
  562. if (new_dir == old_dir) hpfs_brelse4(&qbh);
  563. hpfs_lock_creation(i->i_sb);
  564. if ((r = hpfs_add_dirent(new_dir, new_name, new_len, &de, 1))) {
  565. hpfs_unlock_creation(i->i_sb);
  566. if (r == -1) hpfs_error(new_dir->i_sb, "hpfs_rename: dirent already exists!");
  567. err = r == 1 ? -ENOSPC : -EFSERROR;
  568. if (new_dir != old_dir) hpfs_brelse4(&qbh);
  569. goto end1;
  570. }
  571. if (new_dir == old_dir)
  572. if (!(dep = map_dirent(old_dir, hpfs_i(old_dir)->i_dno, (char *)old_name, old_len, &dno, &qbh))) {
  573. hpfs_unlock_creation(i->i_sb);
  574. hpfs_error(i->i_sb, "lookup succeeded but map dirent failed at #2");
  575. err = -ENOENT;
  576. goto end1;
  577. }
  578. if ((r = hpfs_remove_dirent(old_dir, dno, dep, &qbh, 0))) {
  579. hpfs_unlock_creation(i->i_sb);
  580. hpfs_error(i->i_sb, "hpfs_rename: could not remove dirent");
  581. err = r == 2 ? -ENOSPC : -EFSERROR;
  582. goto end1;
  583. }
  584. hpfs_unlock_creation(i->i_sb);
  585. end:
  586. hpfs_i(i)->i_parent_dir = new_dir->i_ino;
  587. if (S_ISDIR(i->i_mode)) {
  588. inc_nlink(new_dir);
  589. drop_nlink(old_dir);
  590. }
  591. if ((fnode = hpfs_map_fnode(i->i_sb, i->i_ino, &bh))) {
  592. fnode->up = new_dir->i_ino;
  593. fnode->len = new_len;
  594. memcpy(fnode->name, new_name, new_len>15?15:new_len);
  595. if (new_len < 15) memset(&fnode->name[new_len], 0, 15 - new_len);
  596. mark_buffer_dirty(bh);
  597. brelse(bh);
  598. }
  599. hpfs_i(i)->i_conv = hpfs_sb(i->i_sb)->sb_conv;
  600. hpfs_decide_conv(i, (char *)new_name, new_len);
  601. end1:
  602. if (old_dir != new_dir)
  603. mutex_unlock(&hpfs_i(new_dir)->i_mutex);
  604. mutex_unlock(&hpfs_i(old_dir)->i_mutex);
  605. mutex_unlock(&hpfs_i(i)->i_parent_mutex);
  606. if (new_inode)
  607. mutex_unlock(&hpfs_i(new_inode)->i_parent_mutex);
  608. unlock_kernel();
  609. return err;
  610. }
  611. const struct inode_operations hpfs_dir_iops =
  612. {
  613. .create = hpfs_create,
  614. .lookup = hpfs_lookup,
  615. .unlink = hpfs_unlink,
  616. .symlink = hpfs_symlink,
  617. .mkdir = hpfs_mkdir,
  618. .rmdir = hpfs_rmdir,
  619. .mknod = hpfs_mknod,
  620. .rename = hpfs_rename,
  621. .setattr = hpfs_notify_change,
  622. };