xfs_rename.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631
  1. /*
  2. * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
  3. * All Rights Reserved.
  4. *
  5. * This program is free software; you can redistribute it and/or
  6. * modify it under the terms of the GNU General Public License as
  7. * published by the Free Software Foundation.
  8. *
  9. * This program is distributed in the hope that it would be useful,
  10. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12. * GNU General Public License for more details.
  13. *
  14. * You should have received a copy of the GNU General Public License
  15. * along with this program; if not, write the Free Software Foundation,
  16. * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  17. */
  18. #include "xfs.h"
  19. #include "xfs_fs.h"
  20. #include "xfs_types.h"
  21. #include "xfs_log.h"
  22. #include "xfs_inum.h"
  23. #include "xfs_trans.h"
  24. #include "xfs_sb.h"
  25. #include "xfs_dir2.h"
  26. #include "xfs_dmapi.h"
  27. #include "xfs_mount.h"
  28. #include "xfs_da_btree.h"
  29. #include "xfs_bmap_btree.h"
  30. #include "xfs_dir2_sf.h"
  31. #include "xfs_attr_sf.h"
  32. #include "xfs_dinode.h"
  33. #include "xfs_inode.h"
  34. #include "xfs_inode_item.h"
  35. #include "xfs_bmap.h"
  36. #include "xfs_error.h"
  37. #include "xfs_quota.h"
  38. #include "xfs_refcache.h"
  39. #include "xfs_utils.h"
  40. #include "xfs_trans_space.h"
  41. /*
  42. * Given an array of up to 4 inode pointers, unlock the pointed to inodes.
  43. * If there are fewer than 4 entries in the array, the empty entries will
  44. * be at the end and will have NULL pointers in them.
  45. */
  46. STATIC void
  47. xfs_rename_unlock4(
  48. xfs_inode_t **i_tab,
  49. uint lock_mode)
  50. {
  51. int i;
  52. xfs_iunlock(i_tab[0], lock_mode);
  53. for (i = 1; i < 4; i++) {
  54. if (i_tab[i] == NULL) {
  55. break;
  56. }
  57. /*
  58. * Watch out for duplicate entries in the table.
  59. */
  60. if (i_tab[i] != i_tab[i-1]) {
  61. xfs_iunlock(i_tab[i], lock_mode);
  62. }
  63. }
  64. }
  65. #ifdef DEBUG
  66. int xfs_rename_skip, xfs_rename_nskip;
  67. #endif
  68. /*
  69. * The following routine will acquire the locks required for a rename
  70. * operation. The code understands the semantics of renames and will
  71. * validate that name1 exists under dp1 & that name2 may or may not
  72. * exist under dp2.
  73. *
  74. * We are renaming dp1/name1 to dp2/name2.
  75. *
  76. * Return ENOENT if dp1 does not exist, other lookup errors, or 0 for success.
  77. */
  78. STATIC int
  79. xfs_lock_for_rename(
  80. xfs_inode_t *dp1, /* old (source) directory inode */
  81. xfs_inode_t *dp2, /* new (target) directory inode */
  82. bhv_vname_t *vname1,/* old entry name */
  83. bhv_vname_t *vname2,/* new entry name */
  84. xfs_inode_t **ipp1, /* inode of old entry */
  85. xfs_inode_t **ipp2, /* inode of new entry, if it
  86. already exists, NULL otherwise. */
  87. xfs_inode_t **i_tab,/* array of inode returned, sorted */
  88. int *num_inodes) /* number of inodes in array */
  89. {
  90. xfs_inode_t *ip1, *ip2, *temp;
  91. xfs_ino_t inum1, inum2;
  92. int error;
  93. int i, j;
  94. uint lock_mode;
  95. int diff_dirs = (dp1 != dp2);
  96. ip2 = NULL;
  97. /*
  98. * First, find out the current inums of the entries so that we
  99. * can determine the initial locking order. We'll have to
  100. * sanity check stuff after all the locks have been acquired
  101. * to see if we still have the right inodes, directories, etc.
  102. */
  103. lock_mode = xfs_ilock_map_shared(dp1);
  104. error = xfs_get_dir_entry(vname1, &ip1);
  105. if (error) {
  106. xfs_iunlock_map_shared(dp1, lock_mode);
  107. return error;
  108. }
  109. inum1 = ip1->i_ino;
  110. ASSERT(ip1);
  111. ITRACE(ip1);
  112. /*
  113. * Unlock dp1 and lock dp2 if they are different.
  114. */
  115. if (diff_dirs) {
  116. xfs_iunlock_map_shared(dp1, lock_mode);
  117. lock_mode = xfs_ilock_map_shared(dp2);
  118. }
  119. error = xfs_dir_lookup_int(XFS_ITOBHV(dp2), lock_mode,
  120. vname2, &inum2, &ip2);
  121. if (error == ENOENT) { /* target does not need to exist. */
  122. inum2 = 0;
  123. } else if (error) {
  124. /*
  125. * If dp2 and dp1 are the same, the next line unlocks dp1.
  126. * Got it?
  127. */
  128. xfs_iunlock_map_shared(dp2, lock_mode);
  129. IRELE (ip1);
  130. return error;
  131. } else {
  132. ITRACE(ip2);
  133. }
  134. /*
  135. * i_tab contains a list of pointers to inodes. We initialize
  136. * the table here & we'll sort it. We will then use it to
  137. * order the acquisition of the inode locks.
  138. *
  139. * Note that the table may contain duplicates. e.g., dp1 == dp2.
  140. */
  141. i_tab[0] = dp1;
  142. i_tab[1] = dp2;
  143. i_tab[2] = ip1;
  144. if (inum2 == 0) {
  145. *num_inodes = 3;
  146. i_tab[3] = NULL;
  147. } else {
  148. *num_inodes = 4;
  149. i_tab[3] = ip2;
  150. }
  151. /*
  152. * Sort the elements via bubble sort. (Remember, there are at
  153. * most 4 elements to sort, so this is adequate.)
  154. */
  155. for (i=0; i < *num_inodes; i++) {
  156. for (j=1; j < *num_inodes; j++) {
  157. if (i_tab[j]->i_ino < i_tab[j-1]->i_ino) {
  158. temp = i_tab[j];
  159. i_tab[j] = i_tab[j-1];
  160. i_tab[j-1] = temp;
  161. }
  162. }
  163. }
  164. /*
  165. * We have dp2 locked. If it isn't first, unlock it.
  166. * If it is first, tell xfs_lock_inodes so it can skip it
  167. * when locking. if dp1 == dp2, xfs_lock_inodes will skip both
  168. * since they are equal. xfs_lock_inodes needs all these inodes
  169. * so that it can unlock and retry if there might be a dead-lock
  170. * potential with the log.
  171. */
  172. if (i_tab[0] == dp2 && lock_mode == XFS_ILOCK_SHARED) {
  173. #ifdef DEBUG
  174. xfs_rename_skip++;
  175. #endif
  176. xfs_lock_inodes(i_tab, *num_inodes, 1, XFS_ILOCK_SHARED);
  177. } else {
  178. #ifdef DEBUG
  179. xfs_rename_nskip++;
  180. #endif
  181. xfs_iunlock_map_shared(dp2, lock_mode);
  182. xfs_lock_inodes(i_tab, *num_inodes, 0, XFS_ILOCK_SHARED);
  183. }
  184. /*
  185. * Set the return value. Null out any unused entries in i_tab.
  186. */
  187. *ipp1 = *ipp2 = NULL;
  188. for (i=0; i < *num_inodes; i++) {
  189. if (i_tab[i]->i_ino == inum1) {
  190. *ipp1 = i_tab[i];
  191. }
  192. if (i_tab[i]->i_ino == inum2) {
  193. *ipp2 = i_tab[i];
  194. }
  195. }
  196. for (;i < 4; i++) {
  197. i_tab[i] = NULL;
  198. }
  199. return 0;
  200. }
  201. /*
  202. * xfs_rename
  203. */
  204. int
  205. xfs_rename(
  206. bhv_desc_t *src_dir_bdp,
  207. bhv_vname_t *src_vname,
  208. bhv_vnode_t *target_dir_vp,
  209. bhv_vname_t *target_vname,
  210. cred_t *credp)
  211. {
  212. xfs_trans_t *tp;
  213. xfs_inode_t *src_dp, *target_dp, *src_ip, *target_ip;
  214. xfs_mount_t *mp;
  215. int new_parent; /* moving to a new dir */
  216. int src_is_directory; /* src_name is a directory */
  217. int error;
  218. xfs_bmap_free_t free_list;
  219. xfs_fsblock_t first_block;
  220. int cancel_flags;
  221. int committed;
  222. xfs_inode_t *inodes[4];
  223. int target_ip_dropped = 0; /* dropped target_ip link? */
  224. bhv_vnode_t *src_dir_vp;
  225. int spaceres;
  226. int target_link_zero = 0;
  227. int num_inodes;
  228. char *src_name = VNAME(src_vname);
  229. char *target_name = VNAME(target_vname);
  230. int src_namelen = VNAMELEN(src_vname);
  231. int target_namelen = VNAMELEN(target_vname);
  232. src_dir_vp = BHV_TO_VNODE(src_dir_bdp);
  233. vn_trace_entry(src_dir_vp, "xfs_rename", (inst_t *)__return_address);
  234. vn_trace_entry(target_dir_vp, "xfs_rename", (inst_t *)__return_address);
  235. /*
  236. * Find the XFS behavior descriptor for the target directory
  237. * vnode since it was not handed to us.
  238. */
  239. target_dp = xfs_vtoi(target_dir_vp);
  240. if (target_dp == NULL) {
  241. return XFS_ERROR(EXDEV);
  242. }
  243. src_dp = XFS_BHVTOI(src_dir_bdp);
  244. mp = src_dp->i_mount;
  245. if (DM_EVENT_ENABLED(src_dir_vp->v_vfsp, src_dp, DM_EVENT_RENAME) ||
  246. DM_EVENT_ENABLED(target_dir_vp->v_vfsp,
  247. target_dp, DM_EVENT_RENAME)) {
  248. error = XFS_SEND_NAMESP(mp, DM_EVENT_RENAME,
  249. src_dir_vp, DM_RIGHT_NULL,
  250. target_dir_vp, DM_RIGHT_NULL,
  251. src_name, target_name,
  252. 0, 0, 0);
  253. if (error) {
  254. return error;
  255. }
  256. }
  257. /* Return through std_return after this point. */
  258. /*
  259. * Lock all the participating inodes. Depending upon whether
  260. * the target_name exists in the target directory, and
  261. * whether the target directory is the same as the source
  262. * directory, we can lock from 2 to 4 inodes.
  263. * xfs_lock_for_rename() will return ENOENT if src_name
  264. * does not exist in the source directory.
  265. */
  266. tp = NULL;
  267. error = xfs_lock_for_rename(src_dp, target_dp, src_vname,
  268. target_vname, &src_ip, &target_ip, inodes,
  269. &num_inodes);
  270. if (error) {
  271. /*
  272. * We have nothing locked, no inode references, and
  273. * no transaction, so just get out.
  274. */
  275. goto std_return;
  276. }
  277. ASSERT(src_ip != NULL);
  278. if ((src_ip->i_d.di_mode & S_IFMT) == S_IFDIR) {
  279. /*
  280. * Check for link count overflow on target_dp
  281. */
  282. if (target_ip == NULL && (src_dp != target_dp) &&
  283. target_dp->i_d.di_nlink >= XFS_MAXLINK) {
  284. error = XFS_ERROR(EMLINK);
  285. xfs_rename_unlock4(inodes, XFS_ILOCK_SHARED);
  286. goto rele_return;
  287. }
  288. }
  289. /*
  290. * If we are using project inheritance, we only allow renames
  291. * into our tree when the project IDs are the same; else the
  292. * tree quota mechanism would be circumvented.
  293. */
  294. if (unlikely((target_dp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) &&
  295. (target_dp->i_d.di_projid != src_ip->i_d.di_projid))) {
  296. error = XFS_ERROR(EXDEV);
  297. xfs_rename_unlock4(inodes, XFS_ILOCK_SHARED);
  298. goto rele_return;
  299. }
  300. new_parent = (src_dp != target_dp);
  301. src_is_directory = ((src_ip->i_d.di_mode & S_IFMT) == S_IFDIR);
  302. /*
  303. * Drop the locks on our inodes so that we can start the transaction.
  304. */
  305. xfs_rename_unlock4(inodes, XFS_ILOCK_SHARED);
  306. XFS_BMAP_INIT(&free_list, &first_block);
  307. tp = xfs_trans_alloc(mp, XFS_TRANS_RENAME);
  308. cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
  309. spaceres = XFS_RENAME_SPACE_RES(mp, target_namelen);
  310. error = xfs_trans_reserve(tp, spaceres, XFS_RENAME_LOG_RES(mp), 0,
  311. XFS_TRANS_PERM_LOG_RES, XFS_RENAME_LOG_COUNT);
  312. if (error == ENOSPC) {
  313. spaceres = 0;
  314. error = xfs_trans_reserve(tp, 0, XFS_RENAME_LOG_RES(mp), 0,
  315. XFS_TRANS_PERM_LOG_RES, XFS_RENAME_LOG_COUNT);
  316. }
  317. if (error) {
  318. xfs_trans_cancel(tp, 0);
  319. goto rele_return;
  320. }
  321. /*
  322. * Attach the dquots to the inodes
  323. */
  324. if ((error = XFS_QM_DQVOPRENAME(mp, inodes))) {
  325. xfs_trans_cancel(tp, cancel_flags);
  326. goto rele_return;
  327. }
  328. /*
  329. * Reacquire the inode locks we dropped above.
  330. */
  331. xfs_lock_inodes(inodes, num_inodes, 0, XFS_ILOCK_EXCL);
  332. /*
  333. * Join all the inodes to the transaction. From this point on,
  334. * we can rely on either trans_commit or trans_cancel to unlock
  335. * them. Note that we need to add a vnode reference to the
  336. * directories since trans_commit & trans_cancel will decrement
  337. * them when they unlock the inodes. Also, we need to be careful
  338. * not to add an inode to the transaction more than once.
  339. */
  340. VN_HOLD(src_dir_vp);
  341. xfs_trans_ijoin(tp, src_dp, XFS_ILOCK_EXCL);
  342. if (new_parent) {
  343. VN_HOLD(target_dir_vp);
  344. xfs_trans_ijoin(tp, target_dp, XFS_ILOCK_EXCL);
  345. }
  346. if ((src_ip != src_dp) && (src_ip != target_dp)) {
  347. xfs_trans_ijoin(tp, src_ip, XFS_ILOCK_EXCL);
  348. }
  349. if ((target_ip != NULL) &&
  350. (target_ip != src_ip) &&
  351. (target_ip != src_dp) &&
  352. (target_ip != target_dp)) {
  353. xfs_trans_ijoin(tp, target_ip, XFS_ILOCK_EXCL);
  354. }
  355. /*
  356. * Set up the target.
  357. */
  358. if (target_ip == NULL) {
  359. /*
  360. * If there's no space reservation, check the entry will
  361. * fit before actually inserting it.
  362. */
  363. if (spaceres == 0 &&
  364. (error = xfs_dir_canenter(tp, target_dp, target_name,
  365. target_namelen)))
  366. goto error_return;
  367. /*
  368. * If target does not exist and the rename crosses
  369. * directories, adjust the target directory link count
  370. * to account for the ".." reference from the new entry.
  371. */
  372. error = xfs_dir_createname(tp, target_dp, target_name,
  373. target_namelen, src_ip->i_ino,
  374. &first_block, &free_list, spaceres);
  375. if (error == ENOSPC)
  376. goto error_return;
  377. if (error)
  378. goto abort_return;
  379. xfs_ichgtime(target_dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
  380. if (new_parent && src_is_directory) {
  381. error = xfs_bumplink(tp, target_dp);
  382. if (error)
  383. goto abort_return;
  384. }
  385. } else { /* target_ip != NULL */
  386. /*
  387. * If target exists and it's a directory, check that both
  388. * target and source are directories and that target can be
  389. * destroyed, or that neither is a directory.
  390. */
  391. if ((target_ip->i_d.di_mode & S_IFMT) == S_IFDIR) {
  392. /*
  393. * Make sure target dir is empty.
  394. */
  395. if (!(xfs_dir_isempty(target_ip)) ||
  396. (target_ip->i_d.di_nlink > 2)) {
  397. error = XFS_ERROR(EEXIST);
  398. goto error_return;
  399. }
  400. }
  401. /*
  402. * Link the source inode under the target name.
  403. * If the source inode is a directory and we are moving
  404. * it across directories, its ".." entry will be
  405. * inconsistent until we replace that down below.
  406. *
  407. * In case there is already an entry with the same
  408. * name at the destination directory, remove it first.
  409. */
  410. error = xfs_dir_replace(tp, target_dp, target_name,
  411. target_namelen, src_ip->i_ino,
  412. &first_block, &free_list, spaceres);
  413. if (error)
  414. goto abort_return;
  415. xfs_ichgtime(target_dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
  416. /*
  417. * Decrement the link count on the target since the target
  418. * dir no longer points to it.
  419. */
  420. error = xfs_droplink(tp, target_ip);
  421. if (error)
  422. goto abort_return;
  423. target_ip_dropped = 1;
  424. if (src_is_directory) {
  425. /*
  426. * Drop the link from the old "." entry.
  427. */
  428. error = xfs_droplink(tp, target_ip);
  429. if (error)
  430. goto abort_return;
  431. }
  432. /* Do this test while we still hold the locks */
  433. target_link_zero = (target_ip)->i_d.di_nlink==0;
  434. } /* target_ip != NULL */
  435. /*
  436. * Remove the source.
  437. */
  438. if (new_parent && src_is_directory) {
  439. /*
  440. * Rewrite the ".." entry to point to the new
  441. * directory.
  442. */
  443. error = xfs_dir_replace(tp, src_ip, "..", 2, target_dp->i_ino,
  444. &first_block, &free_list, spaceres);
  445. ASSERT(error != EEXIST);
  446. if (error)
  447. goto abort_return;
  448. xfs_ichgtime(src_ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
  449. } else {
  450. /*
  451. * We always want to hit the ctime on the source inode.
  452. * We do it in the if clause above for the 'new_parent &&
  453. * src_is_directory' case, and here we get all the other
  454. * cases. This isn't strictly required by the standards
  455. * since the source inode isn't really being changed,
  456. * but old unix file systems did it and some incremental
  457. * backup programs won't work without it.
  458. */
  459. xfs_ichgtime(src_ip, XFS_ICHGTIME_CHG);
  460. }
  461. /*
  462. * Adjust the link count on src_dp. This is necessary when
  463. * renaming a directory, either within one parent when
  464. * the target existed, or across two parent directories.
  465. */
  466. if (src_is_directory && (new_parent || target_ip != NULL)) {
  467. /*
  468. * Decrement link count on src_directory since the
  469. * entry that's moved no longer points to it.
  470. */
  471. error = xfs_droplink(tp, src_dp);
  472. if (error)
  473. goto abort_return;
  474. }
  475. error = xfs_dir_removename(tp, src_dp, src_name, src_namelen,
  476. src_ip->i_ino, &first_block, &free_list, spaceres);
  477. if (error)
  478. goto abort_return;
  479. xfs_ichgtime(src_dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
  480. /*
  481. * Update the generation counts on all the directory inodes
  482. * that we're modifying.
  483. */
  484. src_dp->i_gen++;
  485. xfs_trans_log_inode(tp, src_dp, XFS_ILOG_CORE);
  486. if (new_parent) {
  487. target_dp->i_gen++;
  488. xfs_trans_log_inode(tp, target_dp, XFS_ILOG_CORE);
  489. }
  490. /*
  491. * If there was a target inode, take an extra reference on
  492. * it here so that it doesn't go to xfs_inactive() from
  493. * within the commit.
  494. */
  495. if (target_ip != NULL) {
  496. IHOLD(target_ip);
  497. }
  498. /*
  499. * If this is a synchronous mount, make sure that the
  500. * rename transaction goes to disk before returning to
  501. * the user.
  502. */
  503. if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC)) {
  504. xfs_trans_set_sync(tp);
  505. }
  506. /*
  507. * Take refs. for vop_link_removed calls below. No need to worry
  508. * about directory refs. because the caller holds them.
  509. *
  510. * Do holds before the xfs_bmap_finish since it might rele them down
  511. * to zero.
  512. */
  513. if (target_ip_dropped)
  514. IHOLD(target_ip);
  515. IHOLD(src_ip);
  516. error = xfs_bmap_finish(&tp, &free_list, &committed);
  517. if (error) {
  518. xfs_bmap_cancel(&free_list);
  519. xfs_trans_cancel(tp, (XFS_TRANS_RELEASE_LOG_RES |
  520. XFS_TRANS_ABORT));
  521. if (target_ip != NULL) {
  522. IRELE(target_ip);
  523. }
  524. if (target_ip_dropped) {
  525. IRELE(target_ip);
  526. }
  527. IRELE(src_ip);
  528. goto std_return;
  529. }
  530. /*
  531. * trans_commit will unlock src_ip, target_ip & decrement
  532. * the vnode references.
  533. */
  534. error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES, NULL);
  535. if (target_ip != NULL) {
  536. xfs_refcache_purge_ip(target_ip);
  537. IRELE(target_ip);
  538. }
  539. /*
  540. * Let interposed file systems know about removed links.
  541. */
  542. if (target_ip_dropped) {
  543. bhv_vop_link_removed(XFS_ITOV(target_ip), target_dir_vp,
  544. target_link_zero);
  545. IRELE(target_ip);
  546. }
  547. IRELE(src_ip);
  548. /* Fall through to std_return with error = 0 or errno from
  549. * xfs_trans_commit */
  550. std_return:
  551. if (DM_EVENT_ENABLED(src_dir_vp->v_vfsp, src_dp, DM_EVENT_POSTRENAME) ||
  552. DM_EVENT_ENABLED(target_dir_vp->v_vfsp,
  553. target_dp, DM_EVENT_POSTRENAME)) {
  554. (void) XFS_SEND_NAMESP (mp, DM_EVENT_POSTRENAME,
  555. src_dir_vp, DM_RIGHT_NULL,
  556. target_dir_vp, DM_RIGHT_NULL,
  557. src_name, target_name,
  558. 0, error, 0);
  559. }
  560. return error;
  561. abort_return:
  562. cancel_flags |= XFS_TRANS_ABORT;
  563. /* FALLTHROUGH */
  564. error_return:
  565. xfs_bmap_cancel(&free_list);
  566. xfs_trans_cancel(tp, cancel_flags);
  567. goto std_return;
  568. rele_return:
  569. IRELE(src_ip);
  570. if (target_ip != NULL) {
  571. IRELE(target_ip);
  572. }
  573. goto std_return;
  574. }