#include <ansi.h>
#endif
-
#ifdef NDEBUG
/* Debugging disabled -- do not evaluate assertions. */
#define assert(expr) ((void) 0)
#define EBADREQUEST (_SIGN 107) /* destination cannot handle request */
#define EDONTREPLY (_SIGN 201) /* pseudo-code: don't send a reply */
-
#endif /* _ERRNO_H */
pid_t l_pid; /* process id of the locks' owner */
};
-
/* Function Prototypes. */
_PROTOTYPE( int creat, (const char *_path, _mnx_Mode_t _mode) );
_PROTOTYPE( int fcntl, (int _filedes, int _cmd, ...) );
#ifndef _BIOS_H
#define _BIOS_H
-
/* PART I --
* The BIOS interrupt vector table (IVT) area (1024 B as of address 0x0000).
* Although this area holds 256 interrupt vectors (with jump addresses), some
#define BIOS_HD1_PARAMS_ADDR 0x0118 /* disk 1 parameters */
#define BIOS_HD1_PARAMS_SIZE 4L
-
/* PART I --
* Addresses in the BIOS data area (256 B as of address 0x0400). The addresses
* listed below are the most important ones, and the ones that are currently
#define VDU_VIDEO_MODE_ADDR 0x49A /* current video mode */
#define VDU_VIDEO_MODE_SIZE 1L
-
/* PART III --
* The motherboard BIOS memory contains some known values that are currently
* in use. Other sections in the upper memory area (UMA) addresses vary in
#define PS_386_MACHINE 0xF8 /* ID byte for PS/2 modela 70/80 */
#define PC_AT_MACHINE 0xFC /* PC/AT, PC/XT286, PS/2 models 50/60 */
-
#endif /* _BIOS_H */
*/
#define RTC_REG_C 0xC
-
/* Contents of the general purpose CMOS RAM (source IBM reference manual) */
#define CMOS_STATUS 0xE
#define CS_LOST_POWER 0x80 /* Chip lost power */
-
#ifndef _IBM_CPU_H
#define _IBM_CPU_H 1
/* Magic numbers for interrupt controller. */
#define END_OF_INT 0x20 /* code used to re-enable after an interrupt */
-
/* Interrupt vectors defined/reserved by processor. */
#define DIVIDE_VECTOR 0 /* divide error */
#define DEBUG_VECTOR 1 /* single step (trace) */
#define AT_WINI_0_IRQ 14 /* at winchester controller 0 */
#define AT_WINI_1_IRQ 15 /* at winchester controller 1 */
-
/* Interrupt number to hardware vector. */
#define BIOS_VECTOR(irq) \
(((irq) < 8 ? BIOS_IRQ0_VEC : BIOS_IRQ8_VEC) + ((irq) & 0x07))
* Created: March 2005, Jorrit N. Herder
*/
-
/* I/O-mapped peripherals. I/O addresses are different from memory addresses
* due to the I/O signal on the ISA bus. Individual I/O ports are defined by
* the drivers that use them or looked up with help of the BIOS.
#define BIOS_DATA_BEGIN 0x00400 /* BIOS data area */
#define BIOS_DATA_END 0x004FF
-
/* The base memory is followed by 384 KB reserved memory located at the top of
* the first MB of physical memory. This memory is known as the upper memory
* area (UMA). It is used for memory-mapped peripherals, such as video RAM,
#define UMA_COLOR_TEXT_BEGIN 0xB8000 /* color text */
#define UMA_COLOR_TEXT_END 0xBFFFF
-
/* o The next 128K (the memory range C0000-DFFFF) is reserved for the adapter
* BIOS that resides in the ROM on some adapter boards. Most VGA-compatible
* video adapters use the first 32 KB of this area for their on-board BIOS.
#define UMA_IDE_HD_BIOS_BEGIN 0xC8000 /* IDE hard disk */
#define UMA_IDE_HD_BIOS_END 0xCBFFF
-
/* o The last 128K of the upper memory area (E0000-FFFFF) is reserved for
* motherboard BIOS (Basic I/O System). The POST (Power-On Self Test) and
* bootstrap loader also reside in this space. The memory falls apart in
#define UMA_SYSTEM_BIOS_BEGIN 0xF0000 /* system BIOS */
#define UMA_SYSTEM_BIOS_END 0xFFFFF
-
u8_t end_mss[3];
};
-
struct cd_play_track
{
u8_t begin_track;
u8_t end_track;
};
-
struct cd_disk_info
{
u8_t first_track;
u8_t first_track_mss[3];
};
-
struct cd_toc_entry
{
u8_t control_address;
#define NONE 0x6ace /* used to indicate 'no process at all' */
#define SELF 0x8ace /* used to indicate 'own process' */
-
/*===========================================================================*
* Process numbers of processes in the system image *
*===========================================================================*/
/* Number of processes contained in the system image. */
#define NR_BOOT_PROCS (NR_TASKS + INIT_PROC_NR + 1)
-
/*===========================================================================*
* Kernel notification types *
*===========================================================================*/
#define NOTIFY_TIMESTAMP m2_l2
#define NOTIFY_FLAGS m2_i1
-
/*===========================================================================*
* Messages for BLOCK and CHARACTER device drivers *
*===========================================================================*/
#define TAPE_STAT0 m2_l1
#define TAPE_STAT1 m2_l2
-
/*===========================================================================*
* Messages for networking layer *
*===========================================================================*/
# define DL_MULTI_REQ 0x4
# define DL_BROAD_REQ 0x8
-
/*===========================================================================*
* SYSTASK request types and field names *
*===========================================================================*/
#define MEM_TOT_SIZE m4_l3 /* total memory size */
#define MEM_CHUNK_TAG m4_l4 /* tag to identify chunk of mem */
-
/* Field names for SYS_DEVIO, SYS_VDEVIO, SYS_SDEVIO. */
#define DIO_REQUEST m2_i3 /* device in or output */
# define DIO_INPUT 0 /* input */
#define SEL_ERRORFDS m8_p3
#define SEL_TIMEOUT m8_p4
-
/*===========================================================================*
* Messages for system management server *
*===========================================================================*/
# define SRV_PRIV_ADDR m1_p3 /* privileges string */
# define SRV_PRIV_LEN m1_i3 /* length of privileges */
-
/*===========================================================================*
* Miscellaneous messages used by TTY *
*===========================================================================*/
# define DIAG_BUF_COUNT m1_i1
# define DIAG_PROC_NR m1_i2
-
#endif /* _MINIX_COM_H */
#define OS_RELEASE "3"
#define OS_VERSION "0.7"
-
/* This file sets configuration parameters for the MINIX kernel, FS, and PM.
* It is divided up into two main sections. The first section contains
* user-settable parameters. In the second section, various internal system
#define NR_RS_LINES 4 /* # rs232 terminals (0 to 4) */
#define NR_PTYS 32 /* # pseudo terminals (0 to 64) */
-
/*===========================================================================*
* There are no user-settable parameters after this line *
*===========================================================================*/
#define hclick_to_physb(n) ((phys_bytes) (n) << HCLICK_SHIFT)
#define physb_to_hclick(n) ((n) >> HCLICK_SHIFT)
-
#define ABS -999 /* this process means absolute memory */
/* Flag bits for i_mode in the inode. */
int dmap_flags;
} dmap[];
-
/*===========================================================================*
* Major and minor device numbers *
*===========================================================================*/
#define LOG_MAJOR 15 /* major device for log driver */
# define IS_KLOG_DEV 0 /* minor device for /dev/klog */
-
#endif /* _DMAP_H */
#define m8_p3 m_u.m_m8.m8p3
#define m8_p4 m_u.m_m8.m8p4
-
/*==========================================================================*
* Minix run-time system (IPC). *
*==========================================================================*/
_PROTOTYPE( int nb_receive, (int src, message *m_ptr) );
_PROTOTYPE( int nb_send, (int dest, message *m_ptr) );
-
#endif /* _IPC_H */
#ifndef SOUND_H
#define SOUND_H
-
/* ------- Mixer stuff ------- */
/* Available devices */
#define sys_inl(p,v) sys_in((p), (unsigned long*) (v), DIO_LONG)
_PROTOTYPE(int sys_in, (int port, unsigned long *value, int type) );
-
#endif /* _SYSLIB_H */
* Mar 31, 2004: setup like other libraries, such as syslib
*/
-
/*==========================================================================*
* Miscellaneous helper functions.
*==========================================================================*/
vir_bytes iov_size; /* sizeof an I/O buffer */
} iovec_t;
-
/* PM passes the address of a structure of this type to KERNEL when
* sys_sendsig() is invoked as part of the signal catching mechanism.
* The structure contain all the information that KERNEL needs to build
#define DHF_UNUSED 0x30
#define DHF_RCODE 0x0F
-
/*
Define constants based on rfc883
*/
#define BIG_ENDIAN 1
#endif
-
#if (LITTLE_ENDIAN) && (BIG_ENDIAN)
#include "both LITTLE_ENDIAN and BIG_ENDIAN are defined"
/* LITTLE_ENDIAN and BIG_ENDIAN are both defined */
char *pw_gecos; /* just in case you have a GE 645 around */
};
-
/* Function Prototypes. */
_PROTOTYPE( struct passwd *getpwnam, (const char *_name) );
_PROTOTYPE( struct passwd *getpwuid, (_mnx_Uid_t _uid) );
#define SIGTTIN 21 /* background process wants to read */
#define SIGTTOU 22 /* background process wants to write */
-
/* The sighandler_t type is not allowed unless _POSIX_SOURCE is defined. */
typedef void _PROTOTYPE( (*__sighandler_t), (int) );
#ifndef _STDARG_H
#define _STDARG_H
-
#ifdef __GNUC__
/* The GNU C-compiler uses its own, but similar varargs mechanism. */
#else /* not __GNUC__ */
-
typedef char *va_list;
#define __vasz(x) ((sizeof(x)+sizeof(int)-1) & ~(sizeof(int) -1))
- __vasz(type))))
#define va_end(ap)
-
#endif /* __GNUC__ */
#endif /* _STDARG_H */
-
#ifndef _SYS_RESOURCE_H
#define _SYS_RESOURCE_H
-
#ifndef _SYS_SELECT_H
#define _SYS_SELECT_H 1
#define TCIOFF 3 /* transmit a STOP character on the line */
#define TCION 4 /* transmit a START character on the line */
-
/* Function Prototypes. */
#ifndef _ANSI_H
#include <ansi.h>
#ifndef _TIMERS_H
#define _TIMERS_H
-
#include <limits.h>
#include <sys/types.h>
#undef TMR_NEVER
#define TMR_NEVER ((clock_t) LONG_MAX)
-
/* These definitions can be used to set or get data from a timer variable. */
#define tmr_arg(tp) (&(tp)->tmr_arg)
#define tmr_exp_time(tp) (&(tp)->tmr_exp_time)
_PROTOTYPE( clock_t tmrs_settimer, (timer_t **tmrs, timer_t *tp,
clock_t exp_time, tmr_func_t watchdog, clock_t *new_head) );
-
#endif /* _TIMERS_H */
-
_PROTOTYPE( int writesectors, (int _off, int _seg, off_t _adr, int _ct));
#endif
-
#define BTMP "/usr/adm/btmp" /* the bad-login history file */
#define UTMP "/etc/utmp" /* the user accouting file */
-
struct utmp {
char ut_user[8]; /* user name */
char ut_id[4]; /* /etc/inittab ID */
#define ut_name ut_user /* for compatibility with other systems */
-
/* Definitions for ut_type. */
#define RUN_LVL 1 /* this is a RUN_LEVEL record */
#define BOOT_TIME 2 /* this is a REBOOT record */
FORWARD _PROTOTYPE( int clock_handler, (irq_hook_t *hook) );
FORWARD _PROTOTYPE( int do_clocktick, (message *m_ptr) );
-
/* Clock parameters. */
#if (CHIP == INTEL)
#define COUNTER_FREQ (2*TIMER_FREQ) /* counter frequency using square wave */
PRIVATE clock_t realtime; /* real time clock */
PRIVATE irq_hook_t clock_hook; /* interrupt handler hook */
-
/*===========================================================================*
* clock_task *
*===========================================================================*/
}
}
-
/*===========================================================================*
* do_clocktick *
*===========================================================================*/
return(EDONTREPLY);
}
-
/*===========================================================================*
* clock_handler *
*===========================================================================*/
return(1); /* reenable interrupts */
}
-
/*===========================================================================*
* get_uptime *
*===========================================================================*/
return(realtime);
}
-
/*===========================================================================*
* set_timer *
*===========================================================================*/
next_timeout = clock_timers->tmr_exp_time;
}
-
/*===========================================================================*
* reset_timer *
*===========================================================================*/
TMR_NEVER : clock_timers->tmr_exp_time;
}
-
#if (CHIP == INTEL)
/*===========================================================================*
enable_irq(&clock_hook); /* ready for clock interrupts */
}
-
/*===========================================================================*
* clock_stop *
*===========================================================================*/
outb(TIMER0, 0);
}
-
/*===========================================================================*
* read_clock *
*===========================================================================*/
#endif /* (CHIP == INTEL) */
-
-
#define USE_PHYSVCOPY 1 /* vector with physical copy requests */
#define USE_MEMSET 1 /* write char to a given memory area */
-
/* Length of program names stored in the process table. This is only used
* for the debugging dumps that can be generated with the IS server. The PM
* server keeps its own copy of the program name.
*/
#define RANDOM_ELEMENTS 32
-
/* This section contains defines for valuable system resources that are used
* by device drivers. The number of elements of the vectors is determined by
* the maximum needed by any given driver. The number of interrupt hooks may
#define VDEVIO_BUF_SIZE 64 /* max elements per VDEVIO request */
#define VCOPY_VEC_SIZE 16 /* max elements per VCOPY request */
-
/* How many bytes for the kernel stack. Space allocated in mpx.s. */
#define K_STACK_BYTES 1024
-
/* This section allows to enable kernel debugging and timing functionality.
* For normal operation all options should be disabled.
*/
( MAP_CHUNK(map.chunk,bit) &= ~(1 << CHUNK_OFFSET(bit) )
#define NR_SYS_CHUNKS BITMAP_CHUNKS(NR_SYS_PROCS)
-
#if (CHIP == INTEL)
/* Program stack words and masks. */
*/
#define NR_MEMS 8
-
#endif /* (CHIP == INTEL) */
#if (CHIP == M68000)
#endif /* DEBUG_TIME_LOCKS */
-
#if DEBUG_SCHED_CHECK /* only include code if enabled */
#define PROCLIMIT 10000
#define locktimeend(c)
#endif /* DEBUG_TIME_LOCKS */
-
/* The locking checks counts relocking situation, which are dangerous because
* the inner lock may unlock the outer one.
*/
#define lockcheck
#endif /* DEBUG_LOCK_CHECK */
-
/* This check makes sure that the scheduling queues are in a consistent state.
* The check is run when the queues are updated with ready() and unready().
*/
_PROTOTYPE( void check_runqueues, (char *when) );
#endif /* DEBUG_SCHED_CHECK */
-
/* The timing and checking of kernel locking requires a redefine of the lock()
* and unlock() macros. That's done here. This redefine requires that this
* header is included after the other kernel headers.
# define unlock(c) do { locktimeend(c); intr_enable(); } while(0)
#endif
-
#endif /* DEBUG_H */
EXTERN char k_reenter; /* kernel reentry count (entry count less 1) */
EXTERN unsigned lost_ticks; /* clock ticks counted outside clock task */
-
#if (CHIP == INTEL)
/* Interrupt related variables. */
#define set_vec(nr, addr) ((void)0)
#endif
-
/*==========================================================================*
* intr_init *
*==========================================================================*/
/* When the handler is not found, normally return here. */
}
-
/*==========================================================================*
* intr_handle *
*==========================================================================*/
#define CHECK_DST 0x05 /* 0 1 0 1 : validate message destination */
#define CHECK_SRC 0x02 /* 0 0 1 0 : validate message source */
-
#endif /* IPC_H */
FORWARD _PROTOTYPE( void announce, (void));
FORWARD _PROTOTYPE( void shutdown, (timer_t *tp));
-
/*===========================================================================*
* main *
*===========================================================================*/
restart();
}
-
-
/*==========================================================================*
* announce *
*==========================================================================*/
#endif
}
-
/*==========================================================================*
* prepare_shutdown *
*==========================================================================*/
#endif
}
-
/*==========================================================================*
* shutdown *
*==========================================================================*/
#include "kernel.h"
#include "proc.h"
-
/* Scheduling and message passing functions. The functions are available to
* other parts of the kernel through lock_...(). The lock temporarily disables
* interrupts to prevent race conditions.
*/
#endif /* (CHIP == M68000) */
-
/*===========================================================================*
* sys_call *
*===========================================================================*/
return(result);
}
-
/*===========================================================================*
* mini_send *
*===========================================================================*/
}
}
-
/*===========================================================================*
* mini_notify *
*===========================================================================*/
return(OK);
}
-
/*==========================================================================*
* lock_notify *
*==========================================================================*/
return(result);
}
-
/*===========================================================================*
* enqueue *
*===========================================================================*/
#endif
}
-
/*===========================================================================*
* sched *
*===========================================================================*/
*front = time_left;
}
-
/*===========================================================================*
* pick_proc *
*===========================================================================*/
}
}
-
/*==========================================================================*
* lock_send *
*==========================================================================*/
return(result);
}
-
/*==========================================================================*
* lock_enqueue *
*==========================================================================*/
unlock(4);
}
-
#define isuserp(p) isusern((p)->p_nr)
#define isusern(n) ((n) >= 0)
-
/* The process table and pointers to process table slots. The pointers allow
* faster access because now a process entry can be found by indexing the
* pproc_addr array, while accessing an element i requires a multiplication
return base;
}
-
/*=========================================================================*
* phys2seg *
*=========================================================================*/
pp->p_reg.psw |= 0x3000;
}
-
/*==========================================================================*
* alloc_segments *
*==========================================================================*/
}
}
-
_PROTOTYPE( void enable_iop, (struct proc *pp) );
_PROTOTYPE( void alloc_segments, (struct proc *rp) );
-
#endif /* (CHIP == INTEL) */
#if (CHIP == M68000)
*/
}
-
/*==========================================================================*
* get_value *
*==========================================================================*/
FORWARD _PROTOTYPE( void initialize, (void));
-
/*===========================================================================*
* sys_task *
*===========================================================================*/
}
}
-
/*===========================================================================*
* initialize *
*===========================================================================*/
map(SYS_GETINFO, do_getinfo); /* request system information */
}
-
/*===========================================================================*
* get_priv *
*===========================================================================*/
return(OK);
}
-
/*===========================================================================*
* get_randomness *
*===========================================================================*/
krandom.bin[source].r_next = (r_next + 1 ) % RANDOM_ELEMENTS;
}
-
/*===========================================================================*
* send_sig *
*===========================================================================*/
lock_notify(SYSTEM, proc_nr);
}
-
/*===========================================================================*
* cause_sig *
*===========================================================================*/
}
}
-
/*===========================================================================*
* umap_bios *
*===========================================================================*/
return 0;
}
-
/*===========================================================================*
* umap_local *
*===========================================================================*/
#endif
}
-
/*===========================================================================*
* umap_remote *
*===========================================================================*/
return(OK);
}
-
}
#endif /* (USE_VIRCOPY || USE_PHYSCOPY) */
-
}
#endif /* USE_EXEC */
-
-
return(EDONTREPLY);
}
-
/*===========================================================================*
* clear_proc *
*===========================================================================*/
#endif /* USE_EXIT */
-
}
#endif /* USE_GETKSIG */
-
#include "../system.h"
-
#if USE_IRQCTL
FORWARD _PROTOTYPE(int generic_handler, (irq_hook_t *hook));
disable_irq(&irq_hooks[irq_hook_id]);
break;
-
/* Control IRQ policies. Set a policy and needed details in the IRQ table.
* This policy is used by a generic function to handle hardware interrupts.
*/
return(r);
}
-
/*===========================================================================*
* generic_handler *
*===========================================================================*/
#endif /* USE_MEMSET */
-
}
#endif /* USE_NEWMAP */
-
#endif /* USE_SDEVIO */
-
-
}
if (index < 0) return(ENOSPC);
-
if (! machine.protected) {
selector = phys / HCLICK_SIZE;
offset = phys % HCLICK_SIZE;
return(OK);
}
-
/*===========================================================================*
* cause_alarm *
*===========================================================================*/
}
#endif /* USE_SIGRETURN */
-
return(EBADREQUEST); /* illegal message type */
}
-
PRIVATE pvw_pair_t *pvw = (pvw_pair_t *) vdevio_buf;
PRIVATE pvl_pair_t *pvl = (pvl_pair_t *) vdevio_buf;
-
/*===========================================================================*
* do_vdevio *
*===========================================================================*/
extern int dummy[(NR_BOOT_PROCS==sizeof(image)/sizeof(struct boot_image))?1:-1];
extern int dummy[(BITCHUNK_BITS > NR_BOOT_PROCS - 1) ? 1 : -1];
-
#define END_OF_KMESS -1
FORWARD _PROTOTYPE(void kputc, (int c));
-
/*===========================================================================*
* panic *
*===========================================================================*/
prepare_shutdown(RBT_PANIC);
}
-
/*===========================================================================*
* kprintf *
*===========================================================================*/
va_end(argp); /* end variable arguments */
}
-
/*===========================================================================*
* kputc *
*===========================================================================*/
}
}
-
return(bp); /* return the newly acquired block */
}
-
/*===========================================================================*
* put_block *
*===========================================================================*/
}
}
-
/*===========================================================================*
* alloc_zone *
*===========================================================================*/
return(sp->s_firstdatazone - 1 + (zone_t) b);
}
-
/*===========================================================================*
* free_zone *
*===========================================================================*/
if (bit < sp->s_zsearch) sp->s_zsearch = bit;
}
-
/*===========================================================================*
* rw_block *
*===========================================================================*/
bp->b_dirt = CLEAN;
}
-
/*===========================================================================*
* invalidate *
*===========================================================================*/
#endif
}
-
/*==========================================================================*
* flushall *
*==========================================================================*/
rw_scattered(dev, dirty, ndirty, WRITING);
}
-
/*===========================================================================*
* rw_scattered *
*===========================================================================*/
}
}
-
/*===========================================================================*
* rm_lru *
*===========================================================================*/
#define hash2(block) ((unsigned) ((block) & (MAX_BUF2 - 1)))
-
/*===========================================================================*
* init_cache2 *
*===========================================================================*/
nr_buf2 = size > MAX_BUF2 ? MAX_BUF2 : (unsigned) size;
}
-
/*===========================================================================*
* get_block2 *
*===========================================================================*/
return(0);
}
-
/*===========================================================================*
* put_block2 *
*===========================================================================*/
}
}
-
/*===========================================================================*
* invalidate2 *
*===========================================================================*/
return(r);
}
-
/*===========================================================================*
* dev_close *
*===========================================================================*/
}
} while(get_more);
-
return;
}
return(dev_mess.REP_STATUS);
}
-
/*===========================================================================*
* gen_opcl *
*===========================================================================*/
return(dev_mess.REP_STATUS);
}
-
/*===========================================================================*
* tty_opcl *
*===========================================================================*/
return(r);
}
-
/*===========================================================================*
* ctty_opcl *
*===========================================================================*/
return(fp->fp_tty == 0 ? ENXIO : OK);
}
-
/*===========================================================================*
* do_setsid *
*===========================================================================*/
rfp->fp_tty = 0;
}
-
/*===========================================================================*
* do_ioctl *
*===========================================================================*/
m_in.REQUEST, f->filp_flags));
}
-
/*===========================================================================*
* gen_io *
*===========================================================================*/
}
}
-
/*===========================================================================*
* ctty_io *
*===========================================================================*/
}
}
-
/*===========================================================================*
* no_dev *
*===========================================================================*/
return(ENODEV);
}
-
/*===========================================================================*
* clone_opcl *
*===========================================================================*/
#endif /* IBM_PC */
};
-
/*===========================================================================*
* do_devctl *
*===========================================================================*/
return(result);
}
-
/*===========================================================================*
* map_driver *
*===========================================================================*/
driver, controller);
}
-
-
return(ENFILE);
}
-
/*===========================================================================*
* get_filp *
*===========================================================================*/
return(fp->fp_filp[fild]); /* may also be NIL_FILP */
}
-
/*===========================================================================*
* find_filp *
*===========================================================================*/
FORWARD _PROTOTYPE( void new_icopy, (struct inode *rip, d2_inode *dip,
int direction, int norm));
-
/*===========================================================================*
* get_inode *
*===========================================================================*/
return(xp);
}
-
/*===========================================================================*
* put_inode *
*===========================================================================*/
for (i = 0; i < V2_NR_TZONES; i++) rip->i_zone[i] = NO_ZONE;
}
-
/*===========================================================================*
* free_inode *
*===========================================================================*/
rip->i_update = 0; /* they are all up-to-date now */
}
-
/*===========================================================================*
* rw_inode *
*===========================================================================*/
rip->i_dirt = CLEAN;
}
-
/*===========================================================================*
* old_icopy *
*===========================================================================*/
}
}
-
/*===========================================================================*
* new_icopy *
*===========================================================================*/
}
}
-
/*===========================================================================*
* dup_inode *
*===========================================================================*/
char i_update; /* the ATIME, CTIME, and MTIME bits are here */
} inode[NR_INODES];
-
#define NIL_INODE (struct inode *) 0 /* indicates absence of inode slot */
/* Field values. Note that CLEAN and DIRTY are defined in "const.h" */
FORWARD _PROTOTYPE( int unlink_file, (struct inode *dirp, struct inode *rip,
char file_name[NAME_MAX]) );
-
/*===========================================================================*
* do_link *
*===========================================================================*/
return(r);
}
-
/*===========================================================================*
* do_unlink *
*===========================================================================*/
return(r);
}
-
/*===========================================================================*
* do_rename *
*===========================================================================*/
return(r == SAME ? OK : r);
}
-
/*===========================================================================*
* truncate *
*===========================================================================*/
/* Leave zone numbers for de(1) to recover file after an unlink(2). */
}
-
/*===========================================================================*
* remove_dir *
*===========================================================================*/
return(OK);
}
-
/*===========================================================================*
* unlink_file *
*===========================================================================*/
#include "param.h"
#include "super.h"
-
-
FORWARD _PROTOTYPE( void fs_init, (void) );
FORWARD _PROTOTYPE( int igetenv, (char *var, int optional) );
FORWARD _PROTOTYPE( void get_work, (void) );
}
}
-
/*===========================================================================*
* get_work *
*===========================================================================*/
if (s != OK) printf("FS: couldn't send reply %d: %d\n", result, s);
}
-
/*===========================================================================*
* fs_init *
*===========================================================================*/
mess.m_type = OK; /* tell PM that we succeeded */
s=send(PM_PROC_NR, &mess); /* send synchronization message */
-
/* All process table entries have been set. Continue with FS initialization.
* Certain relations must hold for the file system to work at all. Some
* extra block_size requirements are checked at super-block-read-in time.
load_super(root_dev); /* load super block for root device */
init_select(); /* init select() structures */
-
/* The root device can now be accessed; set process directories. */
for (rfp=&fproc[0]; rfp < &fproc[NR_PROCS]; rfp++) {
if (rfp->fp_pid != PID_FREE) {
}
}
-
/*===========================================================================*
* igetenv *
*===========================================================================*/
}
}
-
#if ENABLE_CACHE2
/* The RAM disk is a second level block cache while not otherwise used. */
init_cache2(ram_size);
}
}
-
/*===========================================================================*
* load_super *
*===========================================================================*/
}
-
/*===========================================================================*
* do_dup *
*===========================================================================*/
}
}
-
/*===========================================================================*
* do_sync *
*===========================================================================*/
return(OK);
}
-
-
/*===========================================================================*
* do_reboot *
*===========================================================================*/
return(OK);
}
-
/*===========================================================================*
* do_fork *
*===========================================================================*/
return(OK);
}
-
/*===========================================================================*
* do_exec *
*===========================================================================*/
return(OK);
}
-
/*===========================================================================*
* do_exit *
*===========================================================================*/
return(OK);
}
-
/*===========================================================================*
* do_set *
*===========================================================================*/
return(OK);
}
-
/*===========================================================================*
* do_revive *
*===========================================================================*/
return(OK);
}
-
/*===========================================================================*
* do_umount *
*===========================================================================*/
return(unmount(dev));
}
-
/*===========================================================================*
* unmount *
*===========================================================================*/
FORWARD _PROTOTYPE( struct inode *new_node, (char *path, mode_t bits,
zone_t z0) );
-
/*===========================================================================*
* do_creat *
*===========================================================================*/
return(r);
}
-
/*===========================================================================*
* do_open *
*===========================================================================*/
return(r);
}
-
/*===========================================================================*
* common_open *
*===========================================================================*/
return(m_in.fd);
}
-
/*===========================================================================*
* new_node *
*===========================================================================*/
return(rip);
}
-
/*===========================================================================*
* pipe_open *
*===========================================================================*/
return(OK);
}
-
/*===========================================================================*
* do_mknod *
*===========================================================================*/
return(err_code);
}
-
/*===========================================================================*
* do_mkdir *
*===========================================================================*/
return(err_code); /* new_node() always sets 'err_code' */
}
-
/*===========================================================================*
* do_close *
*===========================================================================*/
return(OK);
}
-
/*===========================================================================*
* do_lseek *
*===========================================================================*/
return(rip);
}
-
/*===========================================================================*
* last_dir *
*===========================================================================*/
}
}
-
/*===========================================================================*
* get_name *
*===========================================================================*/
return(rnp);
}
-
/*===========================================================================*
* advance *
*===========================================================================*/
return(rip); /* return pointer to inode's component */
}
-
/*===========================================================================*
* search_dir *
*===========================================================================*/
return(r);
}
-
/* Check for free slot for the benefit of ENTER. */
if (flag == ENTER && dp->d_ino == 0) {
e_hit = TRUE; /* we found a free slot */
return(OK);
}
-
/*===========================================================================*
* pipe_check *
*===========================================================================*/
return(1);
}
-
/*===========================================================================*
* suspend *
*===========================================================================*/
}
}
-
/*===========================================================================*
* release *
*===========================================================================*/
}
}
-
/*===========================================================================*
* revive *
*===========================================================================*/
}
}
-
/*===========================================================================*
* do_unpause *
*===========================================================================*/
return(OK);
}
-
/*===========================================================================*
* do_chown *
*===========================================================================*/
return(r);
}
-
/*===========================================================================*
* do_umask *
*===========================================================================*/
return(r); /* return complement of old mask */
}
-
/*===========================================================================*
* do_access *
*===========================================================================*/
return(r);
}
-
/*===========================================================================*
* forbidden *
*===========================================================================*/
return(r);
}
-
/*===========================================================================*
* read_only *
*===========================================================================*/
return(b);
}
-
/*===========================================================================*
* rd_indir *
*===========================================================================*/
return(zone);
}
-
/*===========================================================================*
* read_ahead *
*===========================================================================*/
put_block(bp, PARTIAL_DATA_BLOCK);
}
-
/*===========================================================================*
* rahead *
*===========================================================================*/
FD_ZERO(&selecttab[s].ready_writefds);
FD_ZERO(&selecttab[s].ready_errorfds);
-
selecttab[s].vir_readfds = (fd_set *) m_in.SEL_READFDS;
selecttab[s].vir_writefds = (fd_set *) m_in.SEL_WRITEFDS;
selecttab[s].vir_errorfds = (fd_set *) m_in.SEL_ERRORFDS;
-
#ifndef _FS_SELECT_H
#define _FS_SELECT_H 1
return(r);
}
-
/*===========================================================================*
* do_chroot *
*===========================================================================*/
return(r);
}
-
/*===========================================================================*
* change *
*===========================================================================*/
return(r);
}
-
/*===========================================================================*
* do_fstat *
*===========================================================================*/
return(stat_inode(rfilp->filp_ino, rfilp, m_in.buffer));
}
-
/*===========================================================================*
* stat_inode *
*===========================================================================*/
return(r);
}
-
return(NO_BIT); /* no bit could be allocated */
}
-
/*===========================================================================*
* free_bit *
*===========================================================================*/
put_block(bp, MAP_BLOCK);
}
-
/*===========================================================================*
* get_super *
*===========================================================================*/
return MIN_BLOCK_SIZE;
}
-
/*===========================================================================*
* mounted *
*===========================================================================*/
return(FALSE);
}
-
/*===========================================================================*
* read_super *
*===========================================================================*/
* A super_block slot is free if s_dev == NO_DEV.
*/
-
EXTERN struct super_block {
ino_t s_ninodes; /* # usable inodes on the minor device */
zone1_t s_nzones; /* total device size, including bit maps etc */
#include "inode.h"
#include "param.h"
-
/*===========================================================================*
* do_utime *
*===========================================================================*/
return(r);
}
-
/*===========================================================================*
* do_stime *
*===========================================================================*/
return(OK);
}
-
return( (time_t) (boottime + (uptime/HZ)));
}
-
/*===========================================================================*
* fetch_name *
*===========================================================================*/
return(r);
}
-
/*===========================================================================*
* no_sys *
*===========================================================================*/
return(EINVAL);
}
-
/*===========================================================================*
* panic *
*===========================================================================*/
sys_exit(1);
}
-
/*===========================================================================*
* conv2 *
*===========================================================================*/
return( ((w&BYTE) << 8) | ( (w>>8) & BYTE));
}
-
/*===========================================================================*
* conv4 *
*===========================================================================*/
return(read_write(WRITING));
}
-
/*===========================================================================*
* write_map *
*===========================================================================*/
return(OK);
}
-
/*===========================================================================*
* wr_indir *
*===========================================================================*/
bp->b_v2_ind[index] = (zone_t) conv4(sp->s_native, (long) zone);
}
-
/*===========================================================================*
* clear_zone *
*===========================================================================*/
}
}
-
/*===========================================================================*
* new_block *
*===========================================================================*/
return(bp);
}
-
/*===========================================================================*
* zero_block *
*===========================================================================*/
slotp->errct = 0;
}
-
int execute(char **cmd)
{
/* Execute a command with a path search along /sbin:/bin:/usr/sbin:/usr/bin.
return -1;
}
-
void wtmp(type, linenr, line, pid)
int type; /* type of entry */
int linenr; /* line number in ttytab */
#include "is.h"
-
/*===========================================================================*
* handle_fkey *
*===========================================================================*/
#include "../fs/fproc.h"
#include <minix/dmap.h>
-
PUBLIC struct fproc fproc[NR_PROCS];
PUBLIC struct dmap dmap[NR_DEVICES];
prev_i = i;
}
-
/*===========================================================================*
* dtab_dmp *
*===========================================================================*/
}
}
-
FORWARD _PROTOTYPE( char *s_flags_str, (int flags) );
FORWARD _PROTOTYPE( char *p_rts_flags_str, (int flags) );
-
/* Some global data that is shared among several dumping procedures.
* Note that the process table copy has the same name as in the kernel
* so that most macros and definitions from proc.h also apply here.
PUBLIC struct priv priv[NR_SYS_PROCS];
PUBLIC struct boot_image image[NR_BOOT_PROCS];
-
-
/*===========================================================================*
* timing_dmp *
*===========================================================================*/
printf("%s", print_buf); /* print the messages */
}
-
/*===========================================================================*
* monparams_dmp *
*===========================================================================*/
printf("\n%s\n", val);
}
-
/*===========================================================================*
* irqtab_dmp *
*===========================================================================*/
printf("\n");
}
-
/*===========================================================================*
* image_dmp *
*===========================================================================*/
return str;
}
-
/*===========================================================================*
* privileges_dmp *
*===========================================================================*/
#endif
}
-
PRIVATE char *p_rts_flags_str(int flags)
{
static char str[10];
return str;
}
-
/*===========================================================================*
* proctab_dmp *
*===========================================================================*/
return cproc_addr(proc_nr)->p_name;
}
-
#include "../pm/mproc.h"
#include <timers.h>
-
PUBLIC struct mproc mproc[NR_PROCS];
/*===========================================================================*
prev_i = i;
}
-
/*===========================================================================*
* sigaction_dmp *
*===========================================================================*/
prev_i = i;
}
-
extern int callnr; /* system call number */
extern int dont_reply; /* normally 0; set to 1 to inhibit reply */
-
-
FORWARD _PROTOTYPE(void get_work, (void) );
FORWARD _PROTOTYPE(void reply, (int whom, int result) );
-
/*===========================================================================*
* main *
*===========================================================================*/
}
}
-
-
-
/*===========================================================================*
* init_server *
*===========================================================================*/
exit(0);
}
-
/*===========================================================================*
* get_work *
*===========================================================================*/
callnr = m_in.m_type; /* set function call number */
}
-
/*===========================================================================*
* reply *
*===========================================================================*/
panic("IS", "unable to send reply!", send_status);
}
-
-
#endif
}
-
#if ENABLE_SWAP
/*===========================================================================*
* swap_on *
return(r); /* return new address or -1 */
}
-
/*===========================================================================*
* adjust *
*===========================================================================*/
}
#endif
-
-
#define PM_PID 0 /* PM's process id number */
#define INIT_PID 1 /* INIT's process id number */
-
return(SUSPEND); /* no reply, new program just runs */
}
-
/*===========================================================================*
* read_header *
*===========================================================================*/
return(m);
}
-
/*===========================================================================*
* new_mem *
*===========================================================================*/
return(OK);
}
-
/*===========================================================================*
* patch_ptr *
*===========================================================================*/
}
}
-
/*===========================================================================*
* insert_arg *
*===========================================================================*/
return(TRUE);
}
-
/*===========================================================================*
* patch_stack *
*===========================================================================*/
return(interp);
}
-
/*===========================================================================*
* rw_seg *
*===========================================================================*/
}
}
-
/*===========================================================================*
* find_share *
*===========================================================================*/
* do_wait: perform the WAITPID or WAIT system call
*/
-
#include "pm.h"
#include <sys/wait.h>
#include <minix/callnr.h>
#define LAST_FEW 2 /* last few slots reserved for superuser */
-
FORWARD _PROTOTYPE (void cleanup, (register struct mproc *child) );
/*===========================================================================*
return(new_pid); /* child's pid */
}
-
/*===========================================================================*
* do_pm_exit *
*===========================================================================*/
return(SUSPEND); /* can't communicate from beyond the grave */
}
-
/*===========================================================================*
* pm_exit *
*===========================================================================*/
if (procgrp != 0) check_sig(-procgrp, SIGHUP);
}
-
/*===========================================================================*
* do_waitpid *
*===========================================================================*/
}
}
-
/*===========================================================================*
* cleanup *
*===========================================================================*/
}
}
-
/*===========================================================================*
* get_work *
*===========================================================================*/
mp = &mproc[who < 0 ? PM_PROC_NR : who];
}
-
/*===========================================================================*
* setreply *
*===========================================================================*/
swap_inqueue(rmp); /* must swap this process back in */
}
-
/*===========================================================================*
* pm_init *
*===========================================================================*/
#include "mproc.h"
#include "param.h"
-
/*===========================================================================*
* do_allocmem *
*===========================================================================*/
return(OK);
}
-
/*===========================================================================*
* do_getprocnr *
*===========================================================================*/
return(OK);
}
-
/*=====================================================================*
* do_reboot *
*=====================================================================*/
PRIVATE time_t boottime;
-
/*===========================================================================*
* do_time *
*===========================================================================*/
return(OK);
}
-
/*===========================================================================*
* do_stime *
*===========================================================================*/
return(OK);
}
-
/*===========================================================================*
* do_times *
*===========================================================================*/
PRIVATE timer_t *pm_timers = NULL;
-
/*===========================================================================*
* pm_set_timer *
*===========================================================================*/
return;
}
-
/*===========================================================================*
* pm_expire_timers *
*===========================================================================*/
}
}
-
/*===========================================================================*
* pm_cancel_timer *
*===========================================================================*/
return(next_pid);
}
-
/*===========================================================================*
* allowed *
*===========================================================================*/
return(fd);
}
-
/*===========================================================================*
* no_sys *
*===========================================================================*/
return(ENOSYS);
}
-
/*===========================================================================*
* panic *
*===========================================================================*/
sys_abort(RBT_PANIC);
}
-
/*===========================================================================*
* tell_fs *
*===========================================================================*/
_taskcall(FS_PROC_NR, what, &m);
}
-
/*==========================================================================*
* find_param *
*==========================================================================*/
return(NULL);
}
-
/*===========================================================================*
* get_mem_map *
*===========================================================================*/
return(OK);
}
-
/*===========================================================================*
* do_stop *
*===========================================================================*/
return(OK);
}
-
_PROTOTYPE( int do_start, (message *m));
_PROTOTYPE( int do_stop, (message *m));
-
#include <sys/types.h>
#include <sys/stat.h>
-
/* This array defines all known requests. */
PRIVATE char *known_requests[] = {
"up",
exit(EGENERIC);
}
-
/* Parse and verify correctness of arguments. Report problem and exit if an
* error is found. Store needed parameters in global variables.
*/
return(i);
}
-
/* Main program.
*/
PUBLIC int main(int argc, char **argv)
}
}
-
/*===========================================================================*
* init_server *
*===========================================================================*/
if (sigaction(SIGHUP, &sa, NULL)<0) panic("SM","sigaction failed", errno);
}
-
/*===========================================================================*
* get_work *
*===========================================================================*/
callnr = m_in.m_type; /* set function call number */
}
-
/*===========================================================================*
* reply *
*===========================================================================*/
panic("SM", "unable to send reply!", send_status);
}
-
-
