git.rot13.org Git - linux/blob - fs/hfsplus/extents.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *  linux/fs/hfsplus/extents.c
   4  *
   5  * Copyright (C) 2001
   6  * Brad Boyer (flar@allandria.com)
   7  * (C) 2003 Ardis Technologies <roman@ardistech.com>
   8  *
   9  * Handling of Extents both in catalog and extents overflow trees
  10  */
  11
  12 #include <linux/errno.h>
  13 #include <linux/fs.h>
  14 #include <linux/pagemap.h>
  15
  16 #include "hfsplus_fs.h"
  17 #include "hfsplus_raw.h"
  18
  19 /* Compare two extents keys, returns 0 on same, pos/neg for difference */
  20 int hfsplus_ext_cmp_key(const hfsplus_btree_key *k1,
  21                         const hfsplus_btree_key *k2)
  22 {
  23         __be32 k1id, k2id;
  24         __be32 k1s, k2s;
  25
  26         k1id = k1->ext.cnid;
  27         k2id = k2->ext.cnid;
  28         if (k1id != k2id)
  29                 return be32_to_cpu(k1id) < be32_to_cpu(k2id) ? -1 : 1;
  30
  31         if (k1->ext.fork_type != k2->ext.fork_type)
  32                 return k1->ext.fork_type < k2->ext.fork_type ? -1 : 1;
  33
  34         k1s = k1->ext.start_block;
  35         k2s = k2->ext.start_block;
  36         if (k1s == k2s)
  37                 return 0;
  38         return be32_to_cpu(k1s) < be32_to_cpu(k2s) ? -1 : 1;
  39 }
  40
  41 static void hfsplus_ext_build_key(hfsplus_btree_key *key, u32 cnid,
  42                                   u32 block, u8 type)
  43 {
  44         key->key_len = cpu_to_be16(HFSPLUS_EXT_KEYLEN - 2);
  45         key->ext.cnid = cpu_to_be32(cnid);
  46         key->ext.start_block = cpu_to_be32(block);
  47         key->ext.fork_type = type;
  48         key->ext.pad = 0;
  49 }
  50
  51 static u32 hfsplus_ext_find_block(struct hfsplus_extent *ext, u32 off)
  52 {
  53         int i;
  54         u32 count;
  55
  56         for (i = 0; i < 8; ext++, i++) {
  57                 count = be32_to_cpu(ext->block_count);
  58                 if (off < count)
  59                         return be32_to_cpu(ext->start_block) + off;
  60                 off -= count;
  61         }
  62         /* panic? */
  63         return 0;
  64 }
  65
  66 static int hfsplus_ext_block_count(struct hfsplus_extent *ext)
  67 {
  68         int i;
  69         u32 count = 0;
  70
  71         for (i = 0; i < 8; ext++, i++)
  72                 count += be32_to_cpu(ext->block_count);
  73         return count;
  74 }
  75
  76 static u32 hfsplus_ext_lastblock(struct hfsplus_extent *ext)
  77 {
  78         int i;
  79
  80         ext += 7;
  81         for (i = 0; i < 7; ext--, i++)
  82                 if (ext->block_count)
  83                         break;
  84         return be32_to_cpu(ext->start_block) + be32_to_cpu(ext->block_count);
  85 }
  86
  87 static int __hfsplus_ext_write_extent(struct inode *inode,
  88                 struct hfs_find_data *fd)
  89 {
  90         struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
  91         int res;
  92
  93         WARN_ON(!mutex_is_locked(&hip->extents_lock));
  94
  95         hfsplus_ext_build_key(fd->search_key, inode->i_ino, hip->cached_start,
  96                               HFSPLUS_IS_RSRC(inode) ?
  97                                 HFSPLUS_TYPE_RSRC : HFSPLUS_TYPE_DATA);
  98
  99         res = hfs_brec_find(fd, hfs_find_rec_by_key);
 100         if (hip->extent_state & HFSPLUS_EXT_NEW) {
 101                 if (res != -ENOENT)
 102                         return res;
 103                 /* Fail early and avoid ENOSPC during the btree operation */
 104                 res = hfs_bmap_reserve(fd->tree, fd->tree->depth + 1);
 105                 if (res)
 106                         return res;
 107                 hfs_brec_insert(fd, hip->cached_extents,
 108                                 sizeof(hfsplus_extent_rec));
 109                 hip->extent_state &= ~(HFSPLUS_EXT_DIRTY | HFSPLUS_EXT_NEW);
 110         } else {
 111                 if (res)
 112                         return res;
 113                 hfs_bnode_write(fd->bnode, hip->cached_extents,
 114                                 fd->entryoffset, fd->entrylength);
 115                 hip->extent_state &= ~HFSPLUS_EXT_DIRTY;
 116         }
 117
 118         /*
 119          * We can't just use hfsplus_mark_inode_dirty here, because we
 120          * also get called from hfsplus_write_inode, which should not
 121          * redirty the inode.  Instead the callers have to be careful
 122          * to explicily mark the inode dirty, too.
 123          */
 124         set_bit(HFSPLUS_I_EXT_DIRTY, &hip->flags);
 125
 126         return 0;
 127 }
 128
 129 static int hfsplus_ext_write_extent_locked(struct inode *inode)
 130 {
 131         int res = 0;
 132
 133         if (HFSPLUS_I(inode)->extent_state & HFSPLUS_EXT_DIRTY) {
 134                 struct hfs_find_data fd;
 135
 136                 res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->ext_tree, &fd);
 137                 if (res)
 138                         return res;
 139                 res = __hfsplus_ext_write_extent(inode, &fd);
 140                 hfs_find_exit(&fd);
 141         }
 142         return res;
 143 }
 144
 145 int hfsplus_ext_write_extent(struct inode *inode)
 146 {
 147         int res;
 148
 149         mutex_lock(&HFSPLUS_I(inode)->extents_lock);
 150         res = hfsplus_ext_write_extent_locked(inode);
 151         mutex_unlock(&HFSPLUS_I(inode)->extents_lock);
 152
 153         return res;
 154 }
 155
 156 static inline int __hfsplus_ext_read_extent(struct hfs_find_data *fd,
 157                                             struct hfsplus_extent *extent,
 158                                             u32 cnid, u32 block, u8 type)
 159 {
 160         int res;
 161
 162         hfsplus_ext_build_key(fd->search_key, cnid, block, type);
 163         fd->key->ext.cnid = 0;
 164         res = hfs_brec_find(fd, hfs_find_rec_by_key);
 165         if (res && res != -ENOENT)
 166                 return res;
 167         if (fd->key->ext.cnid != fd->search_key->ext.cnid ||
 168             fd->key->ext.fork_type != fd->search_key->ext.fork_type)
 169                 return -ENOENT;
 170         if (fd->entrylength != sizeof(hfsplus_extent_rec))
 171                 return -EIO;
 172         hfs_bnode_read(fd->bnode, extent, fd->entryoffset,
 173                 sizeof(hfsplus_extent_rec));
 174         return 0;
 175 }
 176
 177 static inline int __hfsplus_ext_cache_extent(struct hfs_find_data *fd,
 178                 struct inode *inode, u32 block)
 179 {
 180         struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
 181         int res;
 182
 183         WARN_ON(!mutex_is_locked(&hip->extents_lock));
 184
 185         if (hip->extent_state & HFSPLUS_EXT_DIRTY) {
 186                 res = __hfsplus_ext_write_extent(inode, fd);
 187                 if (res)
 188                         return res;
 189         }
 190
 191         res = __hfsplus_ext_read_extent(fd, hip->cached_extents, inode->i_ino,
 192                                         block, HFSPLUS_IS_RSRC(inode) ?
 193                                                 HFSPLUS_TYPE_RSRC :
 194                                                 HFSPLUS_TYPE_DATA);
 195         if (!res) {
 196                 hip->cached_start = be32_to_cpu(fd->key->ext.start_block);
 197                 hip->cached_blocks =
 198                         hfsplus_ext_block_count(hip->cached_extents);
 199         } else {
 200                 hip->cached_start = hip->cached_blocks = 0;
 201                 hip->extent_state &= ~(HFSPLUS_EXT_DIRTY | HFSPLUS_EXT_NEW);
 202         }
 203         return res;
 204 }
 205
 206 static int hfsplus_ext_read_extent(struct inode *inode, u32 block)
 207 {
 208         struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
 209         struct hfs_find_data fd;
 210         int res;
 211
 212         if (block >= hip->cached_start &&
 213             block < hip->cached_start + hip->cached_blocks)
 214                 return 0;
 215
 216         res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->ext_tree, &fd);
 217         if (!res) {
 218                 res = __hfsplus_ext_cache_extent(&fd, inode, block);
 219                 hfs_find_exit(&fd);
 220         }
 221         return res;
 222 }
 223
 224 /* Get a block at iblock for inode, possibly allocating if create */
 225 int hfsplus_get_block(struct inode *inode, sector_t iblock,
 226                       struct buffer_head *bh_result, int create)
 227 {
 228         struct super_block *sb = inode->i_sb;
 229         struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb);
 230         struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
 231         int res = -EIO;
 232         u32 ablock, dblock, mask;
 233         sector_t sector;
 234         int was_dirty = 0;
 235
 236         /* Convert inode block to disk allocation block */
 237         ablock = iblock >> sbi->fs_shift;
 238
 239         if (iblock >= hip->fs_blocks) {
 240                 if (iblock > hip->fs_blocks || !create)
 241                         return -EIO;
 242                 if (ablock >= hip->alloc_blocks) {
 243                         res = hfsplus_file_extend(inode, false);
 244                         if (res)
 245                                 return res;
 246                 }
 247         } else
 248                 create = 0;
 249
 250         if (ablock < hip->first_blocks) {
 251                 dblock = hfsplus_ext_find_block(hip->first_extents, ablock);
 252                 goto done;
 253         }
 254
 255         if (inode->i_ino == HFSPLUS_EXT_CNID)
 256                 return -EIO;
 257
 258         mutex_lock(&hip->extents_lock);
 259
 260         /*
 261          * hfsplus_ext_read_extent will write out a cached extent into
 262          * the extents btree.  In that case we may have to mark the inode
 263          * dirty even for a pure read of an extent here.
 264          */
 265         was_dirty = (hip->extent_state & HFSPLUS_EXT_DIRTY);
 266         res = hfsplus_ext_read_extent(inode, ablock);
 267         if (res) {
 268                 mutex_unlock(&hip->extents_lock);
 269                 return -EIO;
 270         }
 271         dblock = hfsplus_ext_find_block(hip->cached_extents,
 272                                         ablock - hip->cached_start);
 273         mutex_unlock(&hip->extents_lock);
 274
 275 done:
 276         hfs_dbg(EXTENT, "get_block(%lu): %llu - %u\n",
 277                 inode->i_ino, (long long)iblock, dblock);
 278
 279         mask = (1 << sbi->fs_shift) - 1;
 280         sector = ((sector_t)dblock << sbi->fs_shift) +
 281                   sbi->blockoffset + (iblock & mask);
 282         map_bh(bh_result, sb, sector);
 283
 284         if (create) {
 285                 set_buffer_new(bh_result);
 286                 hip->phys_size += sb->s_blocksize;
 287                 hip->fs_blocks++;
 288                 inode_add_bytes(inode, sb->s_blocksize);
 289         }
 290         if (create || was_dirty)
 291                 mark_inode_dirty(inode);
 292         return 0;
 293 }
 294
 295 static void hfsplus_dump_extent(struct hfsplus_extent *extent)
 296 {
 297         int i;
 298
 299         hfs_dbg(EXTENT, "   ");
 300         for (i = 0; i < 8; i++)
 301                 hfs_dbg_cont(EXTENT, " %u:%u",
 302                              be32_to_cpu(extent[i].start_block),
 303                              be32_to_cpu(extent[i].block_count));
 304         hfs_dbg_cont(EXTENT, "\n");
 305 }
 306
 307 static int hfsplus_add_extent(struct hfsplus_extent *extent, u32 offset,
 308                               u32 alloc_block, u32 block_count)
 309 {
 310         u32 count, start;
 311         int i;
 312
 313         hfsplus_dump_extent(extent);
 314         for (i = 0; i < 8; extent++, i++) {
 315                 count = be32_to_cpu(extent->block_count);
 316                 if (offset == count) {
 317                         start = be32_to_cpu(extent->start_block);
 318                         if (alloc_block != start + count) {
 319                                 if (++i >= 8)
 320                                         return -ENOSPC;
 321                                 extent++;
 322                                 extent->start_block = cpu_to_be32(alloc_block);
 323                         } else
 324                                 block_count += count;
 325                         extent->block_count = cpu_to_be32(block_count);
 326                         return 0;
 327                 } else if (offset < count)
 328                         break;
 329                 offset -= count;
 330         }
 331         /* panic? */
 332         return -EIO;
 333 }
 334
 335 static int hfsplus_free_extents(struct super_block *sb,
 336                                 struct hfsplus_extent *extent,
 337                                 u32 offset, u32 block_nr)
 338 {
 339         u32 count, start;
 340         int i;
 341         int err = 0;
 342
 343         /* Mapping the allocation file may lock the extent tree */
 344         WARN_ON(mutex_is_locked(&HFSPLUS_SB(sb)->ext_tree->tree_lock));
 345
 346         hfsplus_dump_extent(extent);
 347         for (i = 0; i < 8; extent++, i++) {
 348                 count = be32_to_cpu(extent->block_count);
 349                 if (offset == count)
 350                         goto found;
 351                 else if (offset < count)
 352                         break;
 353                 offset -= count;
 354         }
 355         /* panic? */
 356         return -EIO;
 357 found:
 358         for (;;) {
 359                 start = be32_to_cpu(extent->start_block);
 360                 if (count <= block_nr) {
 361                         err = hfsplus_block_free(sb, start, count);
 362                         if (err) {
 363                                 pr_err("can't free extent\n");
 364                                 hfs_dbg(EXTENT, " start: %u count: %u\n",
 365                                         start, count);
 366                         }
 367                         extent->block_count = 0;
 368                         extent->start_block = 0;
 369                         block_nr -= count;
 370                 } else {
 371                         count -= block_nr;
 372                         err = hfsplus_block_free(sb, start + count, block_nr);
 373                         if (err) {
 374                                 pr_err("can't free extent\n");
 375                                 hfs_dbg(EXTENT, " start: %u count: %u\n",
 376                                         start, count);
 377                         }
 378                         extent->block_count = cpu_to_be32(count);
 379                         block_nr = 0;
 380                 }
 381                 if (!block_nr || !i) {
 382                         /*
 383                          * Try to free all extents and
 384                          * return only last error
 385                          */
 386                         return err;
 387                 }
 388                 i--;
 389                 extent--;
 390                 count = be32_to_cpu(extent->block_count);
 391         }
 392 }
 393
 394 int hfsplus_free_fork(struct super_block *sb, u32 cnid,
 395                 struct hfsplus_fork_raw *fork, int type)
 396 {
 397         struct hfs_find_data fd;
 398         hfsplus_extent_rec ext_entry;
 399         u32 total_blocks, blocks, start;
 400         int res, i;
 401
 402         total_blocks = be32_to_cpu(fork->total_blocks);
 403         if (!total_blocks)
 404                 return 0;
 405
 406         blocks = 0;
 407         for (i = 0; i < 8; i++)
 408                 blocks += be32_to_cpu(fork->extents[i].block_count);
 409
 410         res = hfsplus_free_extents(sb, fork->extents, blocks, blocks);
 411         if (res)
 412                 return res;
 413         if (total_blocks == blocks)
 414                 return 0;
 415
 416         res = hfs_find_init(HFSPLUS_SB(sb)->ext_tree, &fd);
 417         if (res)
 418                 return res;
 419         do {
 420                 res = __hfsplus_ext_read_extent(&fd, ext_entry, cnid,
 421                                                 total_blocks, type);
 422                 if (res)
 423                         break;
 424                 start = be32_to_cpu(fd.key->ext.start_block);
 425                 hfs_brec_remove(&fd);
 426
 427                 mutex_unlock(&fd.tree->tree_lock);
 428                 hfsplus_free_extents(sb, ext_entry, total_blocks - start,
 429                                      total_blocks);
 430                 total_blocks = start;
 431                 mutex_lock(&fd.tree->tree_lock);
 432         } while (total_blocks > blocks);
 433         hfs_find_exit(&fd);
 434
 435         return res;
 436 }
 437
 438 int hfsplus_file_extend(struct inode *inode, bool zeroout)
 439 {
 440         struct super_block *sb = inode->i_sb;
 441         struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb);
 442         struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
 443         u32 start, len, goal;
 444         int res;
 445
 446         if (sbi->alloc_file->i_size * 8 <
 447             sbi->total_blocks - sbi->free_blocks + 8) {
 448                 /* extend alloc file */
 449                 pr_err("extend alloc file! (%llu,%u,%u)\n",
 450                        sbi->alloc_file->i_size * 8,
 451                        sbi->total_blocks, sbi->free_blocks);
 452                 return -ENOSPC;
 453         }
 454
 455         mutex_lock(&hip->extents_lock);
 456         if (hip->alloc_blocks == hip->first_blocks)
 457                 goal = hfsplus_ext_lastblock(hip->first_extents);
 458         else {
 459                 res = hfsplus_ext_read_extent(inode, hip->alloc_blocks);
 460                 if (res)
 461                         goto out;
 462                 goal = hfsplus_ext_lastblock(hip->cached_extents);
 463         }
 464
 465         len = hip->clump_blocks;
 466         start = hfsplus_block_allocate(sb, sbi->total_blocks, goal, &len);
 467         if (start >= sbi->total_blocks) {
 468                 start = hfsplus_block_allocate(sb, goal, 0, &len);
 469                 if (start >= goal) {
 470                         res = -ENOSPC;
 471                         goto out;
 472                 }
 473         }
 474
 475         if (zeroout) {
 476                 res = sb_issue_zeroout(sb, start, len, GFP_NOFS);
 477                 if (res)
 478                         goto out;
 479         }
 480
 481         hfs_dbg(EXTENT, "extend %lu: %u,%u\n", inode->i_ino, start, len);
 482
 483         if (hip->alloc_blocks <= hip->first_blocks) {
 484                 if (!hip->first_blocks) {
 485                         hfs_dbg(EXTENT, "first extents\n");
 486                         /* no extents yet */
 487                         hip->first_extents[0].start_block = cpu_to_be32(start);
 488                         hip->first_extents[0].block_count = cpu_to_be32(len);
 489                         res = 0;
 490                 } else {
 491                         /* try to append to extents in inode */
 492                         res = hfsplus_add_extent(hip->first_extents,
 493                                                  hip->alloc_blocks,
 494                                                  start, len);
 495                         if (res == -ENOSPC)
 496                                 goto insert_extent;
 497                 }
 498                 if (!res) {
 499                         hfsplus_dump_extent(hip->first_extents);
 500                         hip->first_blocks += len;
 501                 }
 502         } else {
 503                 res = hfsplus_add_extent(hip->cached_extents,
 504                                          hip->alloc_blocks - hip->cached_start,
 505                                          start, len);
 506                 if (!res) {
 507                         hfsplus_dump_extent(hip->cached_extents);
 508                         hip->extent_state |= HFSPLUS_EXT_DIRTY;
 509                         hip->cached_blocks += len;
 510                 } else if (res == -ENOSPC)
 511                         goto insert_extent;
 512         }
 513 out:
 514         if (!res) {
 515                 hip->alloc_blocks += len;
 516                 mutex_unlock(&hip->extents_lock);
 517                 hfsplus_mark_inode_dirty(inode, HFSPLUS_I_ALLOC_DIRTY);
 518                 return 0;
 519         }
 520         mutex_unlock(&hip->extents_lock);
 521         return res;
 522
 523 insert_extent:
 524         hfs_dbg(EXTENT, "insert new extent\n");
 525         res = hfsplus_ext_write_extent_locked(inode);
 526         if (res)
 527                 goto out;
 528
 529         memset(hip->cached_extents, 0, sizeof(hfsplus_extent_rec));
 530         hip->cached_extents[0].start_block = cpu_to_be32(start);
 531         hip->cached_extents[0].block_count = cpu_to_be32(len);
 532         hfsplus_dump_extent(hip->cached_extents);
 533         hip->extent_state |= HFSPLUS_EXT_DIRTY | HFSPLUS_EXT_NEW;
 534         hip->cached_start = hip->alloc_blocks;
 535         hip->cached_blocks = len;
 536
 537         res = 0;
 538         goto out;
 539 }
 540
 541 void hfsplus_file_truncate(struct inode *inode)
 542 {
 543         struct super_block *sb = inode->i_sb;
 544         struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
 545         struct hfs_find_data fd;
 546         u32 alloc_cnt, blk_cnt, start;
 547         int res;
 548
 549         hfs_dbg(INODE, "truncate: %lu, %llu -> %llu\n",
 550                 inode->i_ino, (long long)hip->phys_size, inode->i_size);
 551
 552         if (inode->i_size > hip->phys_size) {
 553                 struct address_space *mapping = inode->i_mapping;
 554                 struct page *page;
 555                 void *fsdata;
 556                 loff_t size = inode->i_size;
 557
 558                 res = pagecache_write_begin(NULL, mapping, size, 0, 0,
 559                                             &page, &fsdata);
 560                 if (res)
 561                         return;
 562                 res = pagecache_write_end(NULL, mapping, size,
 563                         0, 0, page, fsdata);
 564                 if (res < 0)
 565                         return;
 566                 mark_inode_dirty(inode);
 567                 return;
 568         } else if (inode->i_size == hip->phys_size)
 569                 return;
 570
 571         blk_cnt = (inode->i_size + HFSPLUS_SB(sb)->alloc_blksz - 1) >>
 572                         HFSPLUS_SB(sb)->alloc_blksz_shift;
 573
 574         mutex_lock(&hip->extents_lock);
 575
 576         alloc_cnt = hip->alloc_blocks;
 577         if (blk_cnt == alloc_cnt)
 578                 goto out_unlock;
 579
 580         res = hfs_find_init(HFSPLUS_SB(sb)->ext_tree, &fd);
 581         if (res) {
 582                 mutex_unlock(&hip->extents_lock);
 583                 /* XXX: We lack error handling of hfsplus_file_truncate() */
 584                 return;
 585         }
 586         while (1) {
 587                 if (alloc_cnt == hip->first_blocks) {
 588                         mutex_unlock(&fd.tree->tree_lock);
 589                         hfsplus_free_extents(sb, hip->first_extents,
 590                                              alloc_cnt, alloc_cnt - blk_cnt);
 591                         hfsplus_dump_extent(hip->first_extents);
 592                         hip->first_blocks = blk_cnt;
 593                         mutex_lock(&fd.tree->tree_lock);
 594                         break;
 595                 }
 596                 res = __hfsplus_ext_cache_extent(&fd, inode, alloc_cnt);
 597                 if (res)
 598                         break;
 599                 hfs_brec_remove(&fd);
 600
 601                 mutex_unlock(&fd.tree->tree_lock);
 602                 start = hip->cached_start;
 603                 hfsplus_free_extents(sb, hip->cached_extents,
 604                                      alloc_cnt - start, alloc_cnt - blk_cnt);
 605                 hfsplus_dump_extent(hip->cached_extents);
 606                 if (blk_cnt > start) {
 607                         hip->extent_state |= HFSPLUS_EXT_DIRTY;
 608                         break;
 609                 }
 610                 alloc_cnt = start;
 611                 hip->cached_start = hip->cached_blocks = 0;
 612                 hip->extent_state &= ~(HFSPLUS_EXT_DIRTY | HFSPLUS_EXT_NEW);
 613                 mutex_lock(&fd.tree->tree_lock);
 614         }
 615         hfs_find_exit(&fd);
 616
 617         hip->alloc_blocks = blk_cnt;
 618 out_unlock:
 619         mutex_unlock(&hip->extents_lock);
 620         hip->phys_size = inode->i_size;
 621         hip->fs_blocks = (inode->i_size + sb->s_blocksize - 1) >>
 622                 sb->s_blocksize_bits;
 623         inode_set_bytes(inode, hip->fs_blocks << sb->s_blocksize_bits);
 624         hfsplus_mark_inode_dirty(inode, HFSPLUS_I_ALLOC_DIRTY);
 625 }