jfs_extent.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651
  1. /*
  2. * Copyright (C) International Business Machines Corp., 2000-2004
  3. *
  4. * This program is free software; you can redistribute it and/or modify
  5. * it under the terms of the GNU General Public License as published by
  6. * the Free Software Foundation; either version 2 of the License, or
  7. * (at your option) any later version.
  8. *
  9. * This program is distributed in the hope that it will be useful,
  10. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
  12. * the 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 to the Free Software
  16. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  17. */
  18. #include <linux/fs.h>
  19. #include <linux/quotaops.h>
  20. #include "jfs_incore.h"
  21. #include "jfs_inode.h"
  22. #include "jfs_superblock.h"
  23. #include "jfs_dmap.h"
  24. #include "jfs_extent.h"
  25. #include "jfs_debug.h"
  26. /*
  27. * forward references
  28. */
  29. static int extBalloc(struct inode *, s64, s64 *, s64 *);
  30. #ifdef _NOTYET
  31. static int extBrealloc(struct inode *, s64, s64, s64 *, s64 *);
  32. #endif
  33. static s64 extRoundDown(s64 nb);
  34. #define DPD(a) (printk("(a): %d\n",(a)))
  35. #define DPC(a) (printk("(a): %c\n",(a)))
  36. #define DPL1(a) \
  37. { \
  38. if ((a) >> 32) \
  39. printk("(a): %x%08x ",(a)); \
  40. else \
  41. printk("(a): %x ",(a) << 32); \
  42. }
  43. #define DPL(a) \
  44. { \
  45. if ((a) >> 32) \
  46. printk("(a): %x%08x\n",(a)); \
  47. else \
  48. printk("(a): %x\n",(a) << 32); \
  49. }
  50. #define DPD1(a) (printk("(a): %d ",(a)))
  51. #define DPX(a) (printk("(a): %08x\n",(a)))
  52. #define DPX1(a) (printk("(a): %08x ",(a)))
  53. #define DPS(a) (printk("%s\n",(a)))
  54. #define DPE(a) (printk("\nENTERING: %s\n",(a)))
  55. #define DPE1(a) (printk("\nENTERING: %s",(a)))
  56. #define DPS1(a) (printk(" %s ",(a)))
  57. /*
  58. * NAME: extAlloc()
  59. *
  60. * FUNCTION: allocate an extent for a specified page range within a
  61. * file.
  62. *
  63. * PARAMETERS:
  64. * ip - the inode of the file.
  65. * xlen - requested extent length.
  66. * pno - the starting page number with the file.
  67. * xp - pointer to an xad. on entry, xad describes an
  68. * extent that is used as an allocation hint if the
  69. * xaddr of the xad is non-zero. on successful exit,
  70. * the xad describes the newly allocated extent.
  71. * abnr - bool indicating whether the newly allocated extent
  72. * should be marked as allocated but not recorded.
  73. *
  74. * RETURN VALUES:
  75. * 0 - success
  76. * -EIO - i/o error.
  77. * -ENOSPC - insufficient disk resources.
  78. */
  79. int
  80. extAlloc(struct inode *ip, s64 xlen, s64 pno, xad_t * xp, bool abnr)
  81. {
  82. struct jfs_sb_info *sbi = JFS_SBI(ip->i_sb);
  83. s64 nxlen, nxaddr, xoff, hint, xaddr = 0;
  84. int rc;
  85. int xflag;
  86. /* This blocks if we are low on resources */
  87. txBeginAnon(ip->i_sb);
  88. /* Avoid race with jfs_commit_inode() */
  89. mutex_lock(&JFS_IP(ip)->commit_mutex);
  90. /* validate extent length */
  91. if (xlen > MAXXLEN)
  92. xlen = MAXXLEN;
  93. /* get the page's starting extent offset */
  94. xoff = pno << sbi->l2nbperpage;
  95. /* check if an allocation hint was provided */
  96. if ((hint = addressXAD(xp))) {
  97. /* get the size of the extent described by the hint */
  98. nxlen = lengthXAD(xp);
  99. /* check if the hint is for the portion of the file
  100. * immediately previous to the current allocation
  101. * request and if hint extent has the same abnr
  102. * value as the current request. if so, we can
  103. * extend the hint extent to include the current
  104. * extent if we can allocate the blocks immediately
  105. * following the hint extent.
  106. */
  107. if (offsetXAD(xp) + nxlen == xoff &&
  108. abnr == ((xp->flag & XAD_NOTRECORDED) ? true : false))
  109. xaddr = hint + nxlen;
  110. /* adjust the hint to the last block of the extent */
  111. hint += (nxlen - 1);
  112. }
  113. /* allocate the disk blocks for the extent. initially, extBalloc()
  114. * will try to allocate disk blocks for the requested size (xlen).
  115. * if this fails (xlen contiguous free blocks not available), it'll
  116. * try to allocate a smaller number of blocks (producing a smaller
  117. * extent), with this smaller number of blocks consisting of the
  118. * requested number of blocks rounded down to the next smaller
  119. * power of 2 number (i.e. 16 -> 8). it'll continue to round down
  120. * and retry the allocation until the number of blocks to allocate
  121. * is smaller than the number of blocks per page.
  122. */
  123. nxlen = xlen;
  124. if ((rc = extBalloc(ip, hint ? hint : INOHINT(ip), &nxlen, &nxaddr))) {
  125. mutex_unlock(&JFS_IP(ip)->commit_mutex);
  126. return (rc);
  127. }
  128. /* Allocate blocks to quota. */
  129. rc = dquot_alloc_block(ip, nxlen);
  130. if (rc) {
  131. dbFree(ip, nxaddr, (s64) nxlen);
  132. mutex_unlock(&JFS_IP(ip)->commit_mutex);
  133. return rc;
  134. }
  135. /* determine the value of the extent flag */
  136. xflag = abnr ? XAD_NOTRECORDED : 0;
  137. /* if we can extend the hint extent to cover the current request,
  138. * extend it. otherwise, insert a new extent to
  139. * cover the current request.
  140. */
  141. if (xaddr && xaddr == nxaddr)
  142. rc = xtExtend(0, ip, xoff, (int) nxlen, 0);
  143. else
  144. rc = xtInsert(0, ip, xflag, xoff, (int) nxlen, &nxaddr, 0);
  145. /* if the extend or insert failed,
  146. * free the newly allocated blocks and return the error.
  147. */
  148. if (rc) {
  149. dbFree(ip, nxaddr, nxlen);
  150. dquot_free_block(ip, nxlen);
  151. mutex_unlock(&JFS_IP(ip)->commit_mutex);
  152. return (rc);
  153. }
  154. /* set the results of the extent allocation */
  155. XADaddress(xp, nxaddr);
  156. XADlength(xp, nxlen);
  157. XADoffset(xp, xoff);
  158. xp->flag = xflag;
  159. mark_inode_dirty(ip);
  160. mutex_unlock(&JFS_IP(ip)->commit_mutex);
  161. /*
  162. * COMMIT_SyncList flags an anonymous tlock on page that is on
  163. * sync list.
  164. * We need to commit the inode to get the page written disk.
  165. */
  166. if (test_and_clear_cflag(COMMIT_Synclist,ip))
  167. jfs_commit_inode(ip, 0);
  168. return (0);
  169. }
  170. #ifdef _NOTYET
  171. /*
  172. * NAME: extRealloc()
  173. *
  174. * FUNCTION: extend the allocation of a file extent containing a
  175. * partial back last page.
  176. *
  177. * PARAMETERS:
  178. * ip - the inode of the file.
  179. * cp - cbuf for the partial backed last page.
  180. * xlen - request size of the resulting extent.
  181. * xp - pointer to an xad. on successful exit, the xad
  182. * describes the newly allocated extent.
  183. * abnr - bool indicating whether the newly allocated extent
  184. * should be marked as allocated but not recorded.
  185. *
  186. * RETURN VALUES:
  187. * 0 - success
  188. * -EIO - i/o error.
  189. * -ENOSPC - insufficient disk resources.
  190. */
  191. int extRealloc(struct inode *ip, s64 nxlen, xad_t * xp, bool abnr)
  192. {
  193. struct super_block *sb = ip->i_sb;
  194. s64 xaddr, xlen, nxaddr, delta, xoff;
  195. s64 ntail, nextend, ninsert;
  196. int rc, nbperpage = JFS_SBI(sb)->nbperpage;
  197. int xflag;
  198. /* This blocks if we are low on resources */
  199. txBeginAnon(ip->i_sb);
  200. mutex_lock(&JFS_IP(ip)->commit_mutex);
  201. /* validate extent length */
  202. if (nxlen > MAXXLEN)
  203. nxlen = MAXXLEN;
  204. /* get the extend (partial) page's disk block address and
  205. * number of blocks.
  206. */
  207. xaddr = addressXAD(xp);
  208. xlen = lengthXAD(xp);
  209. xoff = offsetXAD(xp);
  210. /* if the extend page is abnr and if the request is for
  211. * the extent to be allocated and recorded,
  212. * make the page allocated and recorded.
  213. */
  214. if ((xp->flag & XAD_NOTRECORDED) && !abnr) {
  215. xp->flag = 0;
  216. if ((rc = xtUpdate(0, ip, xp)))
  217. goto exit;
  218. }
  219. /* try to allocated the request number of blocks for the
  220. * extent. dbRealloc() first tries to satisfy the request
  221. * by extending the allocation in place. otherwise, it will
  222. * try to allocate a new set of blocks large enough for the
  223. * request. in satisfying a request, dbReAlloc() may allocate
  224. * less than what was request but will always allocate enough
  225. * space as to satisfy the extend page.
  226. */
  227. if ((rc = extBrealloc(ip, xaddr, xlen, &nxlen, &nxaddr)))
  228. goto exit;
  229. /* Allocat blocks to quota. */
  230. rc = dquot_alloc_block(ip, nxlen);
  231. if (rc) {
  232. dbFree(ip, nxaddr, (s64) nxlen);
  233. mutex_unlock(&JFS_IP(ip)->commit_mutex);
  234. return rc;
  235. }
  236. delta = nxlen - xlen;
  237. /* check if the extend page is not abnr but the request is abnr
  238. * and the allocated disk space is for more than one page. if this
  239. * is the case, there is a miss match of abnr between the extend page
  240. * and the one or more pages following the extend page. as a result,
  241. * two extents will have to be manipulated. the first will be that
  242. * of the extent of the extend page and will be manipulated thru
  243. * an xtExtend() or an xtTailgate(), depending upon whether the
  244. * disk allocation occurred as an inplace extension. the second
  245. * extent will be manipulated (created) through an xtInsert() and
  246. * will be for the pages following the extend page.
  247. */
  248. if (abnr && (!(xp->flag & XAD_NOTRECORDED)) && (nxlen > nbperpage)) {
  249. ntail = nbperpage;
  250. nextend = ntail - xlen;
  251. ninsert = nxlen - nbperpage;
  252. xflag = XAD_NOTRECORDED;
  253. } else {
  254. ntail = nxlen;
  255. nextend = delta;
  256. ninsert = 0;
  257. xflag = xp->flag;
  258. }
  259. /* if we were able to extend the disk allocation in place,
  260. * extend the extent. otherwise, move the extent to a
  261. * new disk location.
  262. */
  263. if (xaddr == nxaddr) {
  264. /* extend the extent */
  265. if ((rc = xtExtend(0, ip, xoff + xlen, (int) nextend, 0))) {
  266. dbFree(ip, xaddr + xlen, delta);
  267. dquot_free_block(ip, nxlen);
  268. goto exit;
  269. }
  270. } else {
  271. /*
  272. * move the extent to a new location:
  273. *
  274. * xtTailgate() accounts for relocated tail extent;
  275. */
  276. if ((rc = xtTailgate(0, ip, xoff, (int) ntail, nxaddr, 0))) {
  277. dbFree(ip, nxaddr, nxlen);
  278. dquot_free_block(ip, nxlen);
  279. goto exit;
  280. }
  281. }
  282. /* check if we need to also insert a new extent */
  283. if (ninsert) {
  284. /* perform the insert. if it fails, free the blocks
  285. * to be inserted and make it appear that we only did
  286. * the xtExtend() or xtTailgate() above.
  287. */
  288. xaddr = nxaddr + ntail;
  289. if (xtInsert (0, ip, xflag, xoff + ntail, (int) ninsert,
  290. &xaddr, 0)) {
  291. dbFree(ip, xaddr, (s64) ninsert);
  292. delta = nextend;
  293. nxlen = ntail;
  294. xflag = 0;
  295. }
  296. }
  297. /* set the return results */
  298. XADaddress(xp, nxaddr);
  299. XADlength(xp, nxlen);
  300. XADoffset(xp, xoff);
  301. xp->flag = xflag;
  302. mark_inode_dirty(ip);
  303. exit:
  304. mutex_unlock(&JFS_IP(ip)->commit_mutex);
  305. return (rc);
  306. }
  307. #endif /* _NOTYET */
  308. /*
  309. * NAME: extHint()
  310. *
  311. * FUNCTION: produce an extent allocation hint for a file offset.
  312. *
  313. * PARAMETERS:
  314. * ip - the inode of the file.
  315. * offset - file offset for which the hint is needed.
  316. * xp - pointer to the xad that is to be filled in with
  317. * the hint.
  318. *
  319. * RETURN VALUES:
  320. * 0 - success
  321. * -EIO - i/o error.
  322. */
  323. int extHint(struct inode *ip, s64 offset, xad_t * xp)
  324. {
  325. struct super_block *sb = ip->i_sb;
  326. int nbperpage = JFS_SBI(sb)->nbperpage;
  327. s64 prev;
  328. int rc = 0;
  329. s64 xaddr;
  330. int xlen;
  331. int xflag;
  332. /* init the hint as "no hint provided" */
  333. XADaddress(xp, 0);
  334. /* determine the starting extent offset of the page previous
  335. * to the page containing the offset.
  336. */
  337. prev = ((offset & ~POFFSET) >> JFS_SBI(sb)->l2bsize) - nbperpage;
  338. /* if the offset is in the first page of the file, no hint provided.
  339. */
  340. if (prev < 0)
  341. goto out;
  342. rc = xtLookup(ip, prev, nbperpage, &xflag, &xaddr, &xlen, 0);
  343. if ((rc == 0) && xlen) {
  344. if (xlen != nbperpage) {
  345. jfs_error(ip->i_sb, "corrupt xtree\n");
  346. rc = -EIO;
  347. }
  348. XADaddress(xp, xaddr);
  349. XADlength(xp, xlen);
  350. XADoffset(xp, prev);
  351. /*
  352. * only preserve the abnr flag within the xad flags
  353. * of the returned hint.
  354. */
  355. xp->flag = xflag & XAD_NOTRECORDED;
  356. } else
  357. rc = 0;
  358. out:
  359. return (rc);
  360. }
  361. /*
  362. * NAME: extRecord()
  363. *
  364. * FUNCTION: change a page with a file from not recorded to recorded.
  365. *
  366. * PARAMETERS:
  367. * ip - inode of the file.
  368. * cp - cbuf of the file page.
  369. *
  370. * RETURN VALUES:
  371. * 0 - success
  372. * -EIO - i/o error.
  373. * -ENOSPC - insufficient disk resources.
  374. */
  375. int extRecord(struct inode *ip, xad_t * xp)
  376. {
  377. int rc;
  378. txBeginAnon(ip->i_sb);
  379. mutex_lock(&JFS_IP(ip)->commit_mutex);
  380. /* update the extent */
  381. rc = xtUpdate(0, ip, xp);
  382. mutex_unlock(&JFS_IP(ip)->commit_mutex);
  383. return rc;
  384. }
  385. #ifdef _NOTYET
  386. /*
  387. * NAME: extFill()
  388. *
  389. * FUNCTION: allocate disk space for a file page that represents
  390. * a file hole.
  391. *
  392. * PARAMETERS:
  393. * ip - the inode of the file.
  394. * cp - cbuf of the file page represent the hole.
  395. *
  396. * RETURN VALUES:
  397. * 0 - success
  398. * -EIO - i/o error.
  399. * -ENOSPC - insufficient disk resources.
  400. */
  401. int extFill(struct inode *ip, xad_t * xp)
  402. {
  403. int rc, nbperpage = JFS_SBI(ip->i_sb)->nbperpage;
  404. s64 blkno = offsetXAD(xp) >> ip->i_blkbits;
  405. // assert(ISSPARSE(ip));
  406. /* initialize the extent allocation hint */
  407. XADaddress(xp, 0);
  408. /* allocate an extent to fill the hole */
  409. if ((rc = extAlloc(ip, nbperpage, blkno, xp, false)))
  410. return (rc);
  411. assert(lengthPXD(xp) == nbperpage);
  412. return (0);
  413. }
  414. #endif /* _NOTYET */
  415. /*
  416. * NAME: extBalloc()
  417. *
  418. * FUNCTION: allocate disk blocks to form an extent.
  419. *
  420. * initially, we will try to allocate disk blocks for the
  421. * requested size (nblocks). if this fails (nblocks
  422. * contiguous free blocks not available), we'll try to allocate
  423. * a smaller number of blocks (producing a smaller extent), with
  424. * this smaller number of blocks consisting of the requested
  425. * number of blocks rounded down to the next smaller power of 2
  426. * number (i.e. 16 -> 8). we'll continue to round down and
  427. * retry the allocation until the number of blocks to allocate
  428. * is smaller than the number of blocks per page.
  429. *
  430. * PARAMETERS:
  431. * ip - the inode of the file.
  432. * hint - disk block number to be used as an allocation hint.
  433. * *nblocks - pointer to an s64 value. on entry, this value specifies
  434. * the desired number of block to be allocated. on successful
  435. * exit, this value is set to the number of blocks actually
  436. * allocated.
  437. * blkno - pointer to a block address that is filled in on successful
  438. * return with the starting block number of the newly
  439. * allocated block range.
  440. *
  441. * RETURN VALUES:
  442. * 0 - success
  443. * -EIO - i/o error.
  444. * -ENOSPC - insufficient disk resources.
  445. */
  446. static int
  447. extBalloc(struct inode *ip, s64 hint, s64 * nblocks, s64 * blkno)
  448. {
  449. struct jfs_inode_info *ji = JFS_IP(ip);
  450. struct jfs_sb_info *sbi = JFS_SBI(ip->i_sb);
  451. s64 nb, nblks, daddr, max;
  452. int rc, nbperpage = sbi->nbperpage;
  453. struct bmap *bmp = sbi->bmap;
  454. int ag;
  455. /* get the number of blocks to initially attempt to allocate.
  456. * we'll first try the number of blocks requested unless this
  457. * number is greater than the maximum number of contiguous free
  458. * blocks in the map. in that case, we'll start off with the
  459. * maximum free.
  460. */
  461. max = (s64) 1 << bmp->db_maxfreebud;
  462. if (*nblocks >= max && *nblocks > nbperpage)
  463. nb = nblks = (max > nbperpage) ? max : nbperpage;
  464. else
  465. nb = nblks = *nblocks;
  466. /* try to allocate blocks */
  467. while ((rc = dbAlloc(ip, hint, nb, &daddr)) != 0) {
  468. /* if something other than an out of space error,
  469. * stop and return this error.
  470. */
  471. if (rc != -ENOSPC)
  472. return (rc);
  473. /* decrease the allocation request size */
  474. nb = min(nblks, extRoundDown(nb));
  475. /* give up if we cannot cover a page */
  476. if (nb < nbperpage)
  477. return (rc);
  478. }
  479. *nblocks = nb;
  480. *blkno = daddr;
  481. if (S_ISREG(ip->i_mode) && (ji->fileset == FILESYSTEM_I)) {
  482. ag = BLKTOAG(daddr, sbi);
  483. spin_lock_irq(&ji->ag_lock);
  484. if (ji->active_ag == -1) {
  485. atomic_inc(&bmp->db_active[ag]);
  486. ji->active_ag = ag;
  487. } else if (ji->active_ag != ag) {
  488. atomic_dec(&bmp->db_active[ji->active_ag]);
  489. atomic_inc(&bmp->db_active[ag]);
  490. ji->active_ag = ag;
  491. }
  492. spin_unlock_irq(&ji->ag_lock);
  493. }
  494. return (0);
  495. }
  496. #ifdef _NOTYET
  497. /*
  498. * NAME: extBrealloc()
  499. *
  500. * FUNCTION: attempt to extend an extent's allocation.
  501. *
  502. * Initially, we will try to extend the extent's allocation
  503. * in place. If this fails, we'll try to move the extent
  504. * to a new set of blocks. If moving the extent, we initially
  505. * will try to allocate disk blocks for the requested size
  506. * (newnblks). if this fails (new contiguous free blocks not
  507. * available), we'll try to allocate a smaller number of
  508. * blocks (producing a smaller extent), with this smaller
  509. * number of blocks consisting of the requested number of
  510. * blocks rounded down to the next smaller power of 2
  511. * number (i.e. 16 -> 8). We'll continue to round down and
  512. * retry the allocation until the number of blocks to allocate
  513. * is smaller than the number of blocks per page.
  514. *
  515. * PARAMETERS:
  516. * ip - the inode of the file.
  517. * blkno - starting block number of the extents current allocation.
  518. * nblks - number of blocks within the extents current allocation.
  519. * newnblks - pointer to a s64 value. on entry, this value is the
  520. * the new desired extent size (number of blocks). on
  521. * successful exit, this value is set to the extent's actual
  522. * new size (new number of blocks).
  523. * newblkno - the starting block number of the extents new allocation.
  524. *
  525. * RETURN VALUES:
  526. * 0 - success
  527. * -EIO - i/o error.
  528. * -ENOSPC - insufficient disk resources.
  529. */
  530. static int
  531. extBrealloc(struct inode *ip,
  532. s64 blkno, s64 nblks, s64 * newnblks, s64 * newblkno)
  533. {
  534. int rc;
  535. /* try to extend in place */
  536. if ((rc = dbExtend(ip, blkno, nblks, *newnblks - nblks)) == 0) {
  537. *newblkno = blkno;
  538. return (0);
  539. } else {
  540. if (rc != -ENOSPC)
  541. return (rc);
  542. }
  543. /* in place extension not possible.
  544. * try to move the extent to a new set of blocks.
  545. */
  546. return (extBalloc(ip, blkno, newnblks, newblkno));
  547. }
  548. #endif /* _NOTYET */
  549. /*
  550. * NAME: extRoundDown()
  551. *
  552. * FUNCTION: round down a specified number of blocks to the next
  553. * smallest power of 2 number.
  554. *
  555. * PARAMETERS:
  556. * nb - the inode of the file.
  557. *
  558. * RETURN VALUES:
  559. * next smallest power of 2 number.
  560. */
  561. static s64 extRoundDown(s64 nb)
  562. {
  563. int i;
  564. u64 m, k;
  565. for (i = 0, m = (u64) 1 << 63; i < 64; i++, m >>= 1) {
  566. if (m & nb)
  567. break;
  568. }
  569. i = 63 - i;
  570. k = (u64) 1 << i;
  571. k = ((k - 1) & nb) ? k : k >> 1;
  572. return (k);
  573. }