Date: Tue, 28 Apr 1998 12:58:08 -0400 (EDT) From: "Michael A. Suarez" <msuarez@cybernet.com> To: FreeBSD Hackers <freebsd-hackers@FreeBSD.ORG> Subject: Kernel Programming Question Message-ID: <XFMail.980428125808.msuarez@cybernet.com>
next in thread | raw e-mail | index | archive | help
This message is in MIME format
--_=XFMail.1.2.p0.FreeBSD:980428125808:18166=_
Content-Type: text/plain; charset=us-ascii
I am trying to make a kernel hack that does the following: If the high bit of
the text segment size is set, which in any normal circumstance would be very
unlikely, when that executable is loaded, a md5 checksum would be generated and
stored in the proc structure of that running executable. I use the p_pad1 and
p_pad2 elements of the proc structure to store upto 6 bytes of the calculated
checksum. (Yes, I know this is a real hack, but I only need it for this one
machine's kernel).
I have coded it to the point that the checksum calculations occur if the
high-bit is set. Essentially I have modified the imgact_aout to notice the
high-bit is set and then set proc->p_pad1[0]=1 if it was. Then in kern_exec, I
read through the executable file and, currently, only calculate and print the
sum.
The problem is that it only works about half the time. It fails when trying to
read the file on the vn_rdwr call. It fails by simply hanging the processes,
vn_rdwr does not return. If I look at the process list, the process is hung in
the DV+ state. Also, the system is somewhat flakey after that. When it works,
however, it calculates the sum and continues to execute the program without a
hitch.
I have included both the imgact_aout changes and the kern_exec changes. These
are from the 2.2.2 source tree.
If anyone has any suggestions, I would be very happy to hear them.
Thanks,
Michael
msuarez@cybernet.com
--_=XFMail.1.2.p0.FreeBSD:980428125808:18166=_
Content-Disposition: attachment; filename="kern_exec.c"
Content-Transfer-Encoding: base64
Content-Description: kern_exec.c
Content-Type: application/octet-stream; name=kern_exec.c; SizeOnDisk=16865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=
--_=XFMail.1.2.p0.FreeBSD:980428125808:18166=_
Content-Disposition: attachment; filename="imgact_aout.c"
Content-Transfer-Encoding: 7bit
Content-Description: imgact_aout.c
Content-Type: text/plain; charset=us-ascii; name=imgact_aout.c; SizeOnDisk=6477
/*
* Copyright (c) 1993, David Greenman
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $Id: imgact_aout.c,v 1.2 1998/04/27 09:39:10 msuarez Exp $
*/
#include "opt_rlimit.h"
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/resourcevar.h>
#include <sys/exec.h>
#include <sys/mman.h>
#include <sys/imgact.h>
#include <sys/imgact_aout.h>
#include <sys/kernel.h>
#include <sys/proc.h>
#include <sys/sysent.h>
#include <sys/vnode.h>
#include <vm/vm.h>
#include <vm/vm_param.h>
#include <vm/vm_prot.h>
#include <vm/lock.h>
#include <vm/pmap.h>
#include <vm/vm_map.h>
#include <vm/vm_extern.h>
static int exec_aout_imgact __P((struct image_params *imgp));
static int
exec_aout_imgact(imgp)
struct image_params *imgp;
{
const struct exec *a_out = (const struct exec *) imgp->image_header;
struct vmspace *vmspace = imgp->proc->p_vmspace;
vm_offset_t vmaddr;
unsigned long virtual_offset;
unsigned long file_offset;
unsigned long bss_size;
int error;
/*
* Linux and *BSD binaries look very much alike,
* only the machine id is different:
* 0x64 for Linux, 0x86 for *BSD, 0x00 for BSDI.
* NetBSD is in network byte order.. ugh.
*/
if (((a_out->a_magic >> 16) & 0xff) != 0x86 &&
((a_out->a_magic >> 16) & 0xff) != 0 &&
((((int)ntohl(a_out->a_magic)) >> 16) & 0xff) != 0x86)
return -1;
imgp->proc->p_pad1[0]=0;
if(a_out->a_text & 0x80000000)
{
/* This means we need a checksum */
imgp->proc->p_pad1[0]=1;
}
/*
* Set file/virtual offset based on a.out variant.
* We do two cases: host byte order and network byte order
* (for NetBSD compatibility)
*/
switch ((int)(a_out->a_magic & 0xffff)) {
case ZMAGIC:
virtual_offset = 0;
if (a_out->a_text&0x7fffffff) {
file_offset = PAGE_SIZE;
} else {
/* Bill's "screwball mode" */
file_offset = 0;
}
break;
case QMAGIC:
virtual_offset = PAGE_SIZE;
file_offset = 0;
break;
default:
/* NetBSD compatibility */
switch ((int)(ntohl(a_out->a_magic) & 0xffff)) {
case ZMAGIC:
case QMAGIC:
virtual_offset = PAGE_SIZE;
file_offset = 0;
break;
default:
return (-1);
}
}
bss_size = roundup(a_out->a_bss, PAGE_SIZE);
/*
* Check various fields in header for validity/bounds.
*/
if (/* entry point must lay with text region */
a_out->a_entry < virtual_offset ||
a_out->a_entry >= virtual_offset + (a_out->a_text&0x7fffffff) ||
/* text and data size must each be page rounded */
(a_out->a_text&0x7fffffff) & PAGE_MASK || a_out->a_data & PAGE_MASK)
return (-1);
/* text + data can't exceed file size */
if (a_out->a_data + (a_out->a_text&0x7fffffff) > imgp->attr->va_size)
return (EFAULT);
/*
* text/data/bss must not exceed limits
*/
if (/* text can't exceed maximum text size */
(a_out->a_text&0x7fffffff) > MAXTSIZ ||
/* data + bss can't exceed maximum data size */
a_out->a_data + bss_size > MAXDSIZ ||
/* data + bss can't exceed rlimit */
a_out->a_data + bss_size >
imgp->proc->p_rlimit[RLIMIT_DATA].rlim_cur)
return (ENOMEM);
/* copy in arguments and/or environment from old process */
error = exec_extract_strings(imgp);
if (error)
return (error);
/*
* Destroy old process VM and create a new one (with a new stack)
*/
exec_new_vmspace(imgp);
/*
* Map text/data read/execute
*/
vmaddr = virtual_offset;
error =
vm_mmap(&vmspace->vm_map, /* map */
&vmaddr, /* address */
(a_out->a_text&0x7fffffff) + a_out->a_data, /* size */
VM_PROT_READ | VM_PROT_EXECUTE, /* protection */
VM_PROT_ALL, /* max protection */
MAP_PRIVATE | MAP_FIXED, /* flags */
(caddr_t)imgp->vp, /* vnode */
file_offset); /* offset */
if (error)
return (error);
/*
* allow writing of data
*/
vm_map_protect(&vmspace->vm_map,
vmaddr + (a_out->a_text&0x7fffffff),
vmaddr + (a_out->a_text&0x7fffffff) + a_out->a_data,
VM_PROT_ALL,
FALSE);
if (bss_size != 0) {
/*
* Allocate demand-zeroed area for uninitialized data
* "bss" = 'block started by symbol' - named after the IBM 7090
* instruction of the same name.
*/
vmaddr = virtual_offset + (a_out->a_text&0x7fffffff) + a_out->a_data;
error = vm_map_find(&vmspace->vm_map, NULL, 0, &vmaddr, bss_size, FALSE, VM_PR
OT_ALL, VM_PROT_ALL, 0);
if (error)
return (error);
}
/* Fill in process VM information */
vmspace->vm_tsize = (a_out->a_text&0x7fffffff) >> PAGE_SHIFT;
vmspace->vm_dsize = (a_out->a_data + bss_size) >> PAGE_SHIFT;
vmspace->vm_taddr = (caddr_t) virtual_offset;
vmspace->vm_daddr = (caddr_t) virtual_offset + (a_out->a_text&0x7fffffff);
/* Fill in image_params */
imgp->interpreted = 0;
imgp->entry_addr = a_out->a_entry;
imgp->proc->p_sysent = &aout_sysvec;
/* Indicate that this file should not be modified */
imgp->vp->v_flag |= VTEXT;
return (0);
}
/*
* Tell kern_execve.c about it, with a little help from the linker.
* Since `const' objects end up in the text segment, TEXT_SET is the
* correct directive to use.
*/
static const struct execsw aout_execsw = { exec_aout_imgact, "a.out" };
TEXT_SET(execsw_set, aout_execsw);
--_=XFMail.1.2.p0.FreeBSD:980428125808:18166=_--
End of MIME message
To Unsubscribe: send mail to majordomo@FreeBSD.org
with "unsubscribe freebsd-hackers" in the body of the message
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?XFMail.980428125808.msuarez>