Skip to content

W
wine-cw
Commit e32a317b authored by Marcus Meissner's avatar Marcus Meissner Committed by Alexandre Julliard
Browse files
Options

Removed the old, historical and no longer working IPC support.

parent 3dff7bb8
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 2 additions and 3284 deletions
Makefile.in
View file @ e32a317b
......@@ -51,7 +51,6 @@ LIBSUBDIRS = \
graphics/metafiledrv \
graphics/psdrv \
graphics/ttydrv \
ipc \
library \
loader \
loader/ne \
......@@ -127,7 +126,6 @@ LIBOBJS = \
graphics/metafiledrv/metafiledrv.o \
graphics/psdrv/psdrv.o \
graphics/ttydrv/ttydrv.o \
ipc/ipc.o \
loader/loader.o \
loader/ne/ne.o \
loader/dos/dos.o \
......
configure.in
View file @ e32a317b
......@@ -31,10 +31,6 @@ AC_ARG_ENABLE(lib,
[ --disable-lib build the Wine without building libwine.a],
[if test "$enableval" = "no"; then ALT_LINK="\$(LIBOBJS) \$(X11OBJS)"; LIB_TARGET=""; fi])
dnl AC_ARG_WITH(ipc,
dnl [ --enable-ipc use inter-process communication for DDE],
dnl [if test "$enableval" = "no"; then : ; else OPTIONS="-DCONFIG_IPC"; fi])
AC_ARG_ENABLE(debug,
[ --disable-debug compile out all debugging messages],
[if test "$enableval" = "no"; then DEBUG_MSGS="no"; fi])
......@@ -785,7 +781,6 @@ graphics/win16drv/Makefile
graphics/x11drv/Makefile
if1632/Makefile
include/Makefile
ipc/Makefile
library/Makefile
libtest/Makefile
loader/Makefile
......
include/dde.h
View file @ e32a317b
......@@ -12,7 +12,6 @@
#define __WINE_DDE_H
#include "windef.h"
#include "dde_proc.h"
#define WM_DDE_INITIATE 0x3E0
#define WM_DDE_TERMINATE 0x3E1
......
include/dde_atom.h deleted 100644 → 0
View file @ 3dff7bb8
/***************************************************************************
* Copyright 1995, Technion, Israel Institute of Technology
* Electrical Eng, Software Lab.
* Author: Michael Veksler.
***************************************************************************
* File: dde_atom.h
* Purpose : atom functionality for DDE
***************************************************************************
*/
#ifndef __WINE_DDE_ATOM_H
#define __WINE_DDE_ATOM_H
#ifdef CONFIG_IPC
#include "windef.h"
#define DDE_ATOMS 157 /* a prime number for hashing */
void ATOM_GlobalInit(void);
ATOM DDE_GlobalAddAtom( SEGPTR str );
ATOM DDE_GlobalDeleteAtom( ATOM atom );
ATOM DDE_GlobalFindAtom( SEGPTR str );
WORD DDE_GlobalGetAtomName( ATOM atom, LPSTR buffer, short count );
#endif /* CONFIG_IPC */
#endif __WINE_DDE_ATOM_H
include/dde_mem.h deleted 100644 → 0
View file @ 3dff7bb8
/***************************************************************************
* Copyright 1995, Technion, Israel Institute of Technology
* Electrical Eng, Software Lab.
* Author: Michael Veksler.
***************************************************************************
* File: dde_mem.h
* Purpose : shared DDE memory functionality for DDE
***************************************************************************
*/
#ifndef __WINE_DDE_MEM_H
#define __WINE_DDE_MEM_H
#ifdef CONFIG_IPC
#include "windef.h"
#include "global.h"
#include "shm_block.h"
#define DDE_HANDLES 0x0400
#define is_dde_handle(block) ( (block) >= (1<<15) && (block) < (1<<15)+DDE_HANDLES )
typedef struct {
int shmid;
REL_PTR rel;
}DDE_HWND;
WORD DDE_SyncHandle(HGLOBAL16 handle, WORD sel);
void *DDE_malloc(unsigned int flags,unsigned long size, SHMDATA *shmdata);
HANDLE16 DDE_GlobalReAlloc(WORD,long,WORD);
HGLOBAL16 DDE_GlobalFree(HGLOBAL16 block);
void *DDE_AttachHandle(HGLOBAL16 handle, SEGPTR *segptr);
WORD DDE_GlobalHandleToSel( HGLOBAL16 handle );
int DDE_GlobalUnlock(int);
HANDLE16 DDE_GlobalSize(WORD);
HANDLE16 DDE_GlobalHandle(WORD);
HANDLE16 DDE_GlobalFlags(WORD);
#endif /* CONFIG_IPC */
#endif /* __WINE_DDE_MEM_H */
include/dde_proc.h deleted 100644 → 0
View file @ 3dff7bb8
/***************************************************************************
* Copyright 1995, Technion, Israel Institute of Technology
* Electrical Eng, Software Lab.
* Author: Michael Veksler.
***************************************************************************
* File: dde_proc.h
* Purpose : DDE signals and processes functionality for DDE
***************************************************************************
*/
#ifndef __WINE_DDE_PROC_H
#define __WINE_DDE_PROC_H
#ifdef CONFIG_IPC
#include <setjmp.h>
#include "windef.h"
#include "windows.h"
#define DDE_PROCS 64
#define DDE_WINDOWS 64
struct _dde_proc {
int msg; /* message queue for this process */
int shmid; /* first shared memory block id. */
int sem; /* semaphore for fragment allocation */
int pid;
} ;
typedef struct _dde_proc *dde_proc;
extern sigjmp_buf env_wait_x;
enum stop_wait_op { /* The action to be taken upon SIGUSR2 */
CONT, /* Don't do anything */
STOP_WAIT_ACK, /* Use siglongjmp to stop wait_ack() */
STOP_WAIT_X /* siglongjmp to stop MSG_WaitXEvent() */
};
typedef struct {
WORD proc_idx; /* index into wine's process table */
HWND16 wnd; /* Window on the local proccess */
} WND_DATA;
extern enum stop_wait_op stop_wait_op;
extern int had_SIGUSR2;
extern int curr_proc_idx;
void stop_wait(int a); /* signal handler for SIGUSR2
(interrupts "select" system call) */
void dde_proc_init(dde_proc proc); /* init proc array */
void dde_proc_done(dde_proc proc); /* delete a proc entry */
void dde_proc_refresh(dde_proc proc); /* delete entry, if old junk */
void dde_proc_add(dde_proc proc); /* Add current proc to proc array */
void dde_msg_setup(int *msg_ptr);
int dde_reschedule();
void dde_wnd_setup(); /* setup Data structure of DDE windows */
/* Send ack. to hnd indicating that posted/sent msg. got to destination*/
void dde_proc_send_ack(HWND16 wnd, BOOL val);
BOOL DDE_PostMessage( MSG16 *msg);
BOOL DDE_SendMessage( MSG16 *msg);
int DDE_GetRemoteMessage();
void DDE_DestroyWindow(HWND16 hwnd); /* delete DDE info regarding hwnd */
void DDE_TestDDE(HWND16 hwnd); /* do we have dde handling in the window ?*/
#endif /* CONFIG_IPC */
#endif /* __WINE_DDE_PROC_H */
include/shm_block.h deleted 100644 → 0
View file @ 3dff7bb8
/***************************************************************************
* Copyright 1995, Technion, Israel Institute of Technology
* Electrical Eng, Software Lab.
* Author: Michael Veksler.
***************************************************************************
* File: shm_block.ch
* Purpose: treat a shared memory block.
***************************************************************************
*/
#ifndef __WINE_SHM_BLOCK_H
#define __WINE_SHM_BLOCK_H
#ifdef CONFIG_IPC
#include <sys/shm.h>
#include "windef.h"
#define SEGSIZE 0x10000 /* 64 */
#define SHM_GRANULARITY SEGSIZE
#define SHM_MINBLOCK SHM_GRANULARITY
#define SHM_MAXBLOCK (((int)SHMMAX/(int)SHM_GRANULARITY)* \
SHM_GRANULARITY)
#define PTR2REL(block,ptr) (REL_PTR) ( (char *) (ptr) - (char *) (block) )
#define REL2PTR(block,rel) (void *) ( (char *) (block) + (rel) )
typedef int REL_PTR;
/* full info for each shm block. */
struct shm_block {
/* private */
int next_shm_id; /* IPC shm ID (for initial linking) */
/* public (read only) */
int size; /* size of the shm block */
int free; /* how much of the block is free */
int proc_idx; /* The index of the owner */
/* public - writable for shm_fragment */
REL_PTR free_list; /* first item in the free list */
};
/* used for mapping local attachments */
struct local_shm_map {
struct local_shm_map *next;
int shm_id;
int proc_idx;
/* 32 bit pointer to the beginning of the block */
struct shm_block *ptr;
};
extern struct local_shm_map *shm_map;
void shm_setup_block(struct shm_block *block, REL_PTR first, int size);
/* shm_create_block:
* allocate and setup a new block:
* first - first non header byte.
* size - block size (in bytes).
* shm_id- IPC shared memory ID.
*/
struct shm_block *shm_create_block(REL_PTR first, int size, int *shm_id);
/* shm_locate_block:
* locate existing block according to shm_id,
* Attach the block if needed. Assume the shm_id is wine's
* Set selectors also.
*/
struct shm_block *shm_locate_block(int shm_id, struct local_shm_map *map);
/* shm_locate_attached_block:
* locate existing block according to shm_id,
* Blocks are never attached.
* if proc_idx is not NULL, it will be set to owner's index.
* map - localy mapped info about block may be NULL;
*/
struct shm_block *shm_locate_attached_block(int shm_id,
struct local_shm_map *map);
/* shm_attach_block: attach existing shm block, setup selectors
* shm_id - id of the block to attach.
* proc_idx - if not -1, puts this data into local mapping
* map - localy mapped info about this block. (may be NULL)
* NOTE: same block can be attached many times
*/
struct shm_block *shm_attach_block(int shm_id, int proc_idx,
struct local_shm_map *map);
/* delete chain of shm blocks (pointing to each other */
void shm_delete_chain(int *shmid);
#endif /* CONFIG_IPC */
#endif /* __WINE_SHM_BLOCK_H */
include/shm_fragment.h deleted 100644 → 0
View file @ 3dff7bb8
/***************************************************************************
* Copyright 1995, Technion, Israel Institute of Technology
* Electrical Eng, Software Lab.
* Author: Michael Veksler.
***************************************************************************
* File: shm_fragment.h
* Purpose: Data fragments and free list items. Allocate and free blocks.
***************************************************************************
*/
#ifndef __WINE_SHM_FRAGMENT_H
#define __WINE_SHM_FRAGMENT_H
#ifdef CONFIG_IPC
#include "shm_block.h"
#define NIL ((int) 0)
/* memory fragment: used or free (when free - it's an item of "free list",
* when allocated it contains the data, and it's size)
*/
struct shm_fragment {
int size; /* fragment's size */
/* The type of info depends on fragment's status (free/allocated) */
union info {
int next; /* next free fragment */
char data[1]; /* the data */
} info;
};
/* setup first item in the free list */
void shm_FragmentInit(struct shm_block *block,REL_PTR first,int size);
/* allocate shm fragment. return: offset to data in fragment, or NULL */
REL_PTR shm_FragmentAlloc(struct shm_block *block, int size);
/* like shm_FragmentAlloc, returns pointer instead of offset */
char *shm_FragPtrAlloc(struct shm_block *block, int size);
/* free shm fragment - according to offset */
void shm_FragmentFree(struct shm_block *block, int ofs);
/* free shm fragment - according to pointer */
void shm_FragPtrFree(struct shm_block *block, void *ptr);
/* This is used for debugging only */
void shm_print_free_list(struct shm_block *block);
#endif /* CONFIG_IPC */
#endif /* __WINE_SHM_FRAGMENT_H */
include/shm_main_blk.h deleted 100644 → 0
View file @ 3dff7bb8
/***************************************************************************
* Copyright 1995, Technion, Israel Institute of Technology
* Electrical Eng, Software Lab.
* Author: Michael Veksler.
***************************************************************************
* File: shm_main_blk.h
* Purpose: Main Wine's shared memory block
***************************************************************************
*/
#ifndef __WINE_SHM_MAIN_BLK_H
#define __WINE_SHM_MAIN_BLK_H
#ifdef CONFIG_IPC
#include <sys/shm.h>
#include "shm_block.h"
#include "shm_semaph.h"
#include "dde_proc.h"
#include "dde_atom.h"
#include "dde_mem.h"
/*****************************************************************************
*
* main block object
*
*****************************************************************************
*/
#define DDE_HANDLES_BIT_ARRAY_SIZE (DDE_HANDLES/sizeof(int)/8)
#define SHM_MAXID SHMSEG /* maximum shm blocks (Wine's limit) */
struct shm_main_block {
/* NOTE: "block" declaration must be the first */
struct shm_block block;
char magic[64]; /* magic string to identify the block */
int build_lock; /* =1 when data structure not stable yet */
shm_sem sem; /* semaphores for main_block integrity */
struct _dde_proc proc[DDE_PROCS]; /* information about processes */
REL_PTR atoms[DDE_ATOMS]; /* relative reference to global atoms */
/* Translation from global window handles to local handles */
WND_DATA windows[DDE_WINDOWS];
DDE_HWND handles[DDE_HANDLES];
/* bit array stating if a handle is free (bit=0), LSB in */
/* free_handles[0] refers handle 0x8000, the MSB refers 0x801F */
unsigned free_handles[DDE_HANDLES_BIT_ARRAY_SIZE];
};
extern struct shm_main_block *main_block;
int shm_init(void);
void shm_delete_all(int shm_id);
void DDE_mem_init();
int DDE_no_of_attached();
#define DDE_IPC_init() ( (main_block==NULL) ? (DDE_mem_init()) : 0 )
#endif /* CONFIG_IPC */
#endif /* __WINE_SHM_MAIN_BLK_H */
include/shm_semaph.h deleted 100644 → 0
View file @ 3dff7bb8
/***************************************************************************
* Copyright 1995, Technion, Israel Institute of Technology
* Electrical Eng, Software Lab.
* Author: Michael Veksler.
***************************************************************************
* File: shm_semaph.h
* Purpose: Handle semaphores for shared memory operations.
***************************************************************************
*/
#ifndef __WINE_SHM_SEMAPH_H
#define __WINE_SHM_SEMAPH_H
/* IMPORTANT: If possible, restrict usage of these functions. */
#ifdef CONFIG_IPC
typedef int shm_sem;
void shm_read_wait(shm_sem semid);
void shm_write_wait(shm_sem semid);
void shm_write_signal(shm_sem semid);
void shm_read_signal(shm_sem semid);
void shm_sem_init(shm_sem *semptr);
void shm_sem_done(shm_sem *semptr);
#endif /* CONFIG_IPC */
#endif /* __WINE_SHM_SEMAPH_H */
ipc/Makefile.in deleted 100644 → 0
View file @ 3dff7bb8
DEFS = @DLLFLAGS@ -D__WINE__
TOPSRCDIR = @top_srcdir@
TOPOBJDIR = ..
SRCDIR = @srcdir@
VPATH = @srcdir@
MODULE = ipc
C_SRCS = \
bit_array.c \
dde_atom.c \
dde_mem.c \
dde_proc.c \
generic_hash.c \
shm_block.c \
shm_fragment.c \
shm_main_blk.c \
shm_semaph.c
all: $(MODULE).o
@MAKE_RULES@
### Dependencies:
ipc/README deleted 100644 → 0
View file @ 3dff7bb8
Technion- Israel Institute of Technology
Electrical Engineering software lab.
Author : Michael Veksler 11678223
Tutor: Avner Lottem
DDE support for Wine
====================
Wine emulator is able to run MS-Windows 3.1 applications under Linux
(Linux is a UNIX clone) . Wine is also a toolkit allowing MS-Windows
applications to compile under Linux. Wine is a world-wide Internet
project with more than 20 developers. Wine is still under development
so many vital MS-Windows features are still missing.
DDE is Dynamic Data Exchange used for communication between MS-Windows
applications. This project adds DDE capabilities into Wine. The new
improved Wine will be able to send messages and share memory between
two different Wine processes.
This project uses System-V IPC mechanisms to implement DDE.
Besides sharing memory handles and sending DDE messages, Wine processes
are synchronize to emulates MS-Windows non-preemptive task switching.
(MS-Windows switches tasks only on given instructions). This is done
without hurting the performance or stability of a single Wine process.
The project adds DDE to Wine emulator and to the toolkit. This allows
old MS-Windows applications to be compiled for UNIX, and have DDE
working among them.
ipc/TEST_FRAGMENT.std deleted 100644 → 0
View file @ 3dff7bb8
After shm_FragmentInit
{0x0020,0xffe0} [total free=ffe0]
0: After shm_FragmentAlloc(block, 0x010000) == NULL
{0x0020,0xffe0} [total free=ffe0]
1: After shm_FragmentAlloc(block, 0x003fdc) == 0x00c024
{0x0020,0xc000} [total free=c000]
2: After shm_FragmentAlloc(block, 0x003ffc) == 0x008024
{0x0020,0x8000} [total free=8000]
3: After shm_FragmentAlloc(block, 0x003ffc) == 0x004024
{0x0020,0x4000} [total free=4000]
4: After shm_FragmentAlloc(block, 0x003ffd) == NULL
{0x0020,0x4000} [total free=4000]
5: After shm_FragmentAlloc(block, 0x003ffc) == 0x000024
no free fragments [total free=0000]
6: Doing shm_FragmentFree(block, 0x000024)
{0x0020,0x4000} [total free=4000]
7: After shm_FragmentAlloc(block, 0x001bfc) == 0x002424
{0x0020,0x2400} [total free=2400]
8: After shm_FragmentAlloc(block, 0x0013fc) == 0x001024
{0x0020,0x1000} [total free=1000]
9: After shm_FragmentAlloc(block, 0x000ffc) == 0x000024
no free fragments [total free=0000]
10: Doing shm_FragmentFree(block, 0x000024)
{0x0020,0x1000} [total free=1000]
11: Doing shm_FragmentFree(block, 0x004024)
{0x0020,0x1000} {0x4020,0x4000} [total free=5000]
12: Doing shm_FragmentFree(block, 0x00c024)
{0x0020,0x1000} {0x4020,0x4000} {0xc020,0x3fe0} [total free=8fe0]
13: After shm_FragmentAlloc(block, 0x000ffc) == 0x000024
{0x4020,0x4000} {0xc020,0x3fe0} [total free=7fe0]
14: Doing shm_FragmentFree(block, 0x000024)
{0x0020,0x1000} {0x4020,0x4000} {0xc020,0x3fe0} [total free=8fe0]
15: After shm_FragmentAlloc(block, 0x000ffd) == 0x007014
{0x0020,0x1000} {0x4020,0x2ff0} {0xc020,0x3fe0} [total free=7fd0]
16: Doing shm_FragmentFree(block, 0x008024)
{0x0020,0x1000} {0x4020,0x2ff0} {0x8020,0x7fe0} [total free=bfd0]
17: Doing shm_FragmentFree(block, 0x001024)
{0x0020,0x2400} {0x4020,0x2ff0} {0x8020,0x7fe0} [total free=d3d0]
18: Doing shm_FragmentFree(block, 0x002424)
{0x0020,0x6ff0} {0x8020,0x7fe0} [total free=efd0]
19: Doing shm_FragmentFree(block, 0x007014)
{0x0020,0xffe0} [total free=ffe0]
ipc/bit_array.c deleted 100644 → 0
View file @ 3dff7bb8
/***************************************************************************
* Copyright 1995, Technion, Israel Institute of Technology
* Electrical Eng, Software Lab.
* Author: Michael Veksler.
***************************************************************************
* File: bit_array.c
* Purpose : manipulate array of bits
* Portability: This is not completely portable, non CISC arcitectures
* Might not have atomic Clear/Set/Toggle bit. On those
* architectures semaphores should be used.
* Big Endian Concerns: This code is big endian compatible,
* but the byte order will be different (i.e. bit 0 will be
* located in byte 3).
***************************************************************************
*/
#ifdef CONFIG_IPC
/*
** uncoment the following line to disable assertions,
** this may boost performance by up to 50%
*/
/* #define NDEBUG */
#if defined(linux) && !defined(NO_ASM)
#include <linux/version.h>
#if LINUX_VERSION_CODE <= 131328 /* Linux 2.1.x doesn't return values with clear_bit and set_bit */
#define HAS_BITOPS
#endif
#endif
#include <stdio.h>
#include <assert.h>
#include "bit_array.h"
#ifdef HAS_BITOPS
#include <asm/bitops.h>
#else
static inline int clear_bit(int bit, int *mem);
static inline int set_bit(int bit, int *mem);
#endif /* HAS_BITOPS */
#define INT_NR(bit_nr) ((bit_nr) >> INT_LOG2)
#define INT_COUNT(bit_count) INT_NR( bit_count + BITS_PER_INT - 1 )
#define BIT_IN_INT(bit_nr) ((bit_nr) & (BITS_PER_INT - 1))
#if !defined(HAS_BITOPS)
/* first_zero maps bytes value to the index of first zero bit */
static char first_zero[256];
static int arrays_initialized=0;
/*
** initialize static arrays used for bit operations speedup.
** Currently initialized: first_zero[256]
** set "arrays_initialized" to inidate that arrays where initialized
*/
static void initialize_arrays()
{
int i;
int bit;
for (i=0 ; i<256 ; i++) {
/* find the first zero bit in `i' */
for (bit=0 ; bit < BITS_PER_BYTE ; bit++)
/* break if the bit is zero */
if ( ( (1 << bit) & i )
== 0)
break;
first_zero[i]= bit;
}
arrays_initialized=1;
}
/*
** Find first zero bit in the integer.
** Assume there is at least one zero.
*/
static inline int find_zbit_in_integer(unsigned int integer)
{
int i;
/* find the zero bit */
for (i=0 ; i < sizeof(int) ; i++, integer>>=8) {
int byte= integer & 0xff;
if (byte != 0xff)
return ( first_zero[ byte ]
+ (i << BYTE_LOG2) );
}
assert(0); /* never reached */
return 0;
}
/* return -1 on failure */
static inline int find_first_zero_bit(unsigned *array, int bits)
{
unsigned int integer;
int i;
int bytes=INT_COUNT(bits);
if (!arrays_initialized)
initialize_arrays();
for ( i=bytes ; i ; i--, array++) {
integer= *array;
/* test if integer contains a zero bit */
if (integer != ~0U)
return ( find_zbit_in_integer(integer)
+ ((bytes-i) << INT_LOG2) );
}
/* indicate failure */
return -1;
}
static inline int test_bit(int pos, unsigned *array)
{
unsigned int integer;
int bit = BIT_IN_INT(pos);
integer= array[ pos >> INT_LOG2 ];
return ( (integer & (1 << bit)) != 0
? 1
: 0 ) ;
}
/*
** The following two functions are x86 specific ,
** other processors will need porting
*/
/* inputs: bit number and memory address (32 bit) */
/* output: Value of the bit before modification */
static inline int clear_bit(int bit, int *mem)
{
int ret;
__asm__("xor %1,%1\n"
"btrl %2,%0\n"
"adcl %1,%1\n"
:"=m" (*mem), "=&r" (ret)
:"r" (bit));
return (ret);
}
static inline int set_bit(int bit, int *mem)
{
int ret;
__asm__("xor %1,%1\n"
"btsl %2,%0\n"
"adcl %1,%1\n"
:"=m" (*mem), "=&r" (ret)
:"r" (bit));
return (ret);
}
#endif /* !deined(HAS_BITOPS) */
/* AssembleArray: assemble an array object using existing data */
bit_array *AssembleArray(bit_array *new_array, unsigned int *buff, int bits)
{
assert(new_array!=NULL);
assert(buff!=NULL);
assert(bits>0);
assert((1 << INT_LOG2) == BITS_PER_INT); /* if fails, redefine INT_LOG2 */
new_array->bits=bits;
new_array->array=buff;
return new_array;
}
/* ResetArray: reset the bit array to zeros */
int ResetArray(bit_array *bits)
{
int i;
int *p;
assert(bits!=NULL);
assert(bits->array!=NULL);
for(i= INT_COUNT(bits->bits), p=bits->array; i ; p++, i--)
*p=0;
return 1;
}
/* VacantBit: find a vacant (zero) bit in the array,
* Return: Bit index on success, -1 on failure.
*/
int VacantBit(bit_array *bits)
{
int bit;
assert(bits!=NULL);
assert(bits->array!=NULL);
bit= find_first_zero_bit(bits->array, bits->bits);
if (bit >= bits->bits) /* failed? */
return -1;
return bit;
}
int SampleBit(bit_array *bits, int i)
{
assert(bits != NULL);
assert(bits->array != NULL);
assert(i >= 0 && i < bits->bits);
return ( test_bit(i,bits->array) != 0
? 1
: 0
);
}
/*
** Use "compare and exchange" mechanism to make sure
** that bits are not modified while "integer" value
** is calculated.
**
** This may be the slowest technique, but it is the most portable
** (Since most architectures have compare and exchange command)
*/
int AssignBit(bit_array *bits, int bit_nr, int val)
{
int ret;
assert(bits != NULL);
assert(bits->array != NULL);
assert(val==0 || val==1);
assert(bit_nr >= 0 && bit_nr < bits->bits);
if (val==0)
ret= clear_bit(BIT_IN_INT(bit_nr), &bits->array[ INT_NR(bit_nr) ]);
else
ret= set_bit(BIT_IN_INT(bit_nr), &bits->array[ INT_NR(bit_nr) ]);
return ( (ret!=0) ? 1 : 0);
}
/*
** Allocate a free bit (==0) and make it used (==1).
** This operation is guaranteed to resemble an atomic instruction.
**
** Return: allocated bit index, or -1 on failure.
**
** There is a crack between locating free bit, and allocating it.
** We assign 1 to the bit, test it was not '1' before the assignment.
** If it was, restart the seek and assign cycle.
**
*/
int AllocateBit(bit_array *bits)
{
int bit_nr;
int orig_bit;
assert(bits != NULL);
assert(bits->array != NULL);
do {
bit_nr= VacantBit(bits);
if (bit_nr == -1) /* No vacant bit ? */
return -1;
orig_bit = AssignBit(bits, bit_nr, 1);
} while (orig_bit != 0); /* it got assigned before we tried */
return bit_nr;
}
#endif /* CONFIG_IPC */
ipc/bit_array_test.c deleted 100644 → 0
View file @ 3dff7bb8
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include "bit_array.h"
#define SIZE (8*sizeof(int)*3)
static bit_array array;
static int simple_array[SIZE];
static int bits;
int are_equal()
{
int i;
for (i=0 ; i < SIZE ; i++)
if (SampleBit(&array,i) != simple_array[i]){
printf("failed bit %d (packed=%d, simple=%d)\n", i,
SampleBit(&array,i), simple_array[i]);
return 0;
}
return 1;
}
int is_same_vacant()
{
int vacant;
for (vacant =0 ; simple_array[vacant]!=0 ; vacant++)
if ( vacant >= SIZE) {
vacant=-1;
break;
}
if ( VacantBit(&array) == vacant )
return 1;
else
return 0;
}
void assign_both(int bit_nr, int bit_val)
{
int old_bit= simple_array[bit_nr];
simple_array[bit_nr]= bit_val;
bits+=bit_val - old_bit;
assert(AssignBit(&array, bit_nr, bit_val) == old_bit);
assert(are_equal());
assert(is_same_vacant());
}
int main()
{
unsigned int integers[SIZE >> 5];
int i,j;
assert( AssembleArray(&array, integers, SIZE)
== &array);
ResetArray(&array);
for (i=0 ; i<SIZE ; i++)
simple_array[i]=0;
for (j=5 ; j ; j--) {
printf("\rleft %d\r",j);
for (i=0 ; VacantBit(&array) != -1 ; i++ ) {
if (i % 256 == 0) {
printf("left %d ",j);
printf("%3d up \r", bits);
fflush(stdout);
}
assign_both(rand() % SIZE,
(rand()% SIZE > bits ) ? 0 : 1 );
}
assign_both(rand() % SIZE, 1);
for (i=0 ; bits ; i++ ) {
if (i % 256 == 0) {
printf("left %d ",j);
printf("%3d down\r", bits);
fflush(stdout);
}
assign_both(rand() % SIZE,
(rand()% SIZE <= (SIZE-bits) ) ? 0 : 1 );
}
assign_both(rand() % SIZE, 0);
}
putchar('\n');
return 0;
}
ipc/dde_atom.c deleted 100644 → 0
View file @ 3dff7bb8
/***************************************************************************
* Copyright 1995, Technion, Israel Institute of Technology
* Electrical Eng, Software Lab.
* Author: Michael Veksler.
***************************************************************************
* File: dde_atom.c
* Purpose : atom functionality for DDE
*/
#ifdef CONFIG_IPC
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include "dde_atom.h"
#include "shm_main_blk.h"
#include "shm_fragment.h"
#include "ldt.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(atom)
typedef struct
{
WORD count;
BYTE str[1];
} AtomData, *AtomData_ptr;
#define EMPTY 0 /* empty hash entry */
#define DELETED -1 /* deleted hash entry */
#define MIN_STR_ATOM 0xfc00
/* OFS2AtomData_ptr: extract AtomData_ptr from ofs */
#define OFS2AtomData_ptr(ofs) ((AtomData*)((int)&main_block->block+(ofs)))
/* OFS2AtomStr: find the string of the atom */
#define OFS2AtomStr(ofs) (OFS2AtomData_ptr(atom_ofs)->str)
/* offset of an atom according to index */
#define ATOM_OFS(idx) (main_block->atoms[idx])
/* rot_left: rotate (with wrap-around) */
static inline int rot_left(unsigned var,int count)
{
return (var<<count) | (var>> (sizeof(var)-count));
}
/* find the entry in the atom table for this string */
static int FindHash(LPCSTR str) /* ignore str case */
{
int i,j;
unsigned hash1,hash2;
int deleted=-1; /* hash for deleted entry */
int atom_ofs;
/* get basic hash parameters */
for (i= hash1= hash2= 0; str[i] ; i++) {
hash1= rot_left(hash1,5) ^ toupper(str[i]);
hash2= rot_left(hash2,4) ^ toupper(str[i]);
}
hash1%= DDE_ATOMS;
atom_ofs=ATOM_OFS(hash1);
switch (atom_ofs) {
case EMPTY: /* empty atom entry */
return hash1;
case DELETED: /* deleted atom entry */
deleted=hash1;
break;
default : /* non empty atom entry */
if (lstrcmpi16( OFS2AtomStr(atom_ofs) , str) == 0)
return hash1; /* found string in atom table */
}
hash2%= DDE_ATOMS-1 ; /* hash2=0..(DDE_ATOMS-2) */
hash2++; /* hash2=1..(DDE_ATOMS-1) */
/* make jumps in the hash table by hash2 steps */
for (i=hash1+hash2 ; ; i+=hash2) {
/* i wraps around into j */
j=i-DDE_ATOMS;
if (j >= 0)
i=j; /* i wraps around */
if (i==hash1)
/* here if covered all hash locations, and got back to beginning */
return deleted; /* return first empty entry - if any */
atom_ofs=ATOM_OFS(i);
switch (atom_ofs) {
case EMPTY: /* empty atom entry */
return i;
case DELETED: /* deleted atom entry */
if (deleted < 0)
/* consider only the first deleted entry */
deleted= i;
break;
default : /* nonempty atom entry */
if (lstrcmpi16( OFS2AtomStr(atom_ofs) , str) == 0)
return i; /* found string in atom table */
}
}
}
void ATOM_GlobalInit(void)
{
int i;
for (i=0 ; i < DDE_ATOMS ; i++)
ATOM_OFS(i)=EMPTY;
}
/***********************************************************************
* DDE_GlobalAddAtom
*/
/* important! don't forget to unlock semaphores before return */
ATOM DDE_GlobalAddAtom( SEGPTR name )
{
int atom_idx;
int atom_ofs;
AtomData_ptr ptr;
ATOM atom;
char *str;
/* First check for integer atom */
if (!HIWORD(name)) return (ATOM)LOWORD(name);
str = (char *)PTR_SEG_TO_LIN( name );
if (str[0] == '#')
{
ATOM atom= (ATOM) atoi(&str[1]);
return (atom<MIN_STR_ATOM) ? atom : 0;
}
TRACE("(\"%s\")\n",str);
DDE_IPC_init(); /* will initialize only if needed */
shm_write_wait(main_block->sem);
atom_idx=FindHash(str);
atom=(ATOM)0;
/* use "return" only at the end so semaphore handling is done only once */
if (atom_idx>=0) {
/* unless table full and item not found */
switch (atom_ofs= ATOM_OFS(atom_idx)) {
case DELETED:
case EMPTY: /* need to allocate new atom */
atom_ofs= shm_FragmentAlloc(&main_block->block,
strlen(str)+sizeof(AtomData));
if (atom_ofs==NIL)
break; /* no more memory (atom==0) */
ATOM_OFS(atom_idx)=atom_ofs;
ptr=OFS2AtomData_ptr(atom_ofs);
strcpy(ptr->str,str);
ptr->count=1;
atom=(ATOM)(atom_idx+MIN_STR_ATOM);
break;
default : /* has to update existing atom */
OFS2AtomData_ptr(atom_ofs)->count++;
atom=(ATOM)(atom_idx+MIN_STR_ATOM);
} /* end of switch */
} /* end of if */
shm_write_signal(main_block->sem);
return atom;
}
/***********************************************************************
* DDE_GlobalDeleteAtom
*/
ATOM DDE_GlobalDeleteAtom( ATOM atom )
{
int atom_idx;
int atom_ofs;
AtomData_ptr atom_ptr;
ATOM retval=(ATOM) 0;
TRACE("(\"%d\")\n",(int)atom);
atom_idx=(int)atom - MIN_STR_ATOM;
if (atom_idx < 0 )
return 0;
DDE_IPC_init(); /* will initialize only if needed */
shm_write_wait(main_block->sem);
/* return used only once from here on -- for semaphore simplicity */
switch (atom_ofs=ATOM_OFS(atom_idx)) {
case DELETED:
case EMPTY:
WARN("Trying to free unallocated atom %d\n", atom);
retval=atom;
break;
default :
atom_ptr=OFS2AtomData_ptr(atom_ofs);
if ( --atom_ptr->count == 0) {
shm_FragmentFree(&main_block->block,atom_ofs);
ATOM_OFS(atom_idx)=DELETED;
}
}
shm_write_signal(main_block->sem);
return retval;
}
/***********************************************************************
* DDE_GlobalFindAtom
*/
ATOM DDE_GlobalFindAtom( SEGPTR name )
{
int atom_idx;
int atom_ofs;
char *str;
TRACE("(%08lx)\n", name );
/* First check for integer atom */
if (!HIWORD(name)) return (ATOM)LOWORD(name);
str = (char *)PTR_SEG_TO_LIN( name );
if (str[0] == '#')
{
ATOM atom= (ATOM) atoi(&str[1]);
return (atom<MIN_STR_ATOM) ? atom : 0;
}
TRACE("(\"%s\")\n",str);
DDE_IPC_init(); /* will initialize only if needed */
shm_read_wait(main_block->sem);
atom_idx=FindHash(str);
if (atom_idx>=0)
atom_ofs=ATOM_OFS(atom_idx); /* is it free ? */
else
atom_ofs=EMPTY;
shm_read_signal(main_block->sem);
if (atom_ofs==EMPTY || atom_ofs==DELETED)
return 0;
else
return (ATOM)(atom_idx+MIN_STR_ATOM);
}
/***********************************************************************
* DDE_GlobalGetAtomName
*/
WORD DDE_GlobalGetAtomName( ATOM atom, LPSTR buffer, short count )
{
int atom_idx, atom_ofs;
int size;
/* temporary buffer to hold maximum "#65535\0" */
char str_num[7];
if (count<2) /* no sense to go on */
return 0;
atom_idx=(int)atom - MIN_STR_ATOM;
if (atom_idx < 0) { /* word atom */
/* use wine convention... */
sprintf(str_num,"#%d%n",(int)atom,&size);
if (size+1>count) { /* overflow ? */
/* truncate the string */
size=count-1;
str_num[size]='\0';
}
strcpy(buffer,str_num);
return size;
}
DDE_IPC_init(); /* will initialize only if needed */
/* string atom */
shm_read_wait(main_block->sem);
atom_ofs=ATOM_OFS(atom_idx);
if (atom_ofs==EMPTY || atom_ofs==DELETED) {
WARN("Illegal atom=%d\n",(int)atom);
size=0;
} else { /* non empty entry */
/* string length will be at most count-1, find actual size */
sprintf(buffer,"%.*s%n",count-1, OFS2AtomStr(atom_ofs), &size);
}
shm_read_signal(main_block->sem);
return size;
}
#endif /* CONFIG_IPC */
ipc/dde_atom_test.c deleted 100644 → 0
View file @ 3dff7bb8
/***************************************************************************
* Copyright 1995, Technion, Israel Institute of Technology
* Electrical Eng, Software Lab.
* Author: Michael Veksler.
***************************************************************************
* File: dde_atom_test.c
* Purpose : tests for dde_atom object
***************************************************************************
*/
#include <stdio.h>
#include <stdlib.h>
#include <win.h>
#include "dde_atom.h"
#include "shm_main_blk.h"
#include "debugtools.h"
DECLARE_DEBUG_CHANNEL(atom)
DECLARE_DEBUG_CHANNEL(sem)
DECLARE_DEBUG_CHANNEL(shm)
#define TOGETHER (DDE_ATOMS/5)
/* run random sequences */
int main()
{
ATOM atom_list[TOGETHER];
char str[TOGETHER][80];
int i,j,atom_n;
int atom_len[TOGETHER];
TRACE_ON(shm)=1;
TRACE_ON(atom)=0;
TRACE_ON(sem)=0;
for (i=0 ; i<=10000/TOGETHER ; i++) {
for (atom_n=0 ; atom_n<TOGETHER ; atom_n++) {
atom_len[atom_n]=rand()%64+1;
for (j=atom_len[atom_n]-1; j>=0; j--)
do {
str[atom_n][j]=(char)(rand()%255+1);
} while (j==0 && str[atom_n][j]=='#');
str[atom_n][ atom_len[atom_n] ]='\0';
atom_list[atom_n]=GlobalAddAtom(str[atom_n]);
if (atom_list[atom_n]==0) {
fprintf(stderr,"failed i=%d, atom_n=%d\n",i,atom_n);
return 1;
}
if (atom_list[atom_n]!=GlobalAddAtom(str[atom_n])) {
fprintf(stderr,
"wrong second GlobalAddAtom(\"%s\")\n", str[atom_n]);
return 1;
}
} /* for */
for (atom_n=0 ; atom_n<TOGETHER ; atom_n++) {
char buf[80];
int len;
len=GlobalGetAtomName( atom_list[atom_n], buf, 79);
if (atom_len[atom_n] != len) {
fprintf(stderr, "i=%d, atom_n=%d; ", i, atom_n);
fprintf(stderr,
"wrong length of GlobalGetAtomName(\"%s\")\n",
str[atom_n]);
return 1;
}
}
for (atom_n=0 ; atom_n<TOGETHER ; atom_n++) {
GlobalDeleteAtom(atom_list[atom_n]);
if (atom_list[atom_n]!=GlobalAddAtom(str[atom_n])) {
fprintf(stderr, "i=%d, atom_n=%d; ", i, atom_n);
fprintf(stderr,
"wrong third GlobalAddAtom(\"%s\")\n", str[atom_n]);
return 1;
}
GlobalDeleteAtom(atom_list[atom_n]);
GlobalDeleteAtom(atom_list[atom_n]);
atom_list[atom_n]=GlobalAddAtom(str[atom_n]);
if (atom_list[atom_n]!=GlobalAddAtom(str[atom_n])) {
fprintf(stderr,
"i=%d, atom_n=%d wrong fifth GlobalAddAtom(\"%s\")\n",
i, atom_n,
str[atom_n]);
return 1;
}
GlobalDeleteAtom(atom_list[atom_n]);
if (atom_list[atom_n]!=GlobalFindAtom(str[atom_n])) {
fprintf(stderr,
"i=%d, atom_n=%d wrong GlobalFindAtom(\"%s\")\n",
i, atom_n,
str[atom_n]);
return 1;
}
GlobalDeleteAtom(atom_list[atom_n]);
}
}
return 0;
}
ipc/dde_mem.c deleted 100644 → 0
View file @ 3dff7bb8
/***************************************************************************
* Copyright 1995, Technion, Israel Institute of Technology
* Electrical Eng, Software Lab.
* Author: Michael Veksler.
***************************************************************************
* File: dde_mem.c
* Purpose : shared DDE memory functionality for DDE
***************************************************************************
*/
#ifdef CONFIG_IPC
#include <assert.h>
#include "debugtools.h"
#include "ldt.h"
#include "shm_main_blk.h"
#include "shm_fragment.h"
#include "shm_semaph.h"
#include "dde_mem.h"
#include "bit_array.h"
DECLARE_DEBUG_CHANNEL(dde)
DECLARE_DEBUG_CHANNEL(global)
#define SEGPTR2HANDLE_INFO(sptr) ( (struct handle_info*)PTR_SEG_TO_LIN(sptr) )
#define HINFO2DATAPTR(h_info_ptr) ( (void*) ( (char*)h_info_ptr + \
sizeof(struct handle_info) ) )
#define DDE_MEM_IDX(handle) ((handle)& 0x7fff)
#define DDE_MEM_HANDLE(idx) ((idx) | 0x8000)
#define DDE_MEM_INFO(handle) (main_block->handles[ DDE_MEM_IDX(handle) ])
/* List of shared handles.
* This entry resides on the shared memory, the data comes right
* after the `handle_info'.
* The entry is on the same block as the actual data.
* The `next' field gives relative reference (relative to the start of
* the blcok.
*/
struct handle_info {
WORD lock_count;
WORD flags;
int size; /* size of the data (net)*/
};
static bit_array free_handles;
int debug_last_handle_size= 0; /* for debugging purpose only */
/* locate_handle:
* locate a shared memory handle.
* Application:
* The handle is first searched for in attached blocks.
* At the beginning, only blocks owned by this process are
* attached.
* If a handle is not found, new blocks are attached.
* Arguments:
* h - the handle.
* RETURN: pointer to handle info.
*/
static struct handle_info *locate_handle(HGLOBAL16 h, struct local_shm_map *map)
{
struct shm_block *block;
TRACE_(global)("shm: (0x%04x)\n", h);
if (SampleBit( &free_handles, DDE_MEM_IDX(h)) == 0) {
TRACE_(global)("shm: return NULL\n");
return NULL; /* free!!! */
}
block= shm_locate_block(DDE_MEM_INFO(h).shmid, map);
if (block == NULL) {
/* nothing found */
TRACE_(global)("shm: return NULL\n");
return NULL;
}
return (struct handle_info *) REL2PTR(block, DDE_MEM_INFO(h).rel);
}
/* dde_alloc_handle: allocate shared DDE handle */
static HGLOBAL16 dde_alloc_handle()
{
int bit_nr;
bit_nr= AllocateBit( &free_handles);
if (bit_nr != -1)
return DDE_MEM_HANDLE(bit_nr);
TRACE_(global)("dde_alloc_handle: no free DDE handle found\n");
return 0;
}
/**********************************************************************
* DDE_malloc
*/
void *
DDE_malloc(unsigned int flags, unsigned long size, SHMDATA *shmdata)
{
int shmid;
struct shm_block *block;
struct handle_info *h_info;
struct local_shm_map *curr;
HGLOBAL16 handle;
TRACE_(global)("DDE_malloc flags %4X, size %ld\n", flags, size);
DDE_IPC_init(); /* make sure main shm block allocated */
shm_write_wait(main_block->proc[curr_proc_idx].sem);
/* Try to find fragment big enough for `size' */
/* iterate through all local shm blocks, and try to allocate
the fragment */
h_info= NULL;
for (curr= shm_map ; curr != NULL ; curr= curr->next) {
if (curr->proc_idx == curr_proc_idx) {
h_info= (struct handle_info *)
shm_FragPtrAlloc(curr->ptr, size+sizeof(struct handle_info));
if (h_info!=NULL) {
shmid= curr->shm_id;
break;
}
}
}
if (h_info == NULL) {
block= shm_create_block(0, size+sizeof(struct handle_info), &shmid);
if (block==NULL) {
shm_write_signal(main_block->proc[curr_proc_idx].sem);
return 0;
}
/* put the new block in the linked list */
block->next_shm_id= main_block->proc[curr_proc_idx].shmid;
main_block->proc[curr_proc_idx].shmid= shmid;
h_info= (struct handle_info *)
shm_FragPtrAlloc(block, size+sizeof(struct handle_info));
if (h_info==NULL) {
ERR_(global)("BUG! unallocated fragment\n");
shm_write_signal(main_block->proc[curr_proc_idx].sem);
return 0;
}
} else {
block= curr->ptr;
}
/* Here we have an allocated fragment */
h_info->flags= flags;
h_info->lock_count= 0;
h_info->size= size;
handle= dde_alloc_handle();
if (handle) {
TRACE_(global)("returning handle=0x%4x, ptr=0x%08lx\n",
(int)handle, (long) HINFO2DATAPTR(h_info));
DDE_MEM_INFO(handle).rel= PTR2REL(block, h_info);
DDE_MEM_INFO(handle).shmid= shmid;
}
else
WARN_(global)("failed\n");
shm_write_signal(main_block->proc[curr_proc_idx].sem);
shmdata->handle= handle;
return (char *)HINFO2DATAPTR(h_info);
}
HGLOBAL16 DDE_GlobalFree(HGLOBAL16 h)
{
struct handle_info *h_info;
int handle_index= h & 0x7fff;
struct local_shm_map map;
TRACE_(global)("(0x%04x)\n",h);
if (h==0)
return 0;
h_info= locate_handle(h, &map);
if (h_info == NULL)
return h;
shm_write_wait(main_block->proc[map.proc_idx].sem);
shm_FragPtrFree(map.ptr, (struct shm_fragment *) h_info);
AssignBit( &free_handles, handle_index, 0);
/* FIXME: must free the shm block some day. */
shm_write_signal(main_block->proc[map.proc_idx].sem);
return 0;
}
WORD DDE_SyncHandle(HGLOBAL16 handle, WORD sel)
{
struct handle_info *h_info;
void *local_ptr;
ldt_entry entry;
h_info= locate_handle(handle, NULL);
local_ptr= (void *)GET_SEL_BASE(sel);
if (h_info == NULL)
return 0;
if (local_ptr == (void *) HINFO2DATAPTR(h_info))
return sel;
/* need syncronization ! */
LDT_GetEntry( SELECTOR_TO_ENTRY(sel), &entry );
entry.base= (unsigned long) HINFO2DATAPTR(h_info);
LDT_SetEntry( SELECTOR_TO_ENTRY(sel), &entry );
return sel;
}
/*
* DDE_AttachHandle:
* Attach shm memory (The data must not be already attached).
* Parameters:
* handle - the memory to attach.
* segptr - in not null, return SEGPTR to the same block.
* return value:
* 32 bit pointer to the memory.
*/
void *DDE_AttachHandle(HGLOBAL16 handle, SEGPTR *segptr)
{
struct handle_info *h_info;
SHMDATA shmdata;
void *ptr;
HGLOBAL16 hOwner = GetCurrentPDB16();
assert(is_dde_handle(handle));
if (segptr != NULL)
*segptr=0;
TRACE_(global)("(%04x)\n",handle);
h_info=locate_handle(handle, NULL);
if (h_info == NULL)
return NULL;
if ( !(h_info->flags & GMEM_DDESHARE) ) {
ERR_(global)("Corrupted memory handle info\n");
return NULL;
}
TRACE_(global)("h_info=%06lx\n",(long)h_info);
shmdata.handle= handle;
shmdata.shmid= DDE_MEM_INFO(handle).shmid;
ptr= HINFO2DATAPTR(h_info);
/* Allocate the selector(s) */
if (! GLOBAL_CreateBlock( h_info->flags, ptr, h_info->size, hOwner,
FALSE, FALSE, FALSE, &shmdata))
return NULL;
if (segptr != NULL)
*segptr= (SEGPTR)MAKELONG( 0, shmdata.sel);
if (TRACE_ON(dde))
debug_last_handle_size= h_info->size;
TRACE_(global)("DDE_AttachHandle returns ptr=0x%08lx\n", (long)ptr);
return (LPSTR)ptr;
}
void DDE_mem_init()
{
int nr_of_bits;
shm_init();
nr_of_bits= BITS_PER_BYTE * sizeof(main_block->free_handles);
AssembleArray( &free_handles, main_block->free_handles, nr_of_bits);
}
#endif /* CONFIG_IPC */
ipc/dde_mem_test.c deleted 100644 → 0
View file @ 3dff7bb8
/***************************************************************************
* Copyright 1995, Technion, Israel Institute of Technology
* Electrical Eng, Software Lab.
* Author: Michael Veksler.
***************************************************************************
* File: dde_mem_test.c
* Purpose : test shared DDE memory functionality for DDE
* Usage: Look for assertion failures
***************************************************************************
*/
#include <stdio.h>
#include <assert.h>
#include <win.h>
#include "dde_mem.h"
/* stub */
void ATOM_GlobalInit()
{
printf("ATOM_GlobalInit\n");
}
int main()
{
HWND h1,h2,h3;
int ret;
void *p1,*p2,*p3,*p;
SHMDATA shmdata;
/* alloc h1, h2, h3 */
setbuf(stdout,NULL);
p1=DDE_malloc(GMEM_DDESHARE, 0x6000, &shmdata);
h1= shmdata.handle;
assert(p1 != NULL);
assert(h1 != 0);
p2=DDE_malloc(GMEM_DDESHARE, 0xff00, &shmdata);
h2= shmdata.handle;
assert(p2 != NULL);
assert(h2 != 0);
p3=DDE_malloc(GMEM_DDESHARE, 0x6000, &shmdata);
h3= shmdata.handle;
assert(p3 != 0);
assert(h3 != 0);
/* lock h1, h2, h3 */
p=DDE_AttachHandle(h1,NULL);
assert(p1==p);
p=DDE_AttachHandle(h2,NULL);
assert(p2==p);
p=DDE_AttachHandle(h3,NULL);
assert(p3==p);
ret=DDE_GlobalFree(h1);
assert(ret==0);
/* do some implementation dependant tests */
p=DDE_malloc(GMEM_DDESHARE, 0x6000, &shmdata);
assert(p!=NULL);
assert(shmdata.handle==h1);
p=DDE_AttachHandle(h1,NULL);
assert(p1==p);
/* check freeing */
ret=DDE_GlobalFree(h1);
assert(ret==0);
ret=DDE_GlobalFree(h2);
assert(ret==0);
ret=DDE_GlobalFree(h3);
assert(ret==0);
return 0;
}
ipc/dde_proc_test.c deleted 100644 → 0
View file @ 3dff7bb8
/***************************************************************************
* Copyright 1995, Technion, Israel Institute of Technology
* Electrical Eng, Software Lab.
* Author: Michael Veksler.
***************************************************************************
* File: dde_proc.c
* Purpose : test DDE signals and processes functionality for DDE
* Usage: run two independant processes, one with an argument another
* without (with the argument is the server).
***************************************************************************
*/
#if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__)
#include <sys/syscall.h>
#include <sys/param.h>
#else
#include <syscall.h>
#endif
#include <stdio.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <win.h>
#include "dde.h"
#include "dde_proc.h"
#include "shm_main_blk.h"
#if !defined(BSD4_4) || defined(linux) || defined(__FreeBSD__)
char * cstack[4096];
#endif
#ifdef linux
extern void ___sig_restore();
extern void ___masksig_restore();
/* Similar to the sigaction function in libc, except it leaves alone the
restorer field */
static int
wine_sigaction(int sig,struct sigaction * new, struct sigaction * old)
{
__asm__("int $0x80":"=a" (sig)
:"0" (SYS_sigaction),"b" (sig),"c" (new),"d" (old));
if (sig>=0)
return 0;
errno = -sig;
return -1;
}
#endif
struct sigaction usr2_act;
void init_signals()
{
#ifdef linux
usr2_act.sa_handler = (__sighandler_t) stop_wait;
usr2_act.sa_flags = 0;
usr2_act.sa_restorer =
(void (*)()) (((unsigned int)(cstack) + sizeof(cstack) - 4) & ~3);
wine_sigaction(SIGUSR2,&usr2_act,NULL);
#endif
#if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__)
usr2_act.sa_hadnler = (void (*)) stop_wait;
usr2_act.sa_flags = SA_ONSTACK;
usr2_act.sa_mask = sig_mask;
usr2_act.sa_restorer =
(void (*)()) (((unsigned int)(cstack) + sizeof(cstack) - 4) & ~3);
if (sigaction(SIGUSR2,&usr2_act,NULL) <0) {
perror("sigaction: SIGUSR2");
exit(1);
}
#endif
}
void ATOM_GlobalInit()
{
printf("ATOM_GlobalInit\n");
}
void idle_loop()
{
int timeout;
for(timeout=500; timeout ; timeout--) {
if (DDE_GetRemoteMessage())
exit(0); ;
usleep(1000);
}
exit(-1);
}
void client()
{
MSG msg;
msg.hwnd=(HWND)-1;
msg.message= WM_DDE_INITIATE;
msg.wParam= 3;
msg.lParam= 4;
if (!DDE_SendMessage(&msg))
exit(-1);
idle_loop();
}
void server()
{
DDE_IPC_init();
idle_loop();
}
int main(int argc, char *argv[])
{
printf("Kill when done one message\n");
init_signals();
if (argc>1)
server();
else
client();
return 0;
}
ipc/generic_hash.h deleted 100644 → 0
View file @ 3dff7bb8
/***************************************************************************
* Copyright 1995 Michael Veksler. mveksler@vnet.ibm.com
***************************************************************************
* File: generic_hash.h
* Purpose : dynamically growing hash, may use shared or local memory.
***************************************************************************
*/
#ifndef _GENERIC_HASH_H_
#define _GENERIC_HASH_H_
#include "windef.h"
#include "shm_block.h"
#include "win.h"
/* default hash values */
#define HASH_LOAD 70
#define HASH_MEM_ALLOC (HASH_PTR (*)(int size)) malloc
#define HASH_MEM_FREE (void (*)(HASH_PTR)) free
#define HASH_MEM_ACCESS access_local_hash
#define HASH_REALLOC_JUMPS 1.5 /* Relative size of the new memory */
#define MIN_HASH 13
typedef union {
char string[1];
WORD words[1];
DWORD dwords[1];
char *ptr;
SEGPTR segptr;
} HASH_VAL;
typedef struct hash_item_struct {
DWORD key;
HASH_VAL data;
} HASH_ITEM;
/* point to the hash structure */
typedef union {
HASH_ITEM* ptr; /* Local pointer */
REL_PTR rel; /* IPC relative address */
SEGPTR segptr; /* Universal (can be IPC or local) */
} HASH_PTR;
typedef struct hash_share_struct {
int total_items; /* total number of items (array size) */
int free_items; /* number of free items (excluding deleted) */
int deleted_items; /* number of deleted items */
int ptr_updates; /* Number of updates to `items' pointer */
/* (of items) - used for intecepting */
/* changes to the pointer. */
HASH_PTR items; /* pointer to the items */
} HASH_SHARED;
typedef BOOL HASH_ITEM_TEST(HASH_VAL *value, HASH_VAL *seeked_data);
/* NOTE:
* 1. Keys 0 and -1 are reserved.
* 2. none of these items should be accessed directly, use existing
* functions. If they are not enough, add a new function.
*/
typedef struct hash_container_struct {
int bytes_per_item;
int maximum_load; /* in percents (0..100) default is 70 */
int min_free_items; /* minimum free items before reallocating
(Function of maximum_load) */
int last_ptr_update; /* to be compared with shared.ptr_updates */
BOOL shared_was_malloced; /* Need that to know how to destroy hash */
/* This is an optional handler.
* If not NULL, this function is used for distinguishing between
* different data with the same key (key field holds integer and
* is too short for long keys like strings).
*/
HASH_ITEM_TEST *is_correct_item;
/* Handlers used for reallocating memory
* [by allocating new data and then freeing old data]
*/
HASH_PTR (*allocate_mem)(int size);
void (*free_mem)(HASH_PTR);
/* Translator from HASH_PTR construct to a regular pointer.
use HASH_MEM_ACCESS, if no translation is needed */
HASH_ITEM *(*access_mem)(HASH_PTR);
HASH_ITEM *items;
HASH_SHARED *shared; /* Things to be on shared memory. */
} HASH_CONTAINER;
/********** Hash maintenance functions ***********/
/* Attach existing & running remote (i.e. shared) hash.
* Attach the items using the data stored in "shared"
*/
HASH_CONTAINER *attach_remote_hash(HASH_SHARED *shared, int bytes_per_datum,
HASH_ITEM *(*access_mem)(HASH_PTR));
HASH_CONTAINER *create_remote_hash(HASH_SHARED *shared,
int bytes_per_datum,
int total_items,
HASH_PTR (*allocate_mem)(int size),
HASH_ITEM *(*access_mem)(HASH_PTR));
/* hash constructor: create brand new hash (not on shared memory) */
HASH_CONTAINER *create_hash(int bytes_per_datum, int total_items);
/* set the extra handlers to non default values */
void set_hash_handlers(HASH_CONTAINER *hash,
HASH_ITEM_TEST *is_correct_item,
HASH_PTR (*allocate_mem)(int size),
void (*free_mem)(HASH_PTR),
HASH_ITEM *(*access_mem)(HASH_PTR));
/* set extra parameters */
void set_hash_parameters(HASH_CONTAINER *hash, int load);
/* hash destructors */
void destroy_hash(HASH_CONTAINER *hash);
void detach_hash(HASH_CONTAINER *hash);
/********** Hash usage *************/
/* All following functions have the same format:
* hash- the hash structure to use
* key- used as primary means to get to the entry.
* data- 1. a secondary key (used only if `is_correct_item' is set).
* 2. data to store. (for hash_add_item).
*/
HASH_VAL *hash_locate_item(HASH_CONTAINER* hash,int key, HASH_VAL* seeked_data);
BOOL hash_add_item(HASH_CONTAINER* hash, int key, HASH_VAL* data);
BOOL hash_delete_item(HASH_CONTAINER* hash, int key, HASH_VAL* seeked_data);
void *ret_null(); /* function returning null (used for */
/* disabling memory reallocation) */
/* access function used by local (non IPC) memory */
HASH_ITEM *access_local_hash(HASH_PTR ptr);
#endif /* _GENERIC_HASH_H_ */
ipc/hash_test.c deleted 100644 → 0
View file @ 3dff7bb8
/***************************************************************************
* Copyright 1995 Michael Veksler. mveksler@vnet.ibm.com
***************************************************************************
* File: hash_test.c
* Purpose : test generic_hash correctness.
* NOTE:
* This code covers only about 80% of generic_hash code.
* There might be bugs in the remaining 20% - although most
* of the functionality is tested with wine linckage.
* For complete testing a little more work should be done.
***************************************************************************
*/
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include "generic_hash.h"
#define SIZE 200
typedef struct { int a,b;} DATA ;
DATA data[SIZE];
int keys[SIZE];
int peeks=0;
HASH_CONTAINER *hash1;
HASH_CONTAINER *hash2; /* actual data is shared with hash1 */
/* test insertion using keys[] and data[] inserting using hash1 and */
/* hash2 periodically, test hash after every 2 insertions */
void test_insert()
{
int i,j;
HASH_VAL *item;
printf("testing insertion \n");
for (i=0 ; i < SIZE-1 ; i+=2) {
assert(hash_add_item(hash1, keys[i], (HASH_VAL *)&data[i]));
assert(hash_add_item(hash2, keys[i+1], (HASH_VAL *)&data[i+1]));
for (j=0 ; j <= i+1 ; j++) {
item= hash_locate_item(hash1, keys[j], (HASH_VAL *)&data[j]);
if (item == NULL) {
printf("NULL item: i=%d,j=%d\n",i,j);
continue;
}
peeks++;
if (memcmp(item,&data[j],sizeof(DATA))!=0) {
printf("i=%d,j=%d\n",i,j);
printf("saved=(%d,%d), orig=(%d,%d)\n",
((DATA*)item)->a, ((DATA*)item)->b,
data[j].a, data[j].b);
}
}
}
}
/* test deletion using keys[] and data[] deleting using hash1 and */
/* hash2 periodicly, test hash after every 2 deletions */
void test_delete()
{
int i,j;
HASH_VAL *item;
printf("testing deletion\n");
for (i=0 ; i < SIZE-1 ; i+=2) {
assert(hash_delete_item(hash2, keys[i], NULL));
assert(hash_delete_item(hash1, keys[i+1], NULL));
for (j=0 ; j < SIZE ; j++) {
item= hash_locate_item(hash2, keys[j], (HASH_VAL *)&data[j]);
if (item == NULL) {
if ( j > i+1)
printf("NULL item: i=%d,j=%d\n",i,j);
continue;
}
if (item != NULL && j <= i+1) {
printf("Non NULL item: i=%d,j=%d\n",i,j);
continue;
}
if (memcmp(item,&data[j],sizeof(DATA))!=0) {
printf("i=%d,j=%d\n",i,j);
printf("saved=(%d,%d), orig=(%d,%d)\n",
((DATA*)item)->a, ((DATA*)item)->b,
data[j].a, data[j].b);
}
}
}
}
int main()
{
int i;
hash1= create_hash(sizeof(DATA), 1);
assert(hash1);
hash2= attach_remote_hash(hash1->shared, sizeof(DATA), HASH_MEM_ACCESS);
assert(hash2);
for (i=0 ; i< SIZE ; i++) {
data[i].a= rand();
data[i].b= rand();
keys[i]= rand();
}
test_insert();
detach_hash(hash1);
free(hash1);
hash1= attach_remote_hash(hash2->shared, sizeof(DATA), HASH_MEM_ACCESS);
test_delete();
test_insert();
detach_hash(hash1);
destroy_hash(hash2);
printf("peeks=%d\n", peeks);
return 0;
}
ipc/run_tests deleted 100644 → 0
View file @ 3dff7bb8
#!/bin/sh
bit_array_test
bit_array=$?
dde_mem_test
mem=$?
hash_test
hash=$?
shm_semaph_test
semaph=$?
dde_atom_test
atom=$?
dde_proc_test 1 > proc_server &
sleep 1
dde_proc_test > proc_client
fgrep "DDE:receive sent message. msg=03e0 wPar=fffb lPar=00000004" proc_server &&
fgrep "DDE_GetRemoteMessage: sending ACK to wnd=fffb, proc=1" proc_server &&
fgrep "get_ack: received DDE_ACK message" proc_client
proc=$?
rm proc_client proc_server
shm_fragment_test | diff TEST_FRAGMENT.std -
fragment=$?
echo ====================================================================
echo Test results:
echo -n "bit_array "
if [ $bit_array -eq 0 ] ; then echo OK ; else echo "** ERROR **" ; fi
echo -n "dde_mem "
if [ $mem -eq 0 ] ; then echo OK ; else echo "** ERROR **" ; fi
echo -n "hash "
if [ $hash -eq 0 ] ; then echo OK ; else echo "** ERROR **" ; fi
echo -n "shm_semaph "
if [ $semaph -eq 0 ] ; then echo OK ; else echo "** ERROR **" ; fi
echo -n "dde_proc "
if [ $proc -eq 0 ] ; then echo OK ; else echo "** ERROR **" ; fi
echo -n "shm_fragment "
if [ $fragment -eq 0 ] ; then echo OK ; else echo "** ERROR **" ; fi
ipc/shm_block.c deleted 100644 → 0
View file @ 3dff7bb8
/***************************************************************************
* Copyright 1995, Technion, Israel Institute of Technology
* Electrical Eng, Software Lab.
* Author: Michael Veksler.
***************************************************************************
* File: shm_block.c
* Purpose: Treat a shared memory block.
***************************************************************************
*/
#ifdef CONFIG_IPC
#include <sys/types.h>
#include <sys/sem.h>
#include <assert.h>
#include <unistd.h>
#include <stdlib.h>
#include "debugtools.h"
#include "global.h"
#include "selectors.h"
#include "shm_fragment.h"
#include "shm_block.h"
#include "shm_semaph.h"
#include "dde_proc.h"
#include "xmalloc.h"
DEFAULT_DEBUG_CHANNEL(shm)
/* How each shmid is maped to local pointer */
/* Only attached shm blocks are in this construct */
struct local_shm_map *shm_map=NULL;
/* setup a new shm block (construct a shm block object).
* block: The pointer to the memory block (local mapping)
* first: The first data byte (excluding header stuff),
* if 0 (zero) Use the default.
* size: The size of the memory block.
*/
void shm_setup_block(struct shm_block *block, int first, int size)
{
TRACE("Setting up shm block at 0x%08x\n",(int )block);
/* setup block internal data structure */
if (first <= 0) {
first=sizeof(*block);
/* round up - so everything starts on cache line boundary
* (assume cache line=32 bytes, may be bigger/smaller for
* different processors and different L2 caches .)
*/
first=(first+0x1f) & ~0x1f;
}
block->free=size-first;
block->next_shm_id=-1; /* IPC shm ID (for initial linking) */
block->proc_idx= curr_proc_idx;
/* block->size is initialized in shm_FragmentInit */
shm_FragmentInit(block, first, size); /* first item in the free list */
TRACE("block was set up at 0x%08x, size=0x%04xKB, 1st usable=%02x\n",
(int )block,size/1024,first);
}
/* shm_attach_block: attach existing shm block, setup selectors
* shm_id - id of the block to attach.
* proc_idx - if not -1, puts this data into local mapping
* map - localy mapped info about this block.
*/
/* NOTE: there is no check if this block is already attached.
* Attaching the same block more than once - is possible
* In case of doubt use shm_locate_block.
*/
struct shm_block *shm_attach_block(int shm_id, int proc_idx,
struct local_shm_map *map)
{
struct shm_block *block;
struct shmid_ds ds;
struct local_shm_map *this;
shmctl(shm_id, IPC_STAT, &ds );
block=(struct shm_block*)shmat(shm_id, NULL, 0);
if (block==NULL || block == (struct shm_block*) -1) return NULL;
this=(struct local_shm_map *)xmalloc(sizeof(*this));
this->next= shm_map;
shm_map = this;
this->shm_id= shm_id;
this->ptr = block;
if (proc_idx < 0)
this->proc_idx=block->proc_idx;
else
this->proc_idx=proc_idx;
if (map != NULL) {
memcpy(map, this, sizeof(map));
map->next= NULL; /* don't pass private info */
}
return block;
}
struct shm_block *shm_create_block(int first, int size, int *shm_id)
{
struct shm_block *block;
if (size==0)
size=SHM_MINBLOCK;
else
/* round up size to a multiple of SHM_MINBLOCK */
size= (size+SHM_MINBLOCK-1) & ~(SHM_MINBLOCK-1);
*shm_id= shmget ( IPC_PRIVATE, size ,0700);
if (*shm_id==-1)
return NULL;
block=shm_attach_block(*shm_id, curr_proc_idx, NULL);
if (block!=NULL)
shm_setup_block(block, first, size);
return block;
}
/*
** Locate attached block. (return it, or NULL on failure)
** shm_id is the block we look for.
** *map - will get all the info related to this local map + proc_idx
** (may be NULL)
** *seg - will get the segment this block is attached to.
*/
struct shm_block *shm_locate_attached_block(int shm_id,
struct local_shm_map *map)
{
struct local_shm_map *curr;
for (curr= shm_map ; curr != NULL ; curr= curr->next) {
if (curr->shm_id == shm_id) {
if (map) {
memcpy(map, curr, sizeof(*curr) );
map->next = NULL; /* this is private info ! */
}
return curr->ptr;
}
}
/* block not found ! */
return 0;
}
/* shm_locate_block: see shm_attach_block.
In addition to shm_attach_block, make sure this
block is not already attached.
*/
struct shm_block *shm_locate_block(int shm_id, struct local_shm_map *map)
{
struct shm_block *ret;
ret= shm_locate_attached_block(shm_id, map);
if (ret!=NULL)
return ret;
/* block not found ! , try to attach */
return shm_attach_block(shm_id, -1, map);
}
static void forget_attached(int shmid)
{
struct local_shm_map *curr, **point_to_curr;
for (curr= shm_map, point_to_curr= &shm_map ;
curr != NULL ;
curr= curr->next, point_to_curr= &curr->next ) {
if (curr->shm_id == shmid) {
*point_to_curr= curr->next;
return;
}
}
}
/* delete chain of shm blocks (pointing to each other)
* Do it in reverse order. (This is what the recursion is for)
*/
void shm_delete_chain(int *shmid)
{
struct shm_block *block;
if (*shmid == -1)
return;
block= shm_locate_block(*shmid, NULL);
forget_attached( *shmid );
if (block == NULL)
return;
shm_delete_chain(&block->next_shm_id);
shmctl(*shmid, IPC_RMID, NULL);
*shmid=-1;
shmdt((char *)block);
}
#endif /* CONFIG_IPC */
ipc/shm_fragment.c deleted 100644 → 0
View file @ 3dff7bb8
/***************************************************************************
* Copyright 1995, Technion, Israel Institute of Technology
* Electrical Eng, Software Lab.
* Author: Michael Veksler.
***************************************************************************
* File: shm_fragment.c
* Purpose: Data fragments and free list items. Allocate and free blocks.
***************************************************************************
*/
#ifdef CONFIG_IPC
#include <stdio.h> /* for debugging only */
#include "debugtools.h" /* for "stddeb" */
#include "shm_fragment.h"
#include "shm_block.h"
/******************************************************************************
*
* Free list: all fragments are ordered according to memory location.
* new fragments are inserted in this way.
*
******************************************************************************
*/
#define FRAG_PTR(block,ofs) ((struct shm_fragment *) ((char *) block + ofs) )
#define NEXT_FRAG(block,ofs) ( FRAG_PTR(block,ofs)->info.next )
/* setup first item in the free list */
void shm_FragmentInit(struct shm_block *block,int first, int size)
{
struct shm_fragment *fragment;
/* round up to nearest 16 byte boundary */
first=(first+15)& ~15;
block->free_list=first;
/* make all the block (exluding the header) free */
fragment= FRAG_PTR(block, first);
block->free= fragment->size= size-first;
fragment->info.next=0;
}
void shm_FragPtrFree(struct shm_block *block, void *ptr)
{
/* ptr points to fragment->info.data, find pointer to fragment,
* find the offset of this pointer in block.
*/
if (ptr)
shm_FragmentFree(block, PTR2REL(block, ptr));
}
void shm_FragmentFree(struct shm_block *block, int fragment_ofs)
{
struct shm_fragment *fragment=NULL;
int prev;
int next;
fragment_ofs-=(int )&fragment->info.data;
fragment= FRAG_PTR(block, fragment_ofs);
block->free+=fragment->size;
/* scan free list to find candidates for merging with fragment */
for (prev=0, next=block->free_list;
(next!=0) && (fragment_ofs > next) ;
prev=next, next=NEXT_FRAG(block,next) )
;
/* insert fragment between, prev and next
* prev==0: fragment will be the first item in free list
* next==0: fragment will be the last item in free list
*/
/* update fragment (point to next, or merge with next) */
if ( fragment_ofs+fragment->size == next ) {
/* merge with the next free block */
fragment->size+= FRAG_PTR(block,next)->size;
fragment->info.next=FRAG_PTR(block,next)->info.next;
} else
/* fragment should be inserted before the next fragment or end of */
/* list. (not merged) */
fragment->info.next=next;
/* now fragment has all the information about the rest of the list */
/* upate prev fragment (point or merge with fragment) */
if (prev==0) /* first item in free list */
block->free_list=fragment_ofs;
else if ( prev+FRAG_PTR(block,prev)->size == fragment_ofs ) {
/* merge fragment with previous fragment */
FRAG_PTR(block,prev)->size+= fragment->size;
FRAG_PTR(block,prev)->info.next=fragment->info.next;
} else
/* insert fragment after previous fragment */
FRAG_PTR(block,prev)->info.next=fragment_ofs;
}
/* use "first fit" algorithm,
* return: offset to data in fragment.
*/
int shm_FragmentAlloc(struct shm_block *block, int size)
{
int prev;
int candidate;
struct shm_fragment *fragment;
struct shm_fragment *ret_fragment;
if (size <= 0)
return NIL;
/* add size of "fragment->size" */
size+= (char *)&fragment->info.data - (char *)fragment ;
/* round "size" to nearest 16 byte value */
size= (size+15) & ~15;
if (size > block->free)
return NIL;
/* scan free list to find candidates for allocation */
for (prev=0, candidate=block->free_list;
candidate!=0 ;
prev=candidate, candidate= fragment->info.next )
{
fragment=FRAG_PTR(block,candidate);
if (fragment->size >= size)
break;
}
if (candidate == 0)
return NIL;
block->free-=size;
if (fragment->size == size) {
if (prev == 0)
block->free_list= fragment->info.next;
else
FRAG_PTR(block,prev)->info.next= fragment->info.next;
return PTR2REL(block, &fragment->info.data);
}
/* fragment->size > size */
/* Split fragment in two, return one part, put the other in free list. */
/* The part that starts at the old location - will stay in the free list. */
fragment->size -= size;
ret_fragment=FRAG_PTR(block, candidate + fragment->size);
ret_fragment->size= size;
return PTR2REL(block, ret_fragment->info.data);
}
/* like shm_FragmentAlloc, returns pointer instead of offset */
char *shm_FragPtrAlloc(struct shm_block *block, int size)
{
int ofs;
ofs= shm_FragmentAlloc(block,size);
if (ofs == NIL)
return NULL;
else
return (char *) REL2PTR(block, ofs);
}
/* This is used for debugging only */
void shm_print_free_list(struct shm_block *block)
{
struct shm_fragment *fragment;
int item;
item=block->free_list;
if (item==0) {
DUMP("no free fragments");
} else {
for (; item ; item=fragment->info.next) {
fragment=FRAG_PTR(block,item);
DUMP("{0x%04x,0x%04x} ",item,fragment->size);
}
}
DUMP(" [total free=%04x]\n",block->free);
fflush(stddeb);
}
#endif /* CONFIG_IPC */
ipc/shm_fragment_test.c deleted 100644 → 0
View file @ 3dff7bb8
/***************************************************************************
* Copyright 1995, Technion, Israel Institute of Technology
* Electrical Eng, Software Lab.
* Author: Michael Veksler.
***************************************************************************
* File: shm_fragment_test.c
* Purpose: Test data fragments and free list items. Allocate and free blocks.
***************************************************************************
*/
#include <assert.h>
#include <stdio.h>
#define DEBUG_DEFINE_VARIABLES /* just avoid dumb errors */
#include "debugtools.h" /* for "stddeb" */
#include <stdlib.h>
#include <string.h>
#include "shm_block.h"
#include "shm_fragment.h"
#include "xmalloc.h"
#define DO_FREE(id) (-id)
#define LIST_LENGTH 20
int main()
{
struct shm_block *block;
char *ret;
int size;
int i;
/* important: The test will work only for the current implementation of */
/* allocation, if the implementation will change, the list should also */
/* cahnge. */
static int sizes[LIST_LENGTH]={
SHM_MINBLOCK, /* 0: should fail */
0x3fe0-4, /* 1: */
0x4000-4, /* 2: */
0x4000-4, /* 3: */
0x4000-4+1, /* 4: should fail */
0x4000-4, /* 5: */
/* allocated(5,3,2,1) free() */
-5, /* 6: */
0x1c00-4, /* 7: */
0x1400-4, /* 8: */
0x1000-4, /* 9: */
/* allocated(9,8,7,3,2,1) free() */
-9, /* 10: */
-3, /* 11: */
-1, /* 12: */
/* allocated(8,7,2) free(9,3,1) */
0x1000-4, /* 13: */
-13, /* 14: */
0x1000+1-4, /* 15: */
/* allocated(8,7,15,2) free(9,[3-15],1) */
-2, /* 16: */
/* allocated(8,7,15) free(9,[3-15],1+2) */
-8, /* 17: */
-7, /* 18: */
-15 /* 19: */
};
static char *ptr[LIST_LENGTH];
block=xmalloc(SHM_MINBLOCK);
/* setup first item in the free list */
shm_FragmentInit(block, sizeof(*block), SHM_MINBLOCK);
fprintf(stddeb,"After shm_FragmentInit\n");
shm_print_free_list(block);
for(i=0 ; i < LIST_LENGTH; i++) {
size=sizes[i];
if (size>0) { /* allocate */
ret=shm_FragPtrAlloc(block, size);
ptr[i]=ret;
fprintf(stddeb,
"%d: After shm_FragmentAlloc(block, 0x%06x) == ",
i, size);
if (ret==NULL)
fprintf(stddeb, "NULL\n");
else {
fprintf(stddeb, "0x%06x\n", (int)ret-(int)block);
memset( ret,0, size ); /* test boundaries */
}
} else { /* free */
/* free shm fragment */
ret=ptr[-sizes[i]];
fprintf(stddeb, "%d: Doing shm_FragmentFree(block, ", i);
if (ret==NULL)
fprintf(stddeb, "NULL)\n");
else
fprintf(stddeb, "0x%06x)\n", (int)ret-(int)block);
fflush(stddeb);
shm_FragPtrFree(block, ret);
}
shm_print_free_list(block);
}
return 0;
}
ipc/shm_main_blk.c deleted 100644 → 0
View file @ 3dff7bb8
/***************************************************************************
* Copyright 1995, Technion, Israel Institute of Technology
* Electrical Eng, Software Lab.
* Author: Michael Veksler.
***************************************************************************
* File: shm_main_blk.c
* Purpose: Main Wine's shared memory block
***************************************************************************
*/
#ifdef CONFIG_IPC
#include <sys/types.h>
#include <sys/sem.h>
#include <time.h>
#include <assert.h>
#include <unistd.h>
#include <errno.h>
#include <signal.h>
#include "debugtools.h"
#include "shm_fragment.h"
#include "shm_block.h"
#include "shm_main_blk.h"
#include "shm_semaph.h"
DEFAULT_DEBUG_CHANNEL(shm)
#define WineKey ( 'W'+((int)'i'<<8)+((int)'n'<<16)+((int)'e'<<24) )
#define SHM_KEY_RANGE 8
/* main block (set during initialization) */
struct shm_main_block *main_block=NULL;
static char *shm_header="Wine - Windows emulator DDE mechanism";
static int main_shm_id;
static void shm_main_refresh();
/* for debugging only */
static void print_perm(struct ipc_perm *perm)
{
printf("Permission:\n");
/* FIXME: not portable
printf("\tKey=%d, mode=%03o, sequence #=%d\n",
(int)perm->key,perm->mode, perm->seq);
*/
printf("\towner: uid=%d, gid=%d ;" ,perm->uid, perm->gid);
printf(" creator: uid=%d, gid=%d\n",perm->cuid,perm->cgid);
}
/* for debugging only */
/* print_shm_info: print shared memory descriptor info */
static void print_shm_info(int shm_id)
{
struct shmid_ds ds;
shmctl(shm_id, IPC_STAT, &ds );
printf("shm_id=%d, Size=0x%08x , Number of attaches=%d\n",
shm_id, ds.shm_segsz, (int)ds.shm_nattch);
if (ds.shm_atime)
printf("Last attach=%s",ctime(&ds.shm_atime));
if (ds.shm_dtime)
printf("Last detach=%s",ctime(&ds.shm_dtime));
printf("Last change=%s",ctime(&ds.shm_ctime));
printf("pid: creator=%d, last operator=%d\n",
(int)ds.shm_cpid,(int)ds.shm_lpid);
print_perm( &ds.shm_perm);
}
int proc_exist(pid_t pid)
{
if ( kill(pid,0) == 0) /* dummy signal to test existence */
return 1;
else if (errno==ESRCH) /* "no such process" */
return 0;
else
return 1;
}
/* setup a new main shm block (only construct a shm block object). */
static void shm_setup_main_block()
{
TRACE("creating data structure\n");
main_block->build_lock=1;
strcpy(main_block->magic, shm_header);
shm_setup_block(&main_block->block,sizeof(*main_block),SHM_MINBLOCK);
dde_proc_init(main_block->proc);
ATOM_GlobalInit();
shm_sem_init(&main_block->sem);
/* main block set and data structure is stable now */
main_block->build_lock=0;
}
/* Delete everything related to main_block */
void shm_delete_all(int shmid)
{
int proc_idx;
if (shmid == -1)
shmid= main_shm_id;
shmctl( shmid, IPC_RMID, NULL);
for (proc_idx= 0 ; proc_idx < DDE_PROCS ; proc_idx++)
dde_proc_done( &main_block->proc[proc_idx] );
shm_sem_done(&main_block->sem);
shmdt( (void *) main_block);
main_block= NULL;
}
int DDE_no_of_attached()
{
struct shmid_ds shm_info;
if (shmctl(main_shm_id, IPC_STAT, &shm_info) == -1)
return -1;
return shm_info.shm_nattch;
}
/*
** Test if shm_id is MainBlock and attach it (if it is),
** Return 1 if ok, 0 otherwise.
*/
static int attach_MainBlock(int shm_id)
{
struct shmid_ds shm_info;
if (shmctl(shm_id, IPC_STAT, &shm_info) == -1)
return 0;
/* Make sure we don't work on somebody else's block */
if (shm_info.shm_perm.cuid != getuid()) { /* creator is not me */
WARN("Creator is not me!\n");
return 0;
}
TRACE("shared memory exist, attaching anywhere\n");
main_block=(struct shm_main_block *)shmat(shm_id, 0, 0);
if ( (int)main_block==-1) {
WARN("Attach failed\n");
return 0;
}
if (strcmp(main_block->magic, shm_header) != 0) {
TRACE("Detaching, wrong magic\n");
shmdt((void *)main_block);
return 0;
}
if (TRACE_ON(shm))
print_shm_info(shm_id);
/* Is it an old unused block ? */
if (shm_info.shm_nattch == 0) {
TRACE("No attaches, deleting old data\n");
shm_delete_all(shm_id);
return 0;
}
/* Wait for data structure to stabilize */
while (main_block->build_lock)
usleep(10000);
main_shm_id= shm_id;
shm_main_refresh();
return 1;
}
/* (Function used by the constructor)
* Try to get existing shared memory with key="Wine", size=SHM_MINBLOCK
* complete user permission.
* If such block is found - return true (1), else return false (0)
*/
static int shm_locate_MainBlock(key_t shm_key)
{
int shm_id; /* Descriptor to this shared memory */
int i;
TRACE("trying to attach, key=0x%x\n",
shm_key);
for (i=0 ; i < SHM_KEY_RANGE ; i++) {
TRACE("iteration=%d\n", i);
shm_id= shmget ( shm_key+i, SHM_MINBLOCK ,0700);
if (shm_id != -1) {
if ( attach_MainBlock(shm_id) ) {
return 1; /* success! */
}
} else {
switch(errno) {
#ifdef EIDRM
case EIDRM: /* segment destroyed */
#endif
case EACCES: /* no user permision */
break;
case ENOMEM: /* no free memory */
case ENOENT: /* this key does not exist */
default :
WARN("shmget failed, errno=%d, %s\n",
errno, strerror(errno) );
return 0; /* Failed */
}
} /* if .. else */
} /* for */
return 0;
}
/* (Function used by the constructor)
* Try to allocate new shared memory with key="Wine", size=SHM_MINBLOCK
* with complete user permission.
* If allocation succeeds - return true (1), else return false (0)
*/
static int shm_create_MainBlock(key_t MainShmKey)
{
int shm_id;
int flags= 0700 | IPC_CREAT | IPC_EXCL;
int i;
TRACE("creating shared memory\n");
/* try to allocate shared memory with key="Wine", size=SHM_MINBLOCK, */
/* complete user permission */
for (i=0 ; i < SHM_KEY_RANGE ; i++) {
shm_id= shmget ( (key_t) MainShmKey, SHM_MINBLOCK, flags);
if (shm_id != -1)
break;
}
if (shm_id == -1) {
WARN("failed to create shared memory\n");
return 0;
}
TRACE("shared memory created, attaching\n");
main_block=(struct shm_main_block*) shmat(shm_id, 0,0);
if (TRACE_ON(shm))
print_shm_info(shm_id);
main_shm_id= shm_id;
shm_setup_main_block();
dde_wnd_setup();
return 1;
}
/* link to the dde shared memory block */
/* RETURN: 0 on success, non zero on failure */
int shm_init(void)
{
if ( !shm_locate_MainBlock(WineKey)
&& !shm_create_MainBlock(WineKey)) {
ERR("Failed to init main shm block\n");
exit(1);
}
dde_proc_add(main_block->proc);
return 0;
}
static void shm_main_refresh()
{
int proc_idx;
for (proc_idx= 0 ; proc_idx < DDE_PROCS ; proc_idx++)
dde_proc_refresh( &main_block->proc[proc_idx] );
}
#endif /* CONFIG_IPC */
ipc/shm_semaph.c deleted 100644 → 0
View file @ 3dff7bb8
/***************************************************************************
* Copyright 1995, Technion, Israel Institute of Technology
* Electrical Eng, Software Lab.
* Author: Michael Veksler.
***************************************************************************
* File: shm_semaph.c
* Purpose: Handle semaphores for shared memory operations.
***************************************************************************
*/
#ifdef CONFIG_IPC
#include <assert.h>
#include <unistd.h>
#include <sys/sem.h>
#include <errno.h>
#include "debugtools.h"
#include "shm_semaph.h"
DEFAULT_DEBUG_CHANNEL(sem)
#define SEM_READ 0
#define SEM_WRITE 1
/* IMPORTANT: Make sure that killed process will not lock everything.
* If possible, restrict usage of these functions.
*/
void shm_read_wait(shm_sem semid)
{
struct sembuf sop[2];
int ret;
TRACE("(%d)\n",semid);
sop[0].sem_num=SEM_READ;
sop[0].sem_op=1; /* add this read instance */
sop[0].sem_flg=SEM_UNDO; /* undo in case process dies */
sop[1].sem_num=SEM_WRITE;
sop[1].sem_op=0; /* wait until no writing instance exists */
sop[1].sem_flg=SEM_UNDO;
do {
ret=semop (semid,sop , 2);
} while (ret<0 && errno==EINTR); /* interrupted system call? */
if (ret<0)
WARN("(semid=%d,errno=%d): Failed semaphore lock for read\n",
semid, errno);
}
void shm_write_wait(shm_sem semid)
{
struct sembuf sop[3];
int ret;
TRACE("(%d)\n",semid);
sop[0].sem_num=SEM_READ;
sop[0].sem_op=0; /* wait until no reading instance exist */
sop[0].sem_flg=SEM_UNDO;
sop[1].sem_num=SEM_WRITE;
sop[1].sem_op=1; /* writing is in progress - disable read */
sop[1].sem_flg=SEM_UNDO; /* undo if process dies */
sop[2].sem_num=SEM_READ;
sop[2].sem_op=1; /* disable new writes */
sop[2].sem_flg=SEM_UNDO;
do {
ret=semop (semid,sop , 3);
} while (ret<0 && errno==EINTR); /* interrupted system call? */
if (ret<0) /* test for the error */
WARN("(semid=%d,errno=%d): Failed semaphore lock for write\n",
semid, errno);
}
void shm_write_signal(shm_sem semid)
{
struct sembuf sop[2];
int ret;
TRACE("(%d)\n",semid);
sop[0].sem_num=SEM_READ;
sop[0].sem_op=-1;
sop[0].sem_flg=IPC_NOWAIT | SEM_UNDO; /* no reason to wait */
sop[1].sem_num=SEM_WRITE;
sop[1].sem_op=-1;
sop[1].sem_flg=IPC_NOWAIT | SEM_UNDO; /* no reason to wait */
do {
ret=semop (semid,sop , 2);
} while (ret<0 && errno==EINTR); /* interrupted system call? */
if (ret<0) /* test for the error */
WARN("(semid=%d,errno=%d): Failed semaphore unlock for write\n",
semid, errno);
}
void shm_read_signal(shm_sem semid)
{
struct sembuf sop[2];
int ret;
TRACE("(%d)\n",semid);
sop[0].sem_num=SEM_READ;
sop[0].sem_op=-1;
sop[0].sem_flg=IPC_NOWAIT | SEM_UNDO; /* no reason to wait */
do {
ret=semop (semid,sop , 1);
} while (ret<0 && errno==EINTR); /* interrupted system call? */
if (ret<0) /* test for the error */
WARN("(semid=%d,errno=%d): Failed semaphore unlock for read\n",
semid, errno);
}
void shm_sem_init(shm_sem *sptr)
{
shm_sem semid;
union semun arg;
semid=semget (IPC_PRIVATE, 2, 0700 | IPC_CREAT);
arg.val=0;
semctl (semid, 0, SETVAL, arg);
semctl (semid, 1, SETVAL, arg);
*sptr=semid;
}
void shm_sem_done(shm_sem *semptr)
{
union semun arg;
semctl (*semptr, 0, IPC_RMID , arg);
semctl (*semptr, 1, IPC_RMID , arg);
*semptr= -1;
}
#endif /* CONFIG_IPC */
ipc/shm_semaph_test.c deleted 100644 → 0
View file @ 3dff7bb8
/***************************************************************************
* Copyright 1995, Technion, Israel Institute of Technology
* Electrical Eng, Software Lab.
* Author: Michael Veksler.
***************************************************************************
* File: shm_semaph_test.c
* Purpose: Test semaphores handleingr shared memory operations.
***************************************************************************
*/
#include <time.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/wait.h>
#include "shm_semaph.h"
#include <sys/shm.h>
#define DEBUG_DEFINE_VARIABLES
#include "debugtools.h"
static volatile int * volatile data;
static int isparent=0;
#define DELAY (rand()%10)
shm_sem sem;
static void read_write(int num)
{
int i,j ;
volatile float dummy=0;
int val;
srand(num+time(NULL));
for (i=0x3fff;i>=0;i--) {
if((i&0x7ff)==0 && isparent)
fprintf(stderr,"0x%06x\r",i);
shm_write_wait(sem);
*data= num;
for (j=DELAY ; j>=0;j--)
dummy*=2;
if (*data!=num) {
fprintf(stderr,"\nbad shm_write_wait(), num=%d\n",num);
shm_write_signal(sem);
return;
}
shm_write_signal(sem);
for (j=DELAY ; j>=0 ;j--)
dummy*=2;
shm_read_wait(sem);
val=*data;
for (j=DELAY; j>=0 ;j--)
dummy*=0.5;
if (*data!=val) {
fprintf(stderr,"\nbad shm_read_wait(), num=%d,val=%d,*data=%d\n",
num,val,*data);
shm_read_signal(sem);
return;
}
shm_read_signal(sem);
}
if (isparent)
fputc('\n',stderr);
}
static void child1()
{
read_write(2);
}
static void child2()
{
read_write(10);
}
static void parent()
{
isparent=1;
read_write(60);
}
int main()
{
int shmid;
int ret1, ret2;
int pid1, pid2;
int stat=0;
shm_sem_init(&sem);
shmid=shmget(IPC_PRIVATE, 0x100, IPC_CREAT | 0700);
data= (int *)shmat ( shmid, NULL, 0);
*data=0;
switch (pid1=fork()) {
case -1:
perror("fork 1");
return 1;
case 0:
fprintf(stderr,"child1\n");
child1();
fprintf(stderr,"child1 done\n");
return 0;
default :
}
switch (pid2=fork()) {
case -1:
perror("fork 2");
stat|=1;
break;
case 0:
fprintf(stderr,"child2\n");
child2();
fprintf(stderr,"child2 done\n");
return 0;
default :
}
fprintf(stderr,"parent\n");
if (pid2>0) { /* if second fork did not fail */
parent();
fprintf(stderr,"parent done, waiting for child2\n");
waitpid(pid2,&ret2,WUNTRACED);
stat|=ret2;
}
fprintf(stderr,"parent done, waiting for child1\n");
waitpid(pid1,&ret1,WUNTRACED);
stat|=ret1;
fprintf(stderr,"all done\n");
shmctl(shmid, IPC_RMID,NULL);
shm_sem_done(&sem);
return stat;
}
ipc/wine_test_stub.c deleted 100644 → 0
View file @ 3dff7bb8
#include <stdlib.h>
#include "dde.h"
#include "windef.h"
#include "global.h"
#include <win.h>
#define DEBUG_DEFINE_VARIABLES
#define DEBUG_ALL
#include "debugtools.h"
#define DDE_PROC2WIN(proc_idx) ( (HWND) ~( (proc_idx)+1) )
#define DDE_WIN2PROC(win) ( (int) ~(short) ((win)+1) )
#define DDE_IsRemoteWindow(win) ( (win)<0xffff && (win)>=(0xffff-DDE_PROCS))
char *MessageTypeNames[0x400]={NULL};
char *dummy_store_for_debug_msg_name;
ldt_copy_entry ldt_copy[LDT_SIZE];
int LDT_GetEntry( int entry, ldt_entry *content )
{
return 0;
}
int LDT_SetEntry( int entry, ldt_entry const *content )
{
return 0;
}
void dummy_usage_of_debug_msg_name()
{
dummy_store_for_debug_msg_name=debug_msg_name[0];
}
/* stub */
HWND GetDesktopWindow()
{
printf("GetDesktopWindow\n");
return 0;
}
/* stub */
/* smart stub */
LONG SendMessage(HWND a,WORD b,WORD c,LONG d)
{
MSG msg;
printf("SendMessage(%04x,%04x,%04x,%04lx)\n",a,b,c,d);
if (DDE_IsRemoteWindow(a) || a==(HWND)-1)
return 0;
if (b!=WM_DDE_INITIATE)
return 0;
msg.hwnd=c;
msg.message= WM_DDE_ACK;
msg.lParam= 0;
msg.wParam= 0;
return DDE_SendMessage(&msg);
}
/* stub */
BOOL PostMessage(HWND a,WORD b,WORD c,LONG d)
{
printf("PostMessage(%04x,%04x,%04x,%04lx)\n",a,b,c,d);
return 0;
}
/* stub */
HWND GetTopWindow(HWND a)
{
printf("GetTopWindow(%04x)\n",a);
return 1;
}
/* stub */
WORD FreeSelector16(WORD a)
{
printf("FreeSelector(%04x)\n",a);
return 0;
}
/* stub that partially emulates the true GLOBAL_CreateBlock function */
HGLOBAL16 GLOBAL_CreateBlock( WORD flags, void *ptr, DWORD size,
HGLOBAL16 hOwner, BOOL isCode,
BOOL is32Bit, BOOL isReadOnly,
SHMDATA *shmdata )
{
printf("GLOBAL_CreateBlock(flags=0x%x,ptr=0x%08lx, size=0x%x,hOwner=0x%x\n",
(int)flags, (long)ptr, (int)size, (int)hOwner);
printf("isCode=%d, is32Bit=%d, isReadOnly=%d, \n", isCode, is32Bit,
isReadOnly);
printf("*shmdata={handle=0x%x,sel=0x%x, shmid=%d})\n",
shmdata->handle, shmdata->sel, shmdata->shmid);
return 1;
}
/* stub */
WND *WIN_FindWndPtr(HWND hwnd)
{
static WND win;
printf("WIN_FindWndPtr(%d)\n",hwnd);
if (hwnd==0)
return NULL;
win.next=NULL;
win.dwStyle=WS_POPUP;
return &win;
}
/* stub */
WORD GetCurrentPDB16(void)
{
printf("GetCurrentPDB()\n");
return 0;
}
/* stub */
void Yield(void)
{
}
loader/signal.c
View file @ e32a317b
......@@ -187,10 +187,6 @@ BOOL SIGNAL_Init(void)
sigemptyset(&async_signal_set);
SIGNAL_SetHandler( SIGCHLD, (void (*)())SIGNAL_child, 1);
#ifdef CONFIG_IPC
sigaddset(&async_signal_set, SIGUSR2);
SIGNAL_SetHandler( SIGUSR2, (void (*)())stop_wait, 1); /* For IPC */
#endif
#ifdef SIGIO
sigaddset(&async_signal_set, SIGIO);
/* SIGNAL_SetHandler( SIGIO, (void (*)())WINSOCK_sigio, 0); */
......
loader/task.c
View file @ e32a317b
......@@ -35,7 +35,6 @@
#include "syslevel.h"
#include "debugtools.h"
#include "dosexe.h"
#include "dde_proc.h"
#include "services.h"
#include "server.h"
......
memory/atom.c
View file @ e32a317b
......@@ -26,10 +26,6 @@
#include "user.h"
#include "debugtools.h"
#ifdef CONFIG_IPC
#include "dde_atom.h"
#endif
DEFAULT_DEBUG_CHANNEL(atom)
#define DEFAULT_ATOMTABLE_SIZE 37
......@@ -545,11 +541,7 @@ UINT WINAPI GetAtomNameW( ATOM atom, LPWSTR buffer, INT count )
ATOM WINAPI GlobalAddAtom16( SEGPTR str )
{
if (!HIWORD(str)) return (ATOM)LOWORD(str); /* Integer atom */
#ifdef CONFIG_IPC
return DDE_GlobalAddAtom( str );
#else
return ATOM_AddAtom( ATOM_GlobalTable, (LPCSTR)PTR_SEG_TO_LIN(str) );
#endif
}
......@@ -595,11 +587,7 @@ ATOM WINAPI GlobalAddAtomW( LPCWSTR str )
ATOM WINAPI GlobalDeleteAtom(
ATOM atom /* [in] Atom to delete */
) {
#ifdef CONFIG_IPC
return DDE_GlobalDeleteAtom( atom );
#else
return ATOM_DeleteAtom( ATOM_GlobalTable, atom );
#endif
}
......@@ -609,11 +597,7 @@ ATOM WINAPI GlobalDeleteAtom(
ATOM WINAPI GlobalFindAtom16( SEGPTR str )
{
if (!HIWORD(str)) return (ATOM)LOWORD(str); /* Integer atom */
#ifdef CONFIG_IPC
return DDE_GlobalFindAtom( str );
#else
return ATOM_FindAtom( ATOM_GlobalTable, (LPCSTR)PTR_SEG_TO_LIN(str) );
#endif
}
......@@ -652,11 +636,7 @@ ATOM WINAPI GlobalFindAtomW( LPCWSTR str )
*/
UINT16 WINAPI GlobalGetAtomName16( ATOM atom, LPSTR buffer, INT16 count )
{
#ifdef CONFIG_IPC
return DDE_GlobalGetAtomName( atom, buffer, count );
#else
return (UINT16)ATOM_GetAtomName( ATOM_GlobalTable, atom, buffer, count );
#endif
}
......
memory/global.c
View file @ e32a317b
......@@ -16,7 +16,6 @@
#include "toolhelp.h"
#include "selectors.h"
#include "miscemu.h"
#include "dde_mem.h"
#include "stackframe.h"
#include "module.h"
#include "debugtools.h"
......@@ -35,9 +34,6 @@ typedef struct
BYTE pageLockCount; /* Count of GlobalPageLock() calls */
BYTE flags; /* Allocation flags */
BYTE selCount; /* Number of selectors allocated for this block */
#ifdef CONFIG_IPC
int shmid;
#endif
} GLOBALARENA;
/* Flags definitions */
......@@ -124,22 +120,7 @@ HGLOBAL16 GLOBAL_CreateBlock( WORD flags, const void *ptr, DWORD size,
pArena->base = (DWORD)ptr;
pArena->size = GET_SEL_LIMIT(sel) + 1;
#ifdef CONFIG_IPC
if (flags & GMEM_DDESHARE)
{
pArena->handle = shmdata->handle;
pArena->shmid = shmdata->shmid;
shmdata->sel = sel;
}
else
{
pArena->handle = (flags & GMEM_MOVEABLE) ? sel - 1 : sel;
pArena->shmid = 0;
}
#else
pArena->handle = (flags & GMEM_MOVEABLE) ? sel - 1 : sel;
#endif
pArena->hOwner = hOwner;
pArena->lockCount = 0;
pArena->pageLockCount = 0;
......@@ -225,16 +206,8 @@ HGLOBAL16 GLOBAL_Alloc( UINT16 flags, DWORD size, HGLOBAL16 hOwner,
if (size >= GLOBAL_MAX_ALLOC_SIZE - 0x1f) return 0;
size = (size + 0x1f) & ~0x1f;
/* Allocate the linear memory */
#ifdef CONFIG_IPC
if (flags & GMEM_DDESHARE)
ptr = DDE_malloc(flags, size, &shmdata);
else
#endif /* CONFIG_IPC */
{
ptr = HeapAlloc( SystemHeap, 0, size );
}
/* Allocate the linear memory */
ptr = HeapAlloc( SystemHeap, 0, size );
/* FIXME: free discardable blocks and try again? */
if (!ptr) return 0;
......@@ -252,50 +225,6 @@ HGLOBAL16 GLOBAL_Alloc( UINT16 flags, DWORD size, HGLOBAL16 hOwner,
return handle;
}
#ifdef CONFIG_IPC
/***********************************************************************
* GLOBAL_FindArena
*
* Find the arena for a given handle
* (when handle is not serial - e.g. DDE)
*/
static GLOBALARENA *GLOBAL_FindArena( HGLOBAL16 handle)
{
int i;
for (i = globalArenaSize-1 ; i>=0 ; i--) {
if (pGlobalArena[i].size!=0 && pGlobalArena[i].handle == handle)
return ( &pGlobalArena[i] );
}
return NULL;
}
/***********************************************************************
* DDE_GlobalHandleToSel
*/
WORD DDE_GlobalHandleToSel( HGLOBAL16 handle )
{
GLOBALARENA *pArena;
SEGPTR segptr;
pArena= GLOBAL_FindArena(handle);
if (pArena) {
int ArenaIdx = pArena - pGlobalArena;
/* See if synchronized to the shared memory */
return DDE_SyncHandle(handle, ( ArenaIdx << __AHSHIFT) | 7);
}
/* attach the block */
DDE_AttachHandle(handle, &segptr);
return SELECTOROF( segptr );
}
#endif /* CONFIG_IPC */
/***********************************************************************
* GlobalAlloc16 (KERNEL.15)
* RETURNS
......@@ -335,14 +264,6 @@ HGLOBAL16 WINAPI GlobalReAlloc16(
handle, size, flags );
if (!handle) return 0;
#ifdef CONFIG_IPC
if (flags & GMEM_DDESHARE || is_dde_handle(handle))
{
FIXME("shared memory reallocating unimplemented\n");
return 0;
}
#endif /* CONFIG_IPC */
if (!VALID_HANDLE(handle)) {
WARN("Invalid handle 0x%04x!\n", handle);
return 0;
......@@ -456,9 +377,6 @@ HGLOBAL16 WINAPI GlobalFree16(
TRACE("%04x\n", handle );
if (!GLOBAL_FreeBlock( handle )) return handle; /* failed */
#ifdef CONFIG_IPC
if (is_dde_handle(handle)) return DDE_GlobalFree(handle);
#endif /* CONFIG_IPC */
if (ptr) HeapFree( SystemHeap, 0, ptr );
return 0;
}
......@@ -477,11 +395,6 @@ SEGPTR WINAPI WIN16_GlobalLock16( HGLOBAL16 handle )
{
if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
#ifdef CONFIG_IPC
if (is_dde_handle(handle))
return PTR_SEG_OFF_TO_SEGPTR( DDE_GlobalHandleToSel(handle), 0 );
#endif /* CONFIG_IPC */
if (!VALID_HANDLE(handle)) {
WARN("Invalid handle 0x%04x passed to WIN16_GlobalLock16!\n",handle);
return (SEGPTR)0;
......@@ -511,9 +424,6 @@ LPVOID WINAPI GlobalLock16(
if (!VALID_HANDLE(handle))
return (LPVOID)0;
GET_ARENA_PTR(handle)->lockCount++;
#ifdef CONFIG_IPC
if (is_dde_handle(handle)) return DDE_AttachHandle(handle, NULL);
#endif
return (LPVOID)GET_ARENA_PTR(handle)->base;
}
......@@ -893,9 +803,6 @@ HANDLE16 WINAPI FarGetOwner16( HGLOBAL16 handle )
WORD WINAPI GlobalHandleToSel16( HGLOBAL16 handle )
{
if (!handle) return 0;
#ifdef CONFIG_IPC
if (is_dde_handle(handle)) return DDE_GlobalHandleToSel(handle);
#endif
if (!VALID_HANDLE(handle)) {
WARN("Invalid handle 0x%04x passed to GlobalHandleToSel!\n",handle);
return 0;
......
misc/ddeml.c
View file @ e32a317b
......@@ -15,7 +15,6 @@
#include "ddeml.h"
#include "winerror.h"
#include "heap.h"
#include "shm_semaph.h"
#include "debugtools.h"
#include "tchar.h"
#include "winnt.h"
......
windows/message.c
View file @ e32a317b
......@@ -988,11 +988,6 @@ static BOOL MSG_PeekMessage( LPMSG msg, HWND hwnd, DWORD first, DWORD last,
POINT16 pt16;
int iWndsLocks;
#ifdef CONFIG_IPC
DDE_TestDDE(hwnd); /* do we have dde handling in the window ?*/
DDE_GetRemoteMessage();
#endif /* CONFIG_IPC */
mask = QS_POSTMESSAGE | QS_SENDMESSAGE; /* Always selected */
if (first || last)
{
......@@ -1458,11 +1453,6 @@ BOOL WINAPI PostMessageA( HWND hwnd, UINT message, WPARAM wParam,
msg.pt.x = 0;
msg.pt.y = 0;
#ifdef CONFIG_IPC
if (DDE_PostMessage(&msg))
return TRUE;
#endif /* CONFIG_IPC */
if (hwnd == HWND_BROADCAST)
{
WND *pDesktop = WIN_GetDesktop();
......@@ -1672,13 +1662,7 @@ LRESULT WINAPI SendMessage16( HWND16 hwnd, UINT16 msg, WPARAM16 wParam,
LPARAM lParam)
{
LRESULT res;
#ifdef CONFIG_IPC
MSG16 DDE_msg = { hwnd, msg, wParam, lParam };
if (DDE_SendMessage(&DDE_msg)) return TRUE;
#endif /* CONFIG_IPC */
MSG_SendMessage(hwnd, msg, wParam, lParam, INFINITE, 0, &res);
return res;
}
......
windows/win.c
View file @ e32a317b
......@@ -21,8 +21,6 @@
#include "nonclient.h"
#include "queue.h"
#include "winpos.h"
#include "shm_main_blk.h"
#include "dde_proc.h"
#include "clipboard.h"
#include "winproc.h"
#include "task.h"
......@@ -440,11 +438,6 @@ static WND* WIN_DestroyWindow( WND* wndPtr )
TRACE_(win)("%04x\n", wndPtr->hwndSelf );
#ifdef CONFIG_IPC
if (main_block)
DDE_DestroyWindow(wndPtr->hwndSelf);
#endif /* CONFIG_IPC */
/* free child windows */
WIN_LockWndPtr(wndPtr->child);
while ((pWnd = wndPtr->child))
......
windows/x11drv/event.c
View file @ e32a317b
......@@ -19,7 +19,6 @@
#include "callback.h"
#include "clipboard.h"
#include "dce.h"
#include "dde_proc.h"
#include "debugtools.h"
#include "drive.h"
#include "heap.h"
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment