1 /* 2 * linux/fs/hfsplus/inode.c 3 * 4 * Copyright (C) 2001 5 * Brad Boyer (flar@allandria.com) 6 * (C) 2003 Ardis Technologies <roman@ardistech.com> 7 * 8 * Inode handling routines 9 */ 10 11 #include <linux/blkdev.h> 12 #include <linux/mm.h> 13 #include <linux/fs.h> 14 #include <linux/pagemap.h> 15 #include <linux/mpage.h> 16 #include <linux/sched.h> 17 18 #include "hfsplus_fs.h" 19 #include "hfsplus_raw.h" 20 21 static int hfsplus_readpage(struct file *file, struct page *page) 22 { 23 return block_read_full_page(page, hfsplus_get_block); 24 } 25 26 static int hfsplus_writepage(struct page *page, struct writeback_control *wbc) 27 { 28 return block_write_full_page(page, hfsplus_get_block, wbc); 29 } 30 31 static int hfsplus_write_begin(struct file *file, struct address_space *mapping, 32 loff_t pos, unsigned len, unsigned flags, 33 struct page **pagep, void **fsdata) 34 { 35 int ret; 36 37 *pagep = NULL; 38 ret = cont_write_begin(file, mapping, pos, len, flags, pagep, fsdata, 39 hfsplus_get_block, 40 &HFSPLUS_I(mapping->host)->phys_size); 41 if (unlikely(ret)) { 42 loff_t isize = mapping->host->i_size; 43 if (pos + len > isize) 44 vmtruncate(mapping->host, isize); 45 } 46 47 return ret; 48 } 49 50 static sector_t hfsplus_bmap(struct address_space *mapping, sector_t block) 51 { 52 return generic_block_bmap(mapping, block, hfsplus_get_block); 53 } 54 55 static int hfsplus_releasepage(struct page *page, gfp_t mask) 56 { 57 struct inode *inode = page->mapping->host; 58 struct super_block *sb = inode->i_sb; 59 struct hfs_btree *tree; 60 struct hfs_bnode *node; 61 u32 nidx; 62 int i, res = 1; 63 64 switch (inode->i_ino) { 65 case HFSPLUS_EXT_CNID: 66 tree = HFSPLUS_SB(sb)->ext_tree; 67 break; 68 case HFSPLUS_CAT_CNID: 69 tree = HFSPLUS_SB(sb)->cat_tree; 70 break; 71 case HFSPLUS_ATTR_CNID: 72 tree = HFSPLUS_SB(sb)->attr_tree; 73 break; 74 default: 75 BUG(); 76 return 0; 77 } 78 if (!tree) 79 return 0; 80 if (tree->node_size >= PAGE_CACHE_SIZE) { 81 nidx = page->index >> 82 (tree->node_size_shift - PAGE_CACHE_SHIFT); 83 spin_lock(&tree->hash_lock); 84 node = hfs_bnode_findhash(tree, nidx); 85 if (!node) 86 ; 87 else if (atomic_read(&node->refcnt)) 88 res = 0; 89 if (res && node) { 90 hfs_bnode_unhash(node); 91 hfs_bnode_free(node); 92 } 93 spin_unlock(&tree->hash_lock); 94 } else { 95 nidx = page->index << 96 (PAGE_CACHE_SHIFT - tree->node_size_shift); 97 i = 1 << (PAGE_CACHE_SHIFT - tree->node_size_shift); 98 spin_lock(&tree->hash_lock); 99 do { 100 node = hfs_bnode_findhash(tree, nidx++); 101 if (!node) 102 continue; 103 if (atomic_read(&node->refcnt)) { 104 res = 0; 105 break; 106 } 107 hfs_bnode_unhash(node); 108 hfs_bnode_free(node); 109 } while (--i && nidx < tree->node_count); 110 spin_unlock(&tree->hash_lock); 111 } 112 return res ? try_to_free_buffers(page) : 0; 113 } 114 115 static ssize_t hfsplus_direct_IO(int rw, struct kiocb *iocb, 116 const struct iovec *iov, loff_t offset, unsigned long nr_segs) 117 { 118 struct file *file = iocb->ki_filp; 119 struct inode *inode = file->f_path.dentry->d_inode->i_mapping->host; 120 ssize_t ret; 121 122 ret = blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov, 123 offset, nr_segs, hfsplus_get_block, NULL); 124 125 /* 126 * In case of error extending write may have instantiated a few 127 * blocks outside i_size. Trim these off again. 128 */ 129 if (unlikely((rw & WRITE) && ret < 0)) { 130 loff_t isize = i_size_read(inode); 131 loff_t end = offset + iov_length(iov, nr_segs); 132 133 if (end > isize) 134 vmtruncate(inode, isize); 135 } 136 137 return ret; 138 } 139 140 static int hfsplus_writepages(struct address_space *mapping, 141 struct writeback_control *wbc) 142 { 143 return mpage_writepages(mapping, wbc, hfsplus_get_block); 144 } 145 146 const struct address_space_operations hfsplus_btree_aops = { 147 .readpage = hfsplus_readpage, 148 .writepage = hfsplus_writepage, 149 .write_begin = hfsplus_write_begin, 150 .write_end = generic_write_end, 151 .bmap = hfsplus_bmap, 152 .releasepage = hfsplus_releasepage, 153 }; 154 155 const struct address_space_operations hfsplus_aops = { 156 .readpage = hfsplus_readpage, 157 .writepage = hfsplus_writepage, 158 .write_begin = hfsplus_write_begin, 159 .write_end = generic_write_end, 160 .bmap = hfsplus_bmap, 161 .direct_IO = hfsplus_direct_IO, 162 .writepages = hfsplus_writepages, 163 }; 164 165 const struct dentry_operations hfsplus_dentry_operations = { 166 .d_hash = hfsplus_hash_dentry, 167 .d_compare = hfsplus_compare_dentry, 168 }; 169 170 static struct dentry *hfsplus_file_lookup(struct inode *dir, 171 struct dentry *dentry, struct nameidata *nd) 172 { 173 struct hfs_find_data fd; 174 struct super_block *sb = dir->i_sb; 175 struct inode *inode = NULL; 176 struct hfsplus_inode_info *hip; 177 int err; 178 179 if (HFSPLUS_IS_RSRC(dir) || strcmp(dentry->d_name.name, "rsrc")) 180 goto out; 181 182 inode = HFSPLUS_I(dir)->rsrc_inode; 183 if (inode) 184 goto out; 185 186 inode = new_inode(sb); 187 if (!inode) 188 return ERR_PTR(-ENOMEM); 189 190 hip = HFSPLUS_I(inode); 191 inode->i_ino = dir->i_ino; 192 INIT_LIST_HEAD(&hip->open_dir_list); 193 mutex_init(&hip->extents_lock); 194 hip->extent_state = 0; 195 hip->flags = 0; 196 set_bit(HFSPLUS_I_RSRC, &hip->flags); 197 198 hfs_find_init(HFSPLUS_SB(sb)->cat_tree, &fd); 199 err = hfsplus_find_cat(sb, dir->i_ino, &fd); 200 if (!err) 201 err = hfsplus_cat_read_inode(inode, &fd); 202 hfs_find_exit(&fd); 203 if (err) { 204 iput(inode); 205 return ERR_PTR(err); 206 } 207 hip->rsrc_inode = dir; 208 HFSPLUS_I(dir)->rsrc_inode = inode; 209 igrab(dir); 210 211 /* 212 * __mark_inode_dirty expects inodes to be hashed. Since we don't 213 * want resource fork inodes in the regular inode space, we make them 214 * appear hashed, but do not put on any lists. hlist_del() 215 * will work fine and require no locking. 216 */ 217 hlist_add_fake(&inode->i_hash); 218 219 mark_inode_dirty(inode); 220 out: 221 d_add(dentry, inode); 222 return NULL; 223 } 224 225 static void hfsplus_get_perms(struct inode *inode, 226 struct hfsplus_perm *perms, int dir) 227 { 228 struct hfsplus_sb_info *sbi = HFSPLUS_SB(inode->i_sb); 229 u16 mode; 230 231 mode = be16_to_cpu(perms->mode); 232 233 inode->i_uid = be32_to_cpu(perms->owner); 234 if (!inode->i_uid && !mode) 235 inode->i_uid = sbi->uid; 236 237 inode->i_gid = be32_to_cpu(perms->group); 238 if (!inode->i_gid && !mode) 239 inode->i_gid = sbi->gid; 240 241 if (dir) { 242 mode = mode ? (mode & S_IALLUGO) : (S_IRWXUGO & ~(sbi->umask)); 243 mode |= S_IFDIR; 244 } else if (!mode) 245 mode = S_IFREG | ((S_IRUGO|S_IWUGO) & ~(sbi->umask)); 246 inode->i_mode = mode; 247 248 HFSPLUS_I(inode)->userflags = perms->userflags; 249 if (perms->rootflags & HFSPLUS_FLG_IMMUTABLE) 250 inode->i_flags |= S_IMMUTABLE; 251 else 252 inode->i_flags &= ~S_IMMUTABLE; 253 if (perms->rootflags & HFSPLUS_FLG_APPEND) 254 inode->i_flags |= S_APPEND; 255 else 256 inode->i_flags &= ~S_APPEND; 257 } 258 259 static int hfsplus_file_open(struct inode *inode, struct file *file) 260 { 261 if (HFSPLUS_IS_RSRC(inode)) 262 inode = HFSPLUS_I(inode)->rsrc_inode; 263 if (!(file->f_flags & O_LARGEFILE) && i_size_read(inode) > MAX_NON_LFS) 264 return -EOVERFLOW; 265 atomic_inc(&HFSPLUS_I(inode)->opencnt); 266 return 0; 267 } 268 269 static int hfsplus_file_release(struct inode *inode, struct file *file) 270 { 271 struct super_block *sb = inode->i_sb; 272 273 if (HFSPLUS_IS_RSRC(inode)) 274 inode = HFSPLUS_I(inode)->rsrc_inode; 275 if (atomic_dec_and_test(&HFSPLUS_I(inode)->opencnt)) { 276 mutex_lock(&inode->i_mutex); 277 hfsplus_file_truncate(inode); 278 if (inode->i_flags & S_DEAD) { 279 hfsplus_delete_cat(inode->i_ino, 280 HFSPLUS_SB(sb)->hidden_dir, NULL); 281 hfsplus_delete_inode(inode); 282 } 283 mutex_unlock(&inode->i_mutex); 284 } 285 return 0; 286 } 287 288 static int hfsplus_setattr(struct dentry *dentry, struct iattr *attr) 289 { 290 struct inode *inode = dentry->d_inode; 291 int error; 292 293 error = inode_change_ok(inode, attr); 294 if (error) 295 return error; 296 297 if ((attr->ia_valid & ATTR_SIZE) && 298 attr->ia_size != i_size_read(inode)) { 299 error = vmtruncate(inode, attr->ia_size); 300 if (error) 301 return error; 302 } 303 304 setattr_copy(inode, attr); 305 mark_inode_dirty(inode); 306 return 0; 307 } 308 309 int hfsplus_file_fsync(struct file *file, int datasync) 310 { 311 struct inode *inode = file->f_mapping->host; 312 struct hfsplus_inode_info *hip = HFSPLUS_I(inode); 313 struct hfsplus_sb_info *sbi = HFSPLUS_SB(inode->i_sb); 314 int error = 0, error2; 315 316 /* 317 * Sync inode metadata into the catalog and extent trees. 318 */ 319 sync_inode_metadata(inode, 1); 320 321 /* 322 * And explicitly write out the btrees. 323 */ 324 if (test_and_clear_bit(HFSPLUS_I_CAT_DIRTY, &hip->flags)) 325 error = filemap_write_and_wait(sbi->cat_tree->inode->i_mapping); 326 327 if (test_and_clear_bit(HFSPLUS_I_EXT_DIRTY, &hip->flags)) { 328 error2 = 329 filemap_write_and_wait(sbi->ext_tree->inode->i_mapping); 330 if (!error) 331 error = error2; 332 } 333 334 if (test_and_clear_bit(HFSPLUS_I_ALLOC_DIRTY, &hip->flags)) { 335 error2 = filemap_write_and_wait(sbi->alloc_file->i_mapping); 336 if (!error) 337 error = error2; 338 } 339 340 if (!test_bit(HFSPLUS_SB_NOBARRIER, &sbi->flags)) 341 blkdev_issue_flush(inode->i_sb->s_bdev, GFP_KERNEL, NULL); 342 343 return error; 344 } 345 346 static const struct inode_operations hfsplus_file_inode_operations = { 347 .lookup = hfsplus_file_lookup, 348 .truncate = hfsplus_file_truncate, 349 .setattr = hfsplus_setattr, 350 .setxattr = hfsplus_setxattr, 351 .getxattr = hfsplus_getxattr, 352 .listxattr = hfsplus_listxattr, 353 }; 354 355 static const struct file_operations hfsplus_file_operations = { 356 .llseek = generic_file_llseek, 357 .read = do_sync_read, 358 .aio_read = generic_file_aio_read, 359 .write = do_sync_write, 360 .aio_write = generic_file_aio_write, 361 .mmap = generic_file_mmap, 362 .splice_read = generic_file_splice_read, 363 .fsync = hfsplus_file_fsync, 364 .open = hfsplus_file_open, 365 .release = hfsplus_file_release, 366 .unlocked_ioctl = hfsplus_ioctl, 367 }; 368 369 struct inode *hfsplus_new_inode(struct super_block *sb, int mode) 370 { 371 struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb); 372 struct inode *inode = new_inode(sb); 373 struct hfsplus_inode_info *hip; 374 375 if (!inode) 376 return NULL; 377 378 inode->i_ino = sbi->next_cnid++; 379 inode->i_mode = mode; 380 inode->i_uid = current_fsuid(); 381 inode->i_gid = current_fsgid(); 382 inode->i_nlink = 1; 383 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC; 384 385 hip = HFSPLUS_I(inode); 386 INIT_LIST_HEAD(&hip->open_dir_list); 387 mutex_init(&hip->extents_lock); 388 atomic_set(&hip->opencnt, 0); 389 hip->extent_state = 0; 390 hip->flags = 0; 391 memset(hip->first_extents, 0, sizeof(hfsplus_extent_rec)); 392 memset(hip->cached_extents, 0, sizeof(hfsplus_extent_rec)); 393 hip->alloc_blocks = 0; 394 hip->first_blocks = 0; 395 hip->cached_start = 0; 396 hip->cached_blocks = 0; 397 hip->phys_size = 0; 398 hip->fs_blocks = 0; 399 hip->rsrc_inode = NULL; 400 if (S_ISDIR(inode->i_mode)) { 401 inode->i_size = 2; 402 sbi->folder_count++; 403 inode->i_op = &hfsplus_dir_inode_operations; 404 inode->i_fop = &hfsplus_dir_operations; 405 } else if (S_ISREG(inode->i_mode)) { 406 sbi->file_count++; 407 inode->i_op = &hfsplus_file_inode_operations; 408 inode->i_fop = &hfsplus_file_operations; 409 inode->i_mapping->a_ops = &hfsplus_aops; 410 hip->clump_blocks = sbi->data_clump_blocks; 411 } else if (S_ISLNK(inode->i_mode)) { 412 sbi->file_count++; 413 inode->i_op = &page_symlink_inode_operations; 414 inode->i_mapping->a_ops = &hfsplus_aops; 415 hip->clump_blocks = 1; 416 } else 417 sbi->file_count++; 418 insert_inode_hash(inode); 419 mark_inode_dirty(inode); 420 sb->s_dirt = 1; 421 422 return inode; 423 } 424 425 void hfsplus_delete_inode(struct inode *inode) 426 { 427 struct super_block *sb = inode->i_sb; 428 429 if (S_ISDIR(inode->i_mode)) { 430 HFSPLUS_SB(sb)->folder_count--; 431 sb->s_dirt = 1; 432 return; 433 } 434 HFSPLUS_SB(sb)->file_count--; 435 if (S_ISREG(inode->i_mode)) { 436 if (!inode->i_nlink) { 437 inode->i_size = 0; 438 hfsplus_file_truncate(inode); 439 } 440 } else if (S_ISLNK(inode->i_mode)) { 441 inode->i_size = 0; 442 hfsplus_file_truncate(inode); 443 } 444 sb->s_dirt = 1; 445 } 446 447 void hfsplus_inode_read_fork(struct inode *inode, struct hfsplus_fork_raw *fork) 448 { 449 struct super_block *sb = inode->i_sb; 450 struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb); 451 struct hfsplus_inode_info *hip = HFSPLUS_I(inode); 452 u32 count; 453 int i; 454 455 memcpy(&hip->first_extents, &fork->extents, sizeof(hfsplus_extent_rec)); 456 for (count = 0, i = 0; i < 8; i++) 457 count += be32_to_cpu(fork->extents[i].block_count); 458 hip->first_blocks = count; 459 memset(hip->cached_extents, 0, sizeof(hfsplus_extent_rec)); 460 hip->cached_start = 0; 461 hip->cached_blocks = 0; 462 463 hip->alloc_blocks = be32_to_cpu(fork->total_blocks); 464 hip->phys_size = inode->i_size = be64_to_cpu(fork->total_size); 465 hip->fs_blocks = 466 (inode->i_size + sb->s_blocksize - 1) >> sb->s_blocksize_bits; 467 inode_set_bytes(inode, hip->fs_blocks << sb->s_blocksize_bits); 468 hip->clump_blocks = 469 be32_to_cpu(fork->clump_size) >> sbi->alloc_blksz_shift; 470 if (!hip->clump_blocks) { 471 hip->clump_blocks = HFSPLUS_IS_RSRC(inode) ? 472 sbi->rsrc_clump_blocks : 473 sbi->data_clump_blocks; 474 } 475 } 476 477 void hfsplus_inode_write_fork(struct inode *inode, 478 struct hfsplus_fork_raw *fork) 479 { 480 memcpy(&fork->extents, &HFSPLUS_I(inode)->first_extents, 481 sizeof(hfsplus_extent_rec)); 482 fork->total_size = cpu_to_be64(inode->i_size); 483 fork->total_blocks = cpu_to_be32(HFSPLUS_I(inode)->alloc_blocks); 484 } 485 486 int hfsplus_cat_read_inode(struct inode *inode, struct hfs_find_data *fd) 487 { 488 hfsplus_cat_entry entry; 489 int res = 0; 490 u16 type; 491 492 type = hfs_bnode_read_u16(fd->bnode, fd->entryoffset); 493 494 HFSPLUS_I(inode)->linkid = 0; 495 if (type == HFSPLUS_FOLDER) { 496 struct hfsplus_cat_folder *folder = &entry.folder; 497 498 if (fd->entrylength < sizeof(struct hfsplus_cat_folder)) 499 /* panic? */; 500 hfs_bnode_read(fd->bnode, &entry, fd->entryoffset, 501 sizeof(struct hfsplus_cat_folder)); 502 hfsplus_get_perms(inode, &folder->permissions, 1); 503 inode->i_nlink = 1; 504 inode->i_size = 2 + be32_to_cpu(folder->valence); 505 inode->i_atime = hfsp_mt2ut(folder->access_date); 506 inode->i_mtime = hfsp_mt2ut(folder->content_mod_date); 507 inode->i_ctime = hfsp_mt2ut(folder->attribute_mod_date); 508 HFSPLUS_I(inode)->create_date = folder->create_date; 509 HFSPLUS_I(inode)->fs_blocks = 0; 510 inode->i_op = &hfsplus_dir_inode_operations; 511 inode->i_fop = &hfsplus_dir_operations; 512 } else if (type == HFSPLUS_FILE) { 513 struct hfsplus_cat_file *file = &entry.file; 514 515 if (fd->entrylength < sizeof(struct hfsplus_cat_file)) 516 /* panic? */; 517 hfs_bnode_read(fd->bnode, &entry, fd->entryoffset, 518 sizeof(struct hfsplus_cat_file)); 519 520 hfsplus_inode_read_fork(inode, HFSPLUS_IS_RSRC(inode) ? 521 &file->rsrc_fork : &file->data_fork); 522 hfsplus_get_perms(inode, &file->permissions, 0); 523 inode->i_nlink = 1; 524 if (S_ISREG(inode->i_mode)) { 525 if (file->permissions.dev) 526 inode->i_nlink = 527 be32_to_cpu(file->permissions.dev); 528 inode->i_op = &hfsplus_file_inode_operations; 529 inode->i_fop = &hfsplus_file_operations; 530 inode->i_mapping->a_ops = &hfsplus_aops; 531 } else if (S_ISLNK(inode->i_mode)) { 532 inode->i_op = &page_symlink_inode_operations; 533 inode->i_mapping->a_ops = &hfsplus_aops; 534 } else { 535 init_special_inode(inode, inode->i_mode, 536 be32_to_cpu(file->permissions.dev)); 537 } 538 inode->i_atime = hfsp_mt2ut(file->access_date); 539 inode->i_mtime = hfsp_mt2ut(file->content_mod_date); 540 inode->i_ctime = hfsp_mt2ut(file->attribute_mod_date); 541 HFSPLUS_I(inode)->create_date = file->create_date; 542 } else { 543 printk(KERN_ERR "hfs: bad catalog entry used to create inode\n"); 544 res = -EIO; 545 } 546 return res; 547 } 548 549 int hfsplus_cat_write_inode(struct inode *inode) 550 { 551 struct inode *main_inode = inode; 552 struct hfs_find_data fd; 553 hfsplus_cat_entry entry; 554 555 if (HFSPLUS_IS_RSRC(inode)) 556 main_inode = HFSPLUS_I(inode)->rsrc_inode; 557 558 if (!main_inode->i_nlink) 559 return 0; 560 561 if (hfs_find_init(HFSPLUS_SB(main_inode->i_sb)->cat_tree, &fd)) 562 /* panic? */ 563 return -EIO; 564 565 if (hfsplus_find_cat(main_inode->i_sb, main_inode->i_ino, &fd)) 566 /* panic? */ 567 goto out; 568 569 if (S_ISDIR(main_inode->i_mode)) { 570 struct hfsplus_cat_folder *folder = &entry.folder; 571 572 if (fd.entrylength < sizeof(struct hfsplus_cat_folder)) 573 /* panic? */; 574 hfs_bnode_read(fd.bnode, &entry, fd.entryoffset, 575 sizeof(struct hfsplus_cat_folder)); 576 /* simple node checks? */ 577 hfsplus_cat_set_perms(inode, &folder->permissions); 578 folder->access_date = hfsp_ut2mt(inode->i_atime); 579 folder->content_mod_date = hfsp_ut2mt(inode->i_mtime); 580 folder->attribute_mod_date = hfsp_ut2mt(inode->i_ctime); 581 folder->valence = cpu_to_be32(inode->i_size - 2); 582 hfs_bnode_write(fd.bnode, &entry, fd.entryoffset, 583 sizeof(struct hfsplus_cat_folder)); 584 } else if (HFSPLUS_IS_RSRC(inode)) { 585 struct hfsplus_cat_file *file = &entry.file; 586 hfs_bnode_read(fd.bnode, &entry, fd.entryoffset, 587 sizeof(struct hfsplus_cat_file)); 588 hfsplus_inode_write_fork(inode, &file->rsrc_fork); 589 hfs_bnode_write(fd.bnode, &entry, fd.entryoffset, 590 sizeof(struct hfsplus_cat_file)); 591 } else { 592 struct hfsplus_cat_file *file = &entry.file; 593 594 if (fd.entrylength < sizeof(struct hfsplus_cat_file)) 595 /* panic? */; 596 hfs_bnode_read(fd.bnode, &entry, fd.entryoffset, 597 sizeof(struct hfsplus_cat_file)); 598 hfsplus_inode_write_fork(inode, &file->data_fork); 599 hfsplus_cat_set_perms(inode, &file->permissions); 600 if (HFSPLUS_FLG_IMMUTABLE & 601 (file->permissions.rootflags | 602 file->permissions.userflags)) 603 file->flags |= cpu_to_be16(HFSPLUS_FILE_LOCKED); 604 else 605 file->flags &= cpu_to_be16(~HFSPLUS_FILE_LOCKED); 606 file->access_date = hfsp_ut2mt(inode->i_atime); 607 file->content_mod_date = hfsp_ut2mt(inode->i_mtime); 608 file->attribute_mod_date = hfsp_ut2mt(inode->i_ctime); 609 hfs_bnode_write(fd.bnode, &entry, fd.entryoffset, 610 sizeof(struct hfsplus_cat_file)); 611 } 612 613 set_bit(HFSPLUS_I_CAT_DIRTY, &HFSPLUS_I(inode)->flags); 614 out: 615 hfs_find_exit(&fd); 616 return 0; 617 } 618