arch/h8300/kernel/signal.c

   1 /*
   2  *  linux/arch/h8300/kernel/signal.c
   3  *
   4  *  Copyright (C) 1991, 1992  Linus Torvalds
   5  *
   6  * This file is subject to the terms and conditions of the GNU General Public
   7  * License.  See the file COPYING in the main directory of this archive
   8  * for more details.
   9  */
  10
  11 /*
  12  * uClinux H8/300 support by Yoshinori Sato <ysato@users.sourceforge.jp>
  13  *                and David McCullough <davidm@snapgear.com>
  14  *
  15  * Based on
  16  * Linux/m68k by Hamish Macdonald
  17  */
  18
  19 /*
  20  * ++roman (07/09/96): implemented signal stacks (specially for tosemu on
  21  * Atari :-) Current limitation: Only one sigstack can be active at one time.
  22  * If a second signal with SA_ONSTACK set arrives while working on a sigstack,
  23  * SA_ONSTACK is ignored. This behaviour avoids lots of trouble with nested
  24  * signal handlers!
  25  */
  26
  27 #include <linux/sched.h>
  28 #include <linux/mm.h>
  29 #include <linux/kernel.h>
  30 #include <linux/signal.h>
  31 #include <linux/syscalls.h>
  32 #include <linux/errno.h>
  33 #include <linux/wait.h>
  34 #include <linux/ptrace.h>
  35 #include <linux/unistd.h>
  36 #include <linux/stddef.h>
  37 #include <linux/highuid.h>
  38 #include <linux/personality.h>
  39 #include <linux/tty.h>
  40 #include <linux/binfmts.h>
  41
  42 #include <asm/setup.h>
  43 #include <asm/uaccess.h>
  44 #include <asm/pgtable.h>
  45 #include <asm/traps.h>
  46 #include <asm/ucontext.h>
  47
  48 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  49
  50 asmlinkage int do_signal(sigset_t *oldset, struct pt_regs *regs);
  51
  52 /*
  53  * Atomically swap in the new signal mask, and wait for a signal.
  54  */
  55 asmlinkage int do_sigsuspend(struct pt_regs *regs)
  56 {
  57         old_sigset_t mask = regs->er3;
  58         sigset_t saveset;
  59
  60         mask &= _BLOCKABLE;
  61         spin_lock_irq(&current->sighand->siglock);
  62         saveset = current->blocked;
  63         siginitset(&current->blocked, mask);
  64         recalc_sigpending();
  65         spin_unlock_irq(&current->sighand->siglock);
  66
  67         regs->er0 = -EINTR;
  68         while (1) {
  69                 current->state = TASK_INTERRUPTIBLE;
  70                 schedule();
  71                 if (do_signal(&saveset, regs))
  72                         return -EINTR;
  73         }
  74 }
  75
  76 asmlinkage int
  77 do_rt_sigsuspend(struct pt_regs *regs)
  78 {
  79         sigset_t *unewset = (sigset_t *)regs->er1;
  80         size_t sigsetsize = (size_t)regs->er2;
  81         sigset_t saveset, newset;
  82
  83         /* XXX: Don't preclude handling different sized sigset_t's.  */
  84         if (sigsetsize != sizeof(sigset_t))
  85                 return -EINVAL;
  86
  87         if (copy_from_user(&newset, unewset, sizeof(newset)))
  88                 return -EFAULT;
  89         sigdelsetmask(&newset, ~_BLOCKABLE);
  90
  91         spin_lock_irq(&current->sighand->siglock);
  92         saveset = current->blocked;
  93         current->blocked = newset;
  94         recalc_sigpending();
  95         spin_unlock_irq(&current->sighand->siglock);
  96
  97         regs->er0 = -EINTR;
  98         while (1) {
  99                 current->state = TASK_INTERRUPTIBLE;
 100                 schedule();
 101                 if (do_signal(&saveset, regs))
 102                         return -EINTR;
 103         }
 104 }
 105
 106 asmlinkage int
 107 sys_sigaction(int sig, const struct old_sigaction *act,
 108               struct old_sigaction *oact)
 109 {
 110         struct k_sigaction new_ka, old_ka;
 111         int ret;
 112
 113         if (act) {
 114                 old_sigset_t mask;
 115                 if (verify_area(VERIFY_READ, act, sizeof(*act)) ||
 116                     __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
 117                     __get_user(new_ka.sa.sa_restorer, &act->sa_restorer))
 118                         return -EFAULT;
 119                 __get_user(new_ka.sa.sa_flags, &act->sa_flags);
 120                 __get_user(mask, &act->sa_mask);
 121                 siginitset(&new_ka.sa.sa_mask, mask);
 122         }
 123
 124         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 125
 126         if (!ret && oact) {
 127                 if (verify_area(VERIFY_WRITE, oact, sizeof(*oact)) ||
 128                     __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
 129                     __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer))
 130                         return -EFAULT;
 131                 __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
 132                 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
 133         }
 134
 135         return ret;
 136 }
 137
 138 asmlinkage int
 139 sys_sigaltstack(const stack_t *uss, stack_t *uoss)
 140 {
 141         return do_sigaltstack(uss, uoss, rdusp());
 142 }
 143
 144
 145 /*
 146  * Do a signal return; undo the signal stack.
 147  *
 148  * Keep the return code on the stack quadword aligned!
 149  * That makes the cache flush below easier.
 150  */
 151
 152 struct sigframe
 153 {
 154         long dummy_er0;
 155         long dummy_vector;
 156 #if defined(CONFIG_CPU_H8S)
 157         short dummy_exr;
 158 #endif
 159         long dummy_pc;
 160         char *pretcode;
 161         unsigned char retcode[8];
 162         unsigned long extramask[_NSIG_WORDS-1];
 163         struct sigcontext sc;
 164 } __attribute__((aligned(2),packed));
 165
 166 struct rt_sigframe
 167 {
 168         long dummy_er0;
 169         long dummy_vector;
 170 #if defined(CONFIG_CPU_H8S)
 171         short dummy_exr;
 172 #endif
 173         long dummy_pc;
 174         char *pretcode;
 175         unsigned char retcode[8];
 176         struct siginfo info;
 177         struct ucontext uc;
 178 } __attribute__((aligned(2),packed));
 179
 180 static inline int
 181 restore_sigcontext(struct pt_regs *regs, struct sigcontext *usc, void *fp,
 182                    int *pd0)
 183 {
 184         struct sigcontext context;
 185         int err = 0;
 186
 187         /* get previous context */
 188         if (copy_from_user(&context, usc, sizeof(context)))
 189                 goto badframe;
 190
 191         /* restore passed registers */
 192         regs->er1 = context.sc_er1;
 193         regs->er2 = context.sc_er2;
 194         regs->er3 = context.sc_er3;
 195         regs->er5 = context.sc_er5;
 196         regs->ccr = (regs->ccr & 0x10)|(context.sc_ccr & 0xef);
 197         regs->pc = context.sc_pc;
 198         regs->orig_er0 = -1;            /* disable syscall checks */
 199         wrusp(context.sc_usp);
 200
 201         *pd0 = context.sc_er0;
 202         return err;
 203
 204 badframe:
 205         return 1;
 206 }
 207
 208 static inline int
 209 rt_restore_ucontext(struct pt_regs *regs, struct ucontext *uc, int *pd0)
 210 {
 211         int temp;
 212         greg_t *gregs = uc->uc_mcontext.gregs;
 213         unsigned long usp;
 214         int err;
 215
 216         err = __get_user(temp, &uc->uc_mcontext.version);
 217         if (temp != MCONTEXT_VERSION)
 218                 goto badframe;
 219         /* restore passed registers */
 220         err |= __get_user(regs->er0, &gregs[0]);
 221         err |= __get_user(regs->er1, &gregs[1]);
 222         err |= __get_user(regs->er2, &gregs[2]);
 223         err |= __get_user(regs->er3, &gregs[3]);
 224         err |= __get_user(regs->er4, &gregs[4]);
 225         err |= __get_user(regs->er5, &gregs[5]);
 226         err |= __get_user(regs->er6, &gregs[6]);
 227         err |= __get_user(usp, &gregs[7]);
 228         wrusp(usp);
 229         err |= __get_user(regs->pc, &gregs[8]);
 230         err |= __get_user(temp, &gregs[9]);
 231         regs->ccr = (regs->ccr & 0x10) | (temp & 0xef);
 232         regs->orig_er0 = -1;            /* disable syscall checks */
 233
 234         if (do_sigaltstack(&uc->uc_stack, NULL, usp) == -EFAULT)
 235                 goto badframe;
 236
 237         *pd0 = regs->er0;
 238         return err;
 239
 240 badframe:
 241         return 1;
 242 }
 243
 244 asmlinkage int do_sigreturn(unsigned long __unused,...)
 245 {
 246         struct pt_regs *regs = (struct pt_regs *) (&__unused - 1);
 247         unsigned long usp = rdusp();
 248         struct sigframe *frame = (struct sigframe *)(usp - 4);
 249         sigset_t set;
 250         int er0;
 251
 252         if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
 253                 goto badframe;
 254         if (__get_user(set.sig[0], &frame->sc.sc_mask) ||
 255             (_NSIG_WORDS > 1 &&
 256              __copy_from_user(&set.sig[1], &frame->extramask,
 257                               sizeof(frame->extramask))))
 258                 goto badframe;
 259
 260         sigdelsetmask(&set, ~_BLOCKABLE);
 261         spin_lock_irq(&current->sighand->siglock);
 262         current->blocked = set;
 263         recalc_sigpending();
 264         spin_unlock_irq(&current->sighand->siglock);
 265
 266         if (restore_sigcontext(regs, &frame->sc, frame + 1, &er0))
 267                 goto badframe;
 268         return er0;
 269
 270 badframe:
 271         force_sig(SIGSEGV, current);
 272         return 0;
 273 }
 274
 275 asmlinkage int do_rt_sigreturn(unsigned long __unused,...)
 276 {
 277         struct pt_regs *regs = (struct pt_regs *) &__unused;
 278         unsigned long usp = rdusp();
 279         struct rt_sigframe *frame = (struct rt_sigframe *)(usp - 4);
 280         sigset_t set;
 281         int er0;
 282
 283         if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
 284                 goto badframe;
 285         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 286                 goto badframe;
 287
 288         sigdelsetmask(&set, ~_BLOCKABLE);
 289         spin_unlock_irq(&current->sighand->siglock);
 290         current->blocked = set;
 291         recalc_sigpending();
 292         spin_lock_irq(&current->sighand->siglock);
 293
 294         if (rt_restore_ucontext(regs, &frame->uc, &er0))
 295                 goto badframe;
 296         return er0;
 297
 298 badframe:
 299         force_sig(SIGSEGV, current);
 300         return 0;
 301 }
 302
 303 static void setup_sigcontext(struct sigcontext *sc, struct pt_regs *regs,
 304                              unsigned long mask)
 305 {
 306         sc->sc_mask = mask;
 307         sc->sc_usp = rdusp();
 308         sc->sc_er0 = regs->er0;
 309         sc->sc_er1 = regs->er1;
 310         sc->sc_er2 = regs->er2;
 311         sc->sc_er3 = regs->er3;
 312         sc->sc_er5 = regs->er5;
 313         sc->sc_ccr = regs->ccr;
 314         sc->sc_pc = regs->pc;
 315 }
 316
 317 static inline int rt_setup_ucontext(struct ucontext *uc, struct pt_regs *regs)
 318 {
 319         greg_t *gregs = uc->uc_mcontext.gregs;
 320         int err = 0;
 321
 322         err |= __put_user(MCONTEXT_VERSION, &uc->uc_mcontext.version);
 323         err |= __put_user(regs->er0, &gregs[0]);
 324         err |= __put_user(regs->er1, &gregs[1]);
 325         err |= __put_user(regs->er2, &gregs[2]);
 326         err |= __put_user(regs->er3, &gregs[3]);
 327         err |= __put_user(regs->er4, &gregs[4]);
 328         err |= __put_user(regs->er5, &gregs[5]);
 329         err |= __put_user(regs->er6, &gregs[6]);
 330         err |= __put_user(rdusp(), &gregs[7]);
 331         err |= __put_user(regs->pc, &gregs[8]);
 332         err |= __put_user(regs->ccr, &gregs[9]);
 333         return err;
 334 }
 335
 336 static inline void *
 337 get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size)
 338 {
 339         unsigned long usp;
 340
 341         /* Default to using normal stack.  */
 342         usp = rdusp();
 343
 344         /* This is the X/Open sanctioned signal stack switching.  */
 345         if (ka->sa.sa_flags & SA_ONSTACK) {
 346                 if (!on_sig_stack(usp))
 347                         usp = current->sas_ss_sp + current->sas_ss_size;
 348         }
 349         return (void *)((usp - frame_size) & -8UL);
 350 }
 351
 352 static void setup_frame (int sig, struct k_sigaction *ka,
 353                          sigset_t *set, struct pt_regs *regs)
 354 {
 355         struct sigframe *frame;
 356         struct sigcontext context;
 357         int err = 0;
 358
 359         frame = get_sigframe(ka, regs, sizeof(*frame));
 360
 361         if (_NSIG_WORDS > 1)
 362                 err |= copy_to_user(frame->extramask, &set->sig[1],
 363                                     sizeof(frame->extramask));
 364
 365         setup_sigcontext(&context, regs, set->sig[0]);
 366         err |= copy_to_user (&frame->sc, &context, sizeof(context));
 367
 368         /* Set up to return from userspace.  */
 369         err |= __put_user(frame->retcode, &frame->pretcode);
 370
 371         /* sub.l er0,er0; mov.b #__NR_sigreturn,r0l; trapa #0 */
 372         err != __put_user(0x1a80f800 + (__NR_sigreturn & 0xff),
 373                         (unsigned long *)(frame->retcode + 0));
 374         err |= __put_user(0x5700, (unsigned short *)(frame->retcode + 4));
 375
 376
 377         if (err)
 378                 goto give_sigsegv;
 379
 380         /* Set up registers for signal handler */
 381         wrusp ((unsigned long) frame);
 382         regs->pc = (unsigned long) ka->sa.sa_handler;
 383         regs->er0 = (current_thread_info()->exec_domain
 384                            && current_thread_info()->exec_domain->signal_invmap
 385                            && sig < 32
 386                            ? current_thread_info()->exec_domain->signal_invmap[sig]
 387                           : sig);
 388         regs->er1 = (unsigned long)&(frame->sc);
 389         regs->er5 = current->mm->start_data;    /* GOT base */
 390
 391         return;
 392
 393 give_sigsegv:
 394         if (sig == SIGSEGV)
 395                 ka->sa.sa_handler = SIG_DFL;
 396         force_sig(SIGSEGV, current);
 397 }
 398
 399 static void setup_rt_frame (int sig, struct k_sigaction *ka, siginfo_t *info,
 400                             sigset_t *set, struct pt_regs *regs)
 401 {
 402         struct rt_sigframe *frame;
 403         int err = 0;
 404
 405         frame = get_sigframe(ka, regs, sizeof(*frame));
 406
 407         err |= copy_siginfo_to_user(&frame->info, info);
 408
 409         /* Create the ucontext.  */
 410         err |= __put_user(0, &frame->uc.uc_flags);
 411         err |= __put_user(0, &frame->uc.uc_link);
 412         err |= __put_user((void *)current->sas_ss_sp,
 413                           &frame->uc.uc_stack.ss_sp);
 414         err |= __put_user(sas_ss_flags(rdusp()),
 415                           &frame->uc.uc_stack.ss_flags);
 416         err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
 417         err |= rt_setup_ucontext(&frame->uc, regs);
 418         err |= copy_to_user (&frame->uc.uc_sigmask, set, sizeof(*set));
 419
 420         /* Set up to return from userspace.  */
 421         err |= __put_user(frame->retcode, &frame->pretcode);
 422
 423         /* sub.l er0,er0; mov.b #__NR_rt_sigreturn,r0l; trapa #0 */
 424         err != __put_user(0x1a80f800 + (__NR_rt_sigreturn & 0xff),
 425                         (long *)(frame->retcode + 0));
 426         err |= __put_user(0x5700, (short *)(frame->retcode + 4));
 427
 428         if (err)
 429                 goto give_sigsegv;
 430
 431         /* Set up registers for signal handler */
 432         wrusp ((unsigned long) frame);
 433         regs->pc  = (unsigned long) ka->sa.sa_handler;
 434         regs->er0 = (current_thread_info()->exec_domain
 435                      && current_thread_info()->exec_domain->signal_invmap
 436                      && sig < 32
 437                      ? current_thread_info()->exec_domain->signal_invmap[sig]
 438                      : sig);
 439         regs->er1 = (unsigned long)&(frame->info);
 440         regs->er2 = (unsigned long)&frame->uc;
 441         regs->er5 = current->mm->start_data;    /* GOT base */
 442
 443         return;
 444
 445 give_sigsegv:
 446         if (sig == SIGSEGV)
 447                 ka->sa.sa_handler = SIG_DFL;
 448         force_sig(SIGSEGV, current);
 449 }
 450
 451 static inline void
 452 handle_restart(struct pt_regs *regs, struct k_sigaction *ka, int has_handler)
 453 {
 454         switch (regs->er0) {
 455         case -ERESTARTNOHAND:
 456                 if (!has_handler)
 457                         goto do_restart;
 458                 regs->er0 = -EINTR;
 459                 break;
 460
 461         case -ERESTARTSYS:
 462                 if (has_handler && !(ka->sa.sa_flags & SA_RESTART)) {
 463                         regs->er0 = -EINTR;
 464                         break;
 465                 }
 466         /* fallthrough */
 467         case -ERESTARTNOINTR:
 468         do_restart:
 469                 regs->er0 = regs->orig_er0;
 470                 regs->pc -= 2;
 471                 break;
 472         }
 473 }
 474
 475 /*
 476  * OK, we're invoking a handler
 477  */
 478 static void
 479 handle_signal(int sig, struct k_sigaction *ka, siginfo_t *info,
 480               sigset_t *oldset, struct pt_regs *regs)
 481 {
 482         /* are we from a system call? */
 483         if (regs->orig_er0 >= 0)
 484                 /* If so, check system call restarting.. */
 485                 handle_restart(regs, ka, 1);
 486
 487         /* set up the stack frame */
 488         if (ka->sa.sa_flags & SA_SIGINFO)
 489                 setup_rt_frame(sig, ka, info, oldset, regs);
 490         else
 491                 setup_frame(sig, ka, oldset, regs);
 492
 493         if (ka->sa.sa_flags & SA_ONESHOT)
 494                 ka->sa.sa_handler = SIG_DFL;
 495
 496         if (!(ka->sa.sa_flags & SA_NODEFER)) {
 497                 spin_lock_irq(&current->sighand->siglock);
 498                 sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
 499                 sigaddset(&current->blocked,sig);
 500                 recalc_sigpending();
 501                 spin_unlock_irq(&current->sighand->siglock);
 502         }
 503 }
 504
 505 /*
 506  * Note that 'init' is a special process: it doesn't get signals it doesn't
 507  * want to handle. Thus you cannot kill init even with a SIGKILL even by
 508  * mistake.
 509  *
 510  * Note that we go through the signals twice: once to check the signals
 511  * that the kernel can handle, and then we build all the user-level signal
 512  * handling stack-frames in one go after that.
 513  */
 514 asmlinkage int do_signal(sigset_t *oldset, struct pt_regs *regs)
 515 {
 516         siginfo_t info;
 517         struct k_sigaction *ka;
 518
 519         current->thread.esp0 = (unsigned long) regs;
 520
 521         if (!oldset)
 522                 oldset = &current->blocked;
 523
 524         for (;;) {
 525                 int signr;
 526
 527                 signr = get_signal_to_deliver(&info, regs, NULL);
 528
 529                 if (!signr)
 530                         break;
 531
 532                 if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {
 533                         current->exit_code = signr;
 534                         current->state = TASK_STOPPED;
 535
 536                         /* Did we come from a system call? */
 537                         if (regs->orig_er0 >= 0) {
 538                                 /* Restart the system call the same way as
 539                                    if the process were not traced.  */
 540                                 struct k_sigaction *ka =
 541                                         &current->sighand->action[signr-1];
 542                                 int has_handler =
 543                                         (ka->sa.sa_handler != SIG_IGN &&
 544                                          ka->sa.sa_handler != SIG_DFL);
 545                                 handle_restart(regs, ka, has_handler);
 546                         }
 547                         notify_parent(current, SIGCHLD);
 548                         schedule();
 549
 550                         /* We're back.  Did the debugger cancel the sig?  */
 551                         if (!(signr = current->exit_code)) {
 552                         discard_frame:
 553                             continue;
 554                         }
 555                         current->exit_code = 0;
 556
 557                         /* The debugger continued.  Ignore SIGSTOP.  */
 558                         if (signr == SIGSTOP)
 559                                 goto discard_frame;
 560
 561                         /* Update the siginfo structure.  Is this good?  */
 562                         if (signr != info.si_signo) {
 563                                 info.si_signo = signr;
 564                                 info.si_errno = 0;
 565                                 info.si_code = SI_USER;
 566                                 info.si_pid = current->parent->pid;
 567                                 info.si_uid = current->parent->uid;
 568                         }
 569
 570                         /* If the (new) signal is now blocked, requeue it.  */
 571                         if (sigismember(&current->blocked, signr)) {
 572                                 send_sig_info(signr, &info, current);
 573                                 continue;
 574                         }
 575                 }
 576
 577                 ka = &current->sighand->action[signr-1];
 578                 if (ka->sa.sa_handler == SIG_IGN) {
 579                         if (signr != SIGCHLD)
 580                                 continue;
 581                         /* Check for SIGCHLD: it's special.  */
 582                         while (sys_wait4(-1, NULL, WNOHANG, NULL) > 0)
 583                                 /* nothing */;
 584                         continue;
 585                 }
 586
 587                 if (ka->sa.sa_handler == SIG_DFL) {
 588                         int exit_code = signr;
 589
 590                         if (current->pid == 1)
 591                                 continue;
 592
 593                         switch (signr) {
 594                         case SIGCONT: case SIGCHLD:
 595                         case SIGWINCH: case SIGURG:
 596                                 continue;
 597
 598                         case SIGTSTP: case SIGTTIN: case SIGTTOU:
 599                                 if (is_orphaned_pgrp(process_group(current)))
 600                                         continue;
 601                                 /* FALLTHRU */
 602
 603                         case SIGSTOP: {
 604                                 struct sighand_struct *sig;
 605                                 current->state = TASK_STOPPED;
 606                                 current->exit_code = signr;
 607                                 sig = current->parent->sighand;
 608                                 if (sig && !(sig->action[SIGCHLD-1].sa.sa_flags
 609 & SA_NOCLDSTOP))
 610                                         notify_parent(current, SIGCHLD);
 611                                 schedule();
 612                                 continue;
 613                         }
 614
 615                         case SIGQUIT: case SIGILL: case SIGTRAP:
 616                         case SIGIOT: case SIGFPE: case SIGSEGV:
 617                         case SIGBUS: case SIGSYS: case SIGXCPU: case SIGXFSZ:
 618                                 if (do_coredump(signr, exit_code, regs))
 619                                         exit_code |= 0x80;
 620                                 /* FALLTHRU */
 621
 622                         default:
 623                                 sigaddset(&current->pending.signal, signr);
 624                                 recalc_sigpending();
 625                                 current->flags |= PF_SIGNALED;
 626                                 do_exit(exit_code);
 627                                 /* NOTREACHED */
 628                         }
 629                 }
 630
 631                 /* Whee!  Actually deliver the signal.  */
 632                 handle_signal(signr, ka, &info, oldset, regs);
 633                 return 1;
 634         }
 635
 636         /* Did we come from a system call? */
 637         if (regs->orig_er0 >= 0)
 638                 /* Restart the system call - no handlers present */
 639                 handle_restart(regs, NULL, 0);
 640
 641         return 0;
 642 }