← Back to branch summary

~bkerensa/ubuntu/raring/valgrind/merge-from-deb

« back to all changes in this revision

Viewing changes to coregrind/m_syswrap/syswrap-generic.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastian Dröge
  • Date: 2006-11-16 17:56:30 UTC
  • mfrom: (1.2.2 upstream)
  • mto: This revision was merged to the branch mainline in revision 14.
  • Revision ID: james.westby@ubuntu.com-20061116175630-hatkgajb0twz0upw
Tags: upstream-3.2.1
Import upstream version 3.2.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
coregrind/m_syswrap/syswrap-generic.c
187
187
                  old_addr,old_len,new_addr,new_len, 
188
188
                  flags & VKI_MREMAP_MAYMOVE ? "MAYMOVE" : "",
189
189
                  flags & VKI_MREMAP_FIXED ? "FIXED" : "");
 
190
   if (0)
 
191
      VG_(am_show_nsegments)(0, "do_remap: before");
190
192
 
191
193
   if (flags & ~(VKI_MREMAP_FIXED | VKI_MREMAP_MAYMOVE))
192
194
      goto eINVAL;
327
329
      /* VG_(am_get_advisory_client_simple) interprets zero to mean
328
330
         non-fixed, which is not what we want */
329
331
   advised = VG_(am_get_advisory_client_simple)( needA, needL, &ok );
 
332
   if (ok) {
 
333
      /* VG_(am_get_advisory_client_simple) (first arg == 0, meaning
 
334
         this-or-nothing) is too lenient, and may allow us to trash
 
335
         the next segment along.  So make very sure that the proposed
 
336
         new area really is free.  This is perhaps overly
 
337
         conservative, but it fixes #129866. */
 
338
      NSegment* segLo = VG_(am_find_nsegment)( needA );
 
339
      NSegment* segHi = VG_(am_find_nsegment)( needA + needL - 1 );
 
340
      if (segLo == NULL || segHi == NULL 
 
341
          || segLo != segHi || segLo->kind != SkFree)
 
342
         ok = False;
 
343
   }
330
344
   if (ok && advised == needA) {
331
345
      ok = VG_(am_extend_map_client)( &d, old_seg, needL );
332
346
      if (ok) {
374
388
      /* VG_(am_get_advisory_client_simple) interprets zero to mean
375
389
         non-fixed, which is not what we want */
376
390
   advised = VG_(am_get_advisory_client_simple)( needA, needL, &ok );
 
391
   if (ok) {
 
392
      /* VG_(am_get_advisory_client_simple) (first arg == 0, meaning
 
393
         this-or-nothing) is too lenient, and may allow us to trash
 
394
         the next segment along.  So make very sure that the proposed
 
395
         new area really is free. */
 
396
      NSegment* segLo = VG_(am_find_nsegment)( needA );
 
397
      NSegment* segHi = VG_(am_find_nsegment)( needA + needL - 1 );
 
398
      if (segLo == NULL || segHi == NULL 
 
399
          || segLo != segHi || segLo->kind != SkFree)
 
400
         ok = False;
 
401
   }
377
402
   if (!ok || advised != needA)
378
403
      goto eNOMEM;
379
404
   ok = VG_(am_extend_map_client)( &d, old_seg, needL );
989
1014
      return newbrk;
990
1015
   }
991
1016
 
992
 
   if (newbrk >= rseg->end+1 - VKI_PAGE_SIZE) {
 
1017
   if (newbrk > rseg->end+1 - VKI_PAGE_SIZE) {
993
1018
      /* request is too large -- the resvn would fall below 1 page,
994
1019
         which isn't allowed. */
995
1020
      goto bad;
996
1021
   }
997
1022
 
998
1023
   newbrkP = VG_PGROUNDUP(newbrk);
999
 
   vg_assert(newbrkP > rseg->start && newbrkP < rseg->end+1 - VKI_PAGE_SIZE);
 
1024
   vg_assert(newbrkP > rseg->start && newbrkP <= rseg->end+1 - VKI_PAGE_SIZE);
1000
1025
   delta = newbrkP - rseg->start;
1001
1026
   vg_assert(delta > 0);
1002
1027
   vg_assert(VG_IS_PAGE_ALIGNED(delta));
3815
3840
                    VKI_E_TABSZ * sizeof(unsigned short) );
3816
3841
      break;
3817
3842
 
 
3843
   case VKI_GIO_UNIMAP:
 
3844
      if ( ARG3 ) {
 
3845
         struct vki_unimapdesc *desc = (struct vki_unimapdesc *) ARG3;
 
3846
         PRE_MEM_READ( "ioctl(GIO_UNIMAP)", (Addr)&desc->entry_ct,
 
3847
                       sizeof(unsigned short));
 
3848
         PRE_MEM_READ( "ioctl(GIO_UNIMAP)", (Addr)&desc->entries,
 
3849
                       sizeof(struct vki_unipair *));
 
3850
         PRE_MEM_WRITE( "ioctl(GIO_UNIMAP).entries", (Addr)desc->entries,
 
3851
                        desc->entry_ct * sizeof(struct vki_unipair));
 
3852
      }
 
3853
      break;
 
3854
   case VKI_PIO_UNIMAP:
 
3855
      if ( ARG3 ) {
 
3856
         struct vki_unimapdesc *desc = (struct vki_unimapdesc *) ARG3;
 
3857
         PRE_MEM_READ( "ioctl(GIO_UNIMAP)", (Addr)&desc->entry_ct,
 
3858
                       sizeof(unsigned short) );
 
3859
         PRE_MEM_READ( "ioctl(GIO_UNIMAP)", (Addr)&desc->entries,
 
3860
                       sizeof(struct vki_unipair *) );
 
3861
         PRE_MEM_READ( "ioctl(PIO_UNIMAP).entries", (Addr)desc->entries,
 
3862
                       desc->entry_ct * sizeof(struct vki_unipair) );
 
3863
      }
 
3864
      break;
 
3865
   case VKI_PIO_UNIMAPCLR:
 
3866
      PRE_MEM_READ( "ioctl(GIO_UNIMAP)", ARG3, sizeof(struct vki_unimapinit));
 
3867
      break;
 
3868
 
3818
3869
   case VKI_KDGKBMODE:
3819
3870
      PRE_MEM_WRITE( "ioctl(KDGKBMODE)", ARG3, sizeof(int) );
3820
3871
      break;
3902
3953
   case VKI_KDKBDREP:
3903
3954
      PRE_MEM_READ( "ioctl(KBKBDREP)", ARG3, sizeof(struct vki_kbd_repeat) );
3904
3955
      break;
 
3956
 
 
3957
   case VKI_KDFONTOP:
 
3958
      if ( ARG3 ) {
 
3959
         struct vki_console_font_op *op = (struct vki_console_font_op *) ARG3;
 
3960
         PRE_MEM_READ( "ioctl(KDFONTOP)", (Addr)op,
 
3961
                       sizeof(struct vki_console_font_op) );
 
3962
         switch ( op->op ) {
 
3963
            case VKI_KD_FONT_OP_SET:
 
3964
               PRE_MEM_READ( "ioctl(KDFONTOP,KD_FONT_OP_SET).data",
 
3965
                             (Addr)op->data,
 
3966
                             (op->width + 7) / 8 * 32 * op->charcount );
 
3967
               break;
 
3968
            case VKI_KD_FONT_OP_GET:
 
3969
               if ( op->data )
 
3970
                  PRE_MEM_WRITE( "ioctl(KDFONTOP,KD_FONT_OP_GET).data",
 
3971
                                 (Addr)op->data,
 
3972
                                 (op->width + 7) / 8 * 32 * op->charcount );
 
3973
               break;
 
3974
            case VKI_KD_FONT_OP_SET_DEFAULT:
 
3975
               if ( op->data )
 
3976
                  PRE_MEM_RASCIIZ( "ioctl(KDFONTOP,KD_FONT_OP_SET_DEFAULT).data",
 
3977
                                   (Addr)op->data );
 
3978
               break;
 
3979
            case VKI_KD_FONT_OP_COPY:
 
3980
               break;
 
3981
         }
 
3982
      }
 
3983
      break;
 
3984
 
 
3985
   case VKI_VT_OPENQRY:
 
3986
      PRE_MEM_WRITE( "ioctl(VT_OPENQRY)", ARG3, sizeof(int) );
 
3987
      break;
 
3988
   case VKI_VT_GETMODE:
 
3989
      PRE_MEM_WRITE( "ioctl(VT_GETMODE)", ARG3, sizeof(struct vki_vt_mode) );
 
3990
      break;
 
3991
   case VKI_VT_SETMODE:
 
3992
      PRE_MEM_READ( "ioctl(VT_SETMODE)", ARG3, sizeof(struct vki_vt_mode) );
 
3993
      break;
 
3994
   case VKI_VT_GETSTATE:
 
3995
      PRE_MEM_READ( "ioctl(VT_GETSTATE)", ARG3, sizeof(struct vki_vt_stat) );
 
3996
      PRE_MEM_WRITE( "ioctl(VT_GETSTATE).v_active",
 
3997
                     (Addr) &(((struct vki_vt_stat*) ARG3)->v_active),
 
3998
                     sizeof(((struct vki_vt_stat*) ARG3)->v_active));
 
3999
      PRE_MEM_WRITE( "ioctl(VT_GETSTATE).v_state",
 
4000
                     (Addr) &(((struct vki_vt_stat*) ARG3)->v_state),
 
4001
                     sizeof(((struct vki_vt_stat*) ARG3)->v_state));
 
4002
      break;
 
4003
   case VKI_VT_RELDISP:
 
4004
   case VKI_VT_ACTIVATE:
 
4005
   case VKI_VT_WAITACTIVE:
 
4006
   case VKI_VT_DISALLOCATE:
 
4007
      break;
 
4008
   case VKI_VT_RESIZE:
 
4009
      PRE_MEM_READ( "ioctl(VT_RESIZE)", ARG3, sizeof(struct vki_vt_sizes) );
 
4010
      break;
 
4011
   case VKI_VT_RESIZEX:
 
4012
      PRE_MEM_READ( "ioctl(VT_RESIZEX)", ARG3, sizeof(struct vki_vt_consize) );
 
4013
      break;
 
4014
   case VKI_VT_LOCKSWITCH:
 
4015
   case VKI_VT_UNLOCKSWITCH:
 
4016
      break;
 
4017
 
3905
4018
      
3906
4019
      /* We don't have any specific information on it, so
3907
4020
         try to do something reasonable based on direction and
4453
4566
   case VKI_PIO_UNISCRNMAP:
4454
4567
      break;
4455
4568
 
 
4569
   case VKI_GIO_UNIMAP:
 
4570
      if ( ARG3 ) {
 
4571
         struct vki_unimapdesc *desc = (struct vki_unimapdesc *) ARG3;
 
4572
         POST_MEM_WRITE( (Addr)&desc->entry_ct, sizeof(desc->entry_ct));
 
4573
         POST_MEM_WRITE( (Addr)desc->entries,
 
4574
                         desc->entry_ct * sizeof(struct vki_unipair) );
 
4575
      }
 
4576
      break;
 
4577
   case VKI_PIO_UNIMAP:
 
4578
      break;
 
4579
   case VKI_PIO_UNIMAPCLR:
 
4580
      break;
 
4581
 
4456
4582
   case VKI_KDGKBMODE:
4457
4583
      POST_MEM_WRITE( ARG3, sizeof(int) );
4458
4584
      break;
4504
4630
   case VKI_KDKBDREP:
4505
4631
      break;
4506
4632
 
 
4633
   case VKI_KDFONTOP:
 
4634
      if ( ARG3 ) {
 
4635
         struct vki_console_font_op *op = (struct vki_console_font_op *) ARG3;
 
4636
         switch ( op->op ) {
 
4637
            case VKI_KD_FONT_OP_SET:
 
4638
               break;
 
4639
            case VKI_KD_FONT_OP_GET:
 
4640
               if ( op->data )
 
4641
                  POST_MEM_WRITE( (Addr) op->data,
 
4642
                                  (op->width + 7) / 8 * 32 * op->charcount );
 
4643
               break;
 
4644
            case VKI_KD_FONT_OP_SET_DEFAULT:
 
4645
               break;
 
4646
            case VKI_KD_FONT_OP_COPY:
 
4647
               break;
 
4648
         }
 
4649
         POST_MEM_WRITE( (Addr) op, sizeof(*op));
 
4650
      }
 
4651
      break;
 
4652
 
 
4653
   case VKI_VT_OPENQRY:
 
4654
      POST_MEM_WRITE( ARG3, sizeof(int) );
 
4655
      break;
 
4656
   case VKI_VT_GETMODE:
 
4657
      POST_MEM_WRITE( ARG3, sizeof(struct vki_vt_mode) );
 
4658
      break;
 
4659
   case VKI_VT_SETMODE:
 
4660
      break;
 
4661
   case VKI_VT_GETSTATE:
 
4662
      POST_MEM_WRITE( (Addr) &(((struct vki_vt_stat*) ARG3)->v_active),
 
4663
                      sizeof(((struct vki_vt_stat*) ARG3)->v_active) );
 
4664
      POST_MEM_WRITE( (Addr) &(((struct vki_vt_stat*) ARG3)->v_state),
 
4665
                      sizeof(((struct vki_vt_stat*) ARG3)->v_state) );
 
4666
      break;
 
4667
   case VKI_VT_RELDISP:
 
4668
   case VKI_VT_ACTIVATE:
 
4669
   case VKI_VT_WAITACTIVE:
 
4670
   case VKI_VT_DISALLOCATE:
 
4671
      break;
 
4672
   case VKI_VT_RESIZE:
 
4673
      break;
 
4674
   case VKI_VT_RESIZEX:
 
4675
      break;
 
4676
   case VKI_VT_LOCKSWITCH:
 
4677
   case VKI_VT_UNLOCKSWITCH:
 
4678
      break;
 
4679
      
 
4680
 
4507
4681
      /* We don't have any specific information on it, so
4508
4682
         try to do something reasonable based on direction and
4509
4683
         size bits.  The encoding scheme is described in