namei.c 16 KB

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