1 /* 2 * arch/s390/kernel/compat_signal.c 3 * 4 * Copyright (C) IBM Corp. 2000,2006 5 * Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com) 6 * Gerhard Tonn (ton@de.ibm.com) 7 * 8 * Copyright (C) 1991, 1992 Linus Torvalds 9 * 10 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson 11 */ 12 13 #include <linux/compat.h> 14 #include <linux/sched.h> 15 #include <linux/mm.h> 16 #include <linux/smp.h> 17 #include <linux/kernel.h> 18 #include <linux/signal.h> 19 #include <linux/errno.h> 20 #include <linux/wait.h> 21 #include <linux/ptrace.h> 22 #include <linux/unistd.h> 23 #include <linux/stddef.h> 24 #include <linux/tty.h> 25 #include <linux/personality.h> 26 #include <linux/binfmts.h> 27 #include <asm/ucontext.h> 28 #include <asm/uaccess.h> 29 #include <asm/lowcore.h> 30 #include <asm/switch_to.h> 31 #include "compat_linux.h" 32 #include "compat_ptrace.h" 33 #include "entry.h" 34 35 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP))) 36 37 typedef struct 38 { 39 __u8 callee_used_stack[__SIGNAL_FRAMESIZE32]; 40 struct sigcontext32 sc; 41 _sigregs32 sregs; 42 int signo; 43 __u32 gprs_high[NUM_GPRS]; 44 __u8 retcode[S390_SYSCALL_SIZE]; 45 } sigframe32; 46 47 typedef struct 48 { 49 __u8 callee_used_stack[__SIGNAL_FRAMESIZE32]; 50 __u8 retcode[S390_SYSCALL_SIZE]; 51 compat_siginfo_t info; 52 struct ucontext32 uc; 53 __u32 gprs_high[NUM_GPRS]; 54 } rt_sigframe32; 55 56 int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from) 57 { 58 int err; 59 60 if (!access_ok (VERIFY_WRITE, to, sizeof(compat_siginfo_t))) 61 return -EFAULT; 62 63 /* If you change siginfo_t structure, please be sure 64 this code is fixed accordingly. 65 It should never copy any pad contained in the structure 66 to avoid security leaks, but must copy the generic 67 3 ints plus the relevant union member. 68 This routine must convert siginfo from 64bit to 32bit as well 69 at the same time. */ 70 err = __put_user(from->si_signo, &to->si_signo); 71 err |= __put_user(from->si_errno, &to->si_errno); 72 err |= __put_user((short)from->si_code, &to->si_code); 73 if (from->si_code < 0) 74 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE); 75 else { 76 switch (from->si_code >> 16) { 77 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */ 78 case __SI_MESGQ >> 16: 79 err |= __put_user(from->si_int, &to->si_int); 80 /* fallthrough */ 81 case __SI_KILL >> 16: 82 err |= __put_user(from->si_pid, &to->si_pid); 83 err |= __put_user(from->si_uid, &to->si_uid); 84 break; 85 case __SI_CHLD >> 16: 86 err |= __put_user(from->si_pid, &to->si_pid); 87 err |= __put_user(from->si_uid, &to->si_uid); 88 err |= __put_user(from->si_utime, &to->si_utime); 89 err |= __put_user(from->si_stime, &to->si_stime); 90 err |= __put_user(from->si_status, &to->si_status); 91 break; 92 case __SI_FAULT >> 16: 93 err |= __put_user((unsigned long) from->si_addr, 94 &to->si_addr); 95 break; 96 case __SI_POLL >> 16: 97 err |= __put_user(from->si_band, &to->si_band); 98 err |= __put_user(from->si_fd, &to->si_fd); 99 break; 100 case __SI_TIMER >> 16: 101 err |= __put_user(from->si_tid, &to->si_tid); 102 err |= __put_user(from->si_overrun, &to->si_overrun); 103 err |= __put_user(from->si_int, &to->si_int); 104 break; 105 default: 106 break; 107 } 108 } 109 return err; 110 } 111 112 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from) 113 { 114 int err; 115 u32 tmp; 116 117 if (!access_ok (VERIFY_READ, from, sizeof(compat_siginfo_t))) 118 return -EFAULT; 119 120 err = __get_user(to->si_signo, &from->si_signo); 121 err |= __get_user(to->si_errno, &from->si_errno); 122 err |= __get_user(to->si_code, &from->si_code); 123 124 if (to->si_code < 0) 125 err |= __copy_from_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE); 126 else { 127 switch (to->si_code >> 16) { 128 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */ 129 case __SI_MESGQ >> 16: 130 err |= __get_user(to->si_int, &from->si_int); 131 /* fallthrough */ 132 case __SI_KILL >> 16: 133 err |= __get_user(to->si_pid, &from->si_pid); 134 err |= __get_user(to->si_uid, &from->si_uid); 135 break; 136 case __SI_CHLD >> 16: 137 err |= __get_user(to->si_pid, &from->si_pid); 138 err |= __get_user(to->si_uid, &from->si_uid); 139 err |= __get_user(to->si_utime, &from->si_utime); 140 err |= __get_user(to->si_stime, &from->si_stime); 141 err |= __get_user(to->si_status, &from->si_status); 142 break; 143 case __SI_FAULT >> 16: 144 err |= __get_user(tmp, &from->si_addr); 145 to->si_addr = (void __force __user *) 146 (u64) (tmp & PSW32_ADDR_INSN); 147 break; 148 case __SI_POLL >> 16: 149 err |= __get_user(to->si_band, &from->si_band); 150 err |= __get_user(to->si_fd, &from->si_fd); 151 break; 152 case __SI_TIMER >> 16: 153 err |= __get_user(to->si_tid, &from->si_tid); 154 err |= __get_user(to->si_overrun, &from->si_overrun); 155 err |= __get_user(to->si_int, &from->si_int); 156 break; 157 default: 158 break; 159 } 160 } 161 return err; 162 } 163 164 asmlinkage long 165 sys32_sigaction(int sig, const struct old_sigaction32 __user *act, 166 struct old_sigaction32 __user *oact) 167 { 168 struct k_sigaction new_ka, old_ka; 169 unsigned long sa_handler, sa_restorer; 170 int ret; 171 172 if (act) { 173 compat_old_sigset_t mask; 174 if (!access_ok(VERIFY_READ, act, sizeof(*act)) || 175 __get_user(sa_handler, &act->sa_handler) || 176 __get_user(sa_restorer, &act->sa_restorer) || 177 __get_user(new_ka.sa.sa_flags, &act->sa_flags) || 178 __get_user(mask, &act->sa_mask)) 179 return -EFAULT; 180 new_ka.sa.sa_handler = (__sighandler_t) sa_handler; 181 new_ka.sa.sa_restorer = (void (*)(void)) sa_restorer; 182 siginitset(&new_ka.sa.sa_mask, mask); 183 } 184 185 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); 186 187 if (!ret && oact) { 188 sa_handler = (unsigned long) old_ka.sa.sa_handler; 189 sa_restorer = (unsigned long) old_ka.sa.sa_restorer; 190 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) || 191 __put_user(sa_handler, &oact->sa_handler) || 192 __put_user(sa_restorer, &oact->sa_restorer) || 193 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) || 194 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask)) 195 return -EFAULT; 196 } 197 198 return ret; 199 } 200 201 asmlinkage long 202 sys32_rt_sigaction(int sig, const struct sigaction32 __user *act, 203 struct sigaction32 __user *oact, size_t sigsetsize) 204 { 205 struct k_sigaction new_ka, old_ka; 206 unsigned long sa_handler; 207 int ret; 208 compat_sigset_t set32; 209 210 /* XXX: Don't preclude handling different sized sigset_t's. */ 211 if (sigsetsize != sizeof(compat_sigset_t)) 212 return -EINVAL; 213 214 if (act) { 215 ret = get_user(sa_handler, &act->sa_handler); 216 ret |= __copy_from_user(&set32, &act->sa_mask, 217 sizeof(compat_sigset_t)); 218 new_ka.sa.sa_mask.sig[0] = 219 set32.sig[0] | (((long)set32.sig[1]) << 32); 220 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags); 221 222 if (ret) 223 return -EFAULT; 224 new_ka.sa.sa_handler = (__sighandler_t) sa_handler; 225 } 226 227 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); 228 229 if (!ret && oact) { 230 set32.sig[1] = (old_ka.sa.sa_mask.sig[0] >> 32); 231 set32.sig[0] = old_ka.sa.sa_mask.sig[0]; 232 ret = put_user((unsigned long)old_ka.sa.sa_handler, &oact->sa_handler); 233 ret |= __copy_to_user(&oact->sa_mask, &set32, 234 sizeof(compat_sigset_t)); 235 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags); 236 } 237 238 return ret; 239 } 240 241 asmlinkage long 242 sys32_sigaltstack(const stack_t32 __user *uss, stack_t32 __user *uoss) 243 { 244 struct pt_regs *regs = task_pt_regs(current); 245 stack_t kss, koss; 246 unsigned long ss_sp; 247 int ret, err = 0; 248 mm_segment_t old_fs = get_fs(); 249 250 if (uss) { 251 if (!access_ok(VERIFY_READ, uss, sizeof(*uss))) 252 return -EFAULT; 253 err |= __get_user(ss_sp, &uss->ss_sp); 254 err |= __get_user(kss.ss_size, &uss->ss_size); 255 err |= __get_user(kss.ss_flags, &uss->ss_flags); 256 if (err) 257 return -EFAULT; 258 kss.ss_sp = (void __user *) ss_sp; 259 } 260 261 set_fs (KERNEL_DS); 262 ret = do_sigaltstack((stack_t __force __user *) (uss ? &kss : NULL), 263 (stack_t __force __user *) (uoss ? &koss : NULL), 264 regs->gprs[15]); 265 set_fs (old_fs); 266 267 if (!ret && uoss) { 268 if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss))) 269 return -EFAULT; 270 ss_sp = (unsigned long) koss.ss_sp; 271 err |= __put_user(ss_sp, &uoss->ss_sp); 272 err |= __put_user(koss.ss_size, &uoss->ss_size); 273 err |= __put_user(koss.ss_flags, &uoss->ss_flags); 274 if (err) 275 return -EFAULT; 276 } 277 return ret; 278 } 279 280 static int save_sigregs32(struct pt_regs *regs, _sigregs32 __user *sregs) 281 { 282 _s390_regs_common32 regs32; 283 int err, i; 284 285 regs32.psw.mask = psw32_user_bits | 286 ((__u32)(regs->psw.mask >> 32) & PSW32_MASK_USER); 287 regs32.psw.addr = (__u32) regs->psw.addr | 288 (__u32)(regs->psw.mask & PSW_MASK_BA); 289 for (i = 0; i < NUM_GPRS; i++) 290 regs32.gprs[i] = (__u32) regs->gprs[i]; 291 save_access_regs(current->thread.acrs); 292 memcpy(regs32.acrs, current->thread.acrs, sizeof(regs32.acrs)); 293 err = __copy_to_user(&sregs->regs, ®s32, sizeof(regs32)); 294 if (err) 295 return err; 296 save_fp_regs(¤t->thread.fp_regs); 297 /* s390_fp_regs and _s390_fp_regs32 are the same ! */ 298 return __copy_to_user(&sregs->fpregs, ¤t->thread.fp_regs, 299 sizeof(_s390_fp_regs32)); 300 } 301 302 static int restore_sigregs32(struct pt_regs *regs,_sigregs32 __user *sregs) 303 { 304 _s390_regs_common32 regs32; 305 int err, i; 306 307 /* Alwys make any pending restarted system call return -EINTR */ 308 current_thread_info()->restart_block.fn = do_no_restart_syscall; 309 310 err = __copy_from_user(®s32, &sregs->regs, sizeof(regs32)); 311 if (err) 312 return err; 313 regs->psw.mask = (regs->psw.mask & ~PSW_MASK_USER) | 314 (__u64)(regs32.psw.mask & PSW32_MASK_USER) << 32 | 315 (__u64)(regs32.psw.addr & PSW32_ADDR_AMODE); 316 regs->psw.addr = (__u64)(regs32.psw.addr & PSW32_ADDR_INSN); 317 for (i = 0; i < NUM_GPRS; i++) 318 regs->gprs[i] = (__u64) regs32.gprs[i]; 319 memcpy(current->thread.acrs, regs32.acrs, sizeof(current->thread.acrs)); 320 restore_access_regs(current->thread.acrs); 321 322 err = __copy_from_user(¤t->thread.fp_regs, &sregs->fpregs, 323 sizeof(_s390_fp_regs32)); 324 current->thread.fp_regs.fpc &= FPC_VALID_MASK; 325 if (err) 326 return err; 327 328 restore_fp_regs(¤t->thread.fp_regs); 329 clear_thread_flag(TIF_SYSCALL); /* No longer in a system call */ 330 return 0; 331 } 332 333 static int save_sigregs_gprs_high(struct pt_regs *regs, __u32 __user *uregs) 334 { 335 __u32 gprs_high[NUM_GPRS]; 336 int i; 337 338 for (i = 0; i < NUM_GPRS; i++) 339 gprs_high[i] = regs->gprs[i] >> 32; 340 341 return __copy_to_user(uregs, &gprs_high, sizeof(gprs_high)); 342 } 343 344 static int restore_sigregs_gprs_high(struct pt_regs *regs, __u32 __user *uregs) 345 { 346 __u32 gprs_high[NUM_GPRS]; 347 int err, i; 348 349 err = __copy_from_user(&gprs_high, uregs, sizeof(gprs_high)); 350 if (err) 351 return err; 352 for (i = 0; i < NUM_GPRS; i++) 353 *(__u32 *)®s->gprs[i] = gprs_high[i]; 354 return 0; 355 } 356 357 asmlinkage long sys32_sigreturn(void) 358 { 359 struct pt_regs *regs = task_pt_regs(current); 360 sigframe32 __user *frame = (sigframe32 __user *)regs->gprs[15]; 361 sigset_t set; 362 363 if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) 364 goto badframe; 365 if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE32)) 366 goto badframe; 367 sigdelsetmask(&set, ~_BLOCKABLE); 368 set_current_blocked(&set); 369 if (restore_sigregs32(regs, &frame->sregs)) 370 goto badframe; 371 if (restore_sigregs_gprs_high(regs, frame->gprs_high)) 372 goto badframe; 373 return regs->gprs[2]; 374 badframe: 375 force_sig(SIGSEGV, current); 376 return 0; 377 } 378 379 asmlinkage long sys32_rt_sigreturn(void) 380 { 381 struct pt_regs *regs = task_pt_regs(current); 382 rt_sigframe32 __user *frame = (rt_sigframe32 __user *)regs->gprs[15]; 383 sigset_t set; 384 stack_t st; 385 __u32 ss_sp; 386 int err; 387 mm_segment_t old_fs = get_fs(); 388 389 if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) 390 goto badframe; 391 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set))) 392 goto badframe; 393 sigdelsetmask(&set, ~_BLOCKABLE); 394 set_current_blocked(&set); 395 if (restore_sigregs32(regs, &frame->uc.uc_mcontext)) 396 goto badframe; 397 if (restore_sigregs_gprs_high(regs, frame->gprs_high)) 398 goto badframe; 399 err = __get_user(ss_sp, &frame->uc.uc_stack.ss_sp); 400 st.ss_sp = compat_ptr(ss_sp); 401 err |= __get_user(st.ss_size, &frame->uc.uc_stack.ss_size); 402 err |= __get_user(st.ss_flags, &frame->uc.uc_stack.ss_flags); 403 if (err) 404 goto badframe; 405 set_fs (KERNEL_DS); 406 do_sigaltstack((stack_t __force __user *)&st, NULL, regs->gprs[15]); 407 set_fs (old_fs); 408 return regs->gprs[2]; 409 badframe: 410 force_sig(SIGSEGV, current); 411 return 0; 412 } 413 414 /* 415 * Set up a signal frame. 416 */ 417 418 419 /* 420 * Determine which stack to use.. 421 */ 422 static inline void __user * 423 get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size) 424 { 425 unsigned long sp; 426 427 /* Default to using normal stack */ 428 sp = (unsigned long) A(regs->gprs[15]); 429 430 /* Overflow on alternate signal stack gives SIGSEGV. */ 431 if (on_sig_stack(sp) && !on_sig_stack((sp - frame_size) & -8UL)) 432 return (void __user *) -1UL; 433 434 /* This is the X/Open sanctioned signal stack switching. */ 435 if (ka->sa.sa_flags & SA_ONSTACK) { 436 if (! sas_ss_flags(sp)) 437 sp = current->sas_ss_sp + current->sas_ss_size; 438 } 439 440 /* This is the legacy signal stack switching. */ 441 else if (!user_mode(regs) && 442 !(ka->sa.sa_flags & SA_RESTORER) && 443 ka->sa.sa_restorer) { 444 sp = (unsigned long) ka->sa.sa_restorer; 445 } 446 447 return (void __user *)((sp - frame_size) & -8ul); 448 } 449 450 static inline int map_signal(int sig) 451 { 452 if (current_thread_info()->exec_domain 453 && current_thread_info()->exec_domain->signal_invmap 454 && sig < 32) 455 return current_thread_info()->exec_domain->signal_invmap[sig]; 456 else 457 return sig; 458 } 459 460 static int setup_frame32(int sig, struct k_sigaction *ka, 461 sigset_t *set, struct pt_regs * regs) 462 { 463 sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(sigframe32)); 464 if (!access_ok(VERIFY_WRITE, frame, sizeof(sigframe32))) 465 goto give_sigsegv; 466 467 if (frame == (void __user *) -1UL) 468 goto give_sigsegv; 469 470 if (__copy_to_user(&frame->sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE32)) 471 goto give_sigsegv; 472 473 if (save_sigregs32(regs, &frame->sregs)) 474 goto give_sigsegv; 475 if (save_sigregs_gprs_high(regs, frame->gprs_high)) 476 goto give_sigsegv; 477 if (__put_user((unsigned long) &frame->sregs, &frame->sc.sregs)) 478 goto give_sigsegv; 479 480 /* Set up to return from userspace. If provided, use a stub 481 already in userspace. */ 482 if (ka->sa.sa_flags & SA_RESTORER) { 483 regs->gprs[14] = (__u64) ka->sa.sa_restorer | PSW32_ADDR_AMODE; 484 } else { 485 regs->gprs[14] = (__u64) frame->retcode | PSW32_ADDR_AMODE; 486 if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn, 487 (u16 __force __user *)(frame->retcode))) 488 goto give_sigsegv; 489 } 490 491 /* Set up backchain. */ 492 if (__put_user(regs->gprs[15], (unsigned int __user *) frame)) 493 goto give_sigsegv; 494 495 /* Set up registers for signal handler */ 496 regs->gprs[15] = (__force __u64) frame; 497 regs->psw.mask |= PSW_MASK_BA; /* force amode 31 */ 498 regs->psw.addr = (__force __u64) ka->sa.sa_handler; 499 500 regs->gprs[2] = map_signal(sig); 501 regs->gprs[3] = (__force __u64) &frame->sc; 502 503 /* We forgot to include these in the sigcontext. 504 To avoid breaking binary compatibility, they are passed as args. */ 505 if (sig == SIGSEGV || sig == SIGBUS || sig == SIGILL || 506 sig == SIGTRAP || sig == SIGFPE) { 507 /* set extra registers only for synchronous signals */ 508 regs->gprs[4] = regs->int_code & 127; 509 regs->gprs[5] = regs->int_parm_long; 510 } 511 512 /* Place signal number on stack to allow backtrace from handler. */ 513 if (__put_user(regs->gprs[2], (int __force __user *) &frame->signo)) 514 goto give_sigsegv; 515 return 0; 516 517 give_sigsegv: 518 force_sigsegv(sig, current); 519 return -EFAULT; 520 } 521 522 static int setup_rt_frame32(int sig, struct k_sigaction *ka, siginfo_t *info, 523 sigset_t *set, struct pt_regs * regs) 524 { 525 int err = 0; 526 rt_sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(rt_sigframe32)); 527 if (!access_ok(VERIFY_WRITE, frame, sizeof(rt_sigframe32))) 528 goto give_sigsegv; 529 530 if (frame == (void __user *) -1UL) 531 goto give_sigsegv; 532 533 if (copy_siginfo_to_user32(&frame->info, info)) 534 goto give_sigsegv; 535 536 /* Create the ucontext. */ 537 err |= __put_user(UC_EXTENDED, &frame->uc.uc_flags); 538 err |= __put_user(0, &frame->uc.uc_link); 539 err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp); 540 err |= __put_user(sas_ss_flags(regs->gprs[15]), 541 &frame->uc.uc_stack.ss_flags); 542 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size); 543 err |= save_sigregs32(regs, &frame->uc.uc_mcontext); 544 err |= save_sigregs_gprs_high(regs, frame->gprs_high); 545 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)); 546 if (err) 547 goto give_sigsegv; 548 549 /* Set up to return from userspace. If provided, use a stub 550 already in userspace. */ 551 if (ka->sa.sa_flags & SA_RESTORER) { 552 regs->gprs[14] = (__u64) ka->sa.sa_restorer | PSW32_ADDR_AMODE; 553 } else { 554 regs->gprs[14] = (__u64) frame->retcode | PSW32_ADDR_AMODE; 555 err |= __put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn, 556 (u16 __force __user *)(frame->retcode)); 557 } 558 559 /* Set up backchain. */ 560 if (__put_user(regs->gprs[15], (unsigned int __force __user *) frame)) 561 goto give_sigsegv; 562 563 /* Set up registers for signal handler */ 564 regs->gprs[15] = (__force __u64) frame; 565 regs->psw.mask |= PSW_MASK_BA; /* force amode 31 */ 566 regs->psw.addr = (__u64) ka->sa.sa_handler; 567 568 regs->gprs[2] = map_signal(sig); 569 regs->gprs[3] = (__force __u64) &frame->info; 570 regs->gprs[4] = (__force __u64) &frame->uc; 571 return 0; 572 573 give_sigsegv: 574 force_sigsegv(sig, current); 575 return -EFAULT; 576 } 577 578 /* 579 * OK, we're invoking a handler 580 */ 581 582 int handle_signal32(unsigned long sig, struct k_sigaction *ka, 583 siginfo_t *info, sigset_t *oldset, struct pt_regs *regs) 584 { 585 int ret; 586 587 /* Set up the stack frame */ 588 if (ka->sa.sa_flags & SA_SIGINFO) 589 ret = setup_rt_frame32(sig, ka, info, oldset, regs); 590 else 591 ret = setup_frame32(sig, ka, oldset, regs); 592 if (ret) 593 return ret; 594 block_sigmask(ka, sig); 595 return 0; 596 } 597 598