oneechanhax/phunix
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove protocol version of {mode,ino,uid,gid}_t

Browse Source 
Now that we have enough room in the message, remove these types.

Change-Id: Ib734c6f0209b259a14a1189b3886b9c8474e1b9a
This commit is contained in:
Lionel Sambuc 2014-05-01 16:19:28 +02:00
parent 56350a991b
commit b6aa3714a1
45 changed files with 127 additions and 135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
include/minix/vfsif.h
View File

@ -82,12 +82,6 @@ typedef struct {
gid_t vu_sgroups[NGROUPS_MAX]; gid_t vu_sgroups[NGROUPS_MAX];
} vfs_ucred_t; } vfs_ucred_t;
/* Some system types are larger than what the protocol and FSes use */
typedef u16_t puid_t; /* Protocol version of uid_t */
typedef u16_t pgid_t; /* Protocol version of gid_t */
typedef u16_t pmode_t; /* Protocol version of mode_t */
typedef u32_t pino_t; /* Protocol version of ino_t */
/* Request numbers */ /* Request numbers */
#define REQ_GETNODE (FS_BASE + 1) /* Should be removed */ #define REQ_GETNODE (FS_BASE + 1) /* Should be removed */
#define REQ_PUTNODE (FS_BASE + 2) #define REQ_PUTNODE (FS_BASE + 2)

6
lib/libpuffs/path.c
View File

@ -29,7 +29,7 @@ char dot2[3] = ".."; /* permissions for . and .. */
static char *get_name(char *name, char string[NAME_MAX+1]); static char *get_name(char *name, char string[NAME_MAX+1]);
static int ltraverse(struct puffs_node *pn, char *suffix); static int ltraverse(struct puffs_node *pn, char *suffix);
static int parse_path(pino_t dir_ino, pino_t root_ino, int flags, struct static int parse_path(ino_t dir_ino, ino_t root_ino, int flags, struct
puffs_node **res_inop, size_t *offsetp, int *symlinkp); puffs_node **res_inop, size_t *offsetp, int *symlinkp);
/*===========================================================================* /*===========================================================================*
@ -129,8 +129,8 @@ int fs_lookup(void)
* parse_path * * parse_path *
*===========================================================================*/ *===========================================================================*/
static int parse_path( static int parse_path(
pino_t dir_ino, ino_t dir_ino,
pino_t root_ino, ino_t root_ino,
int flags, int flags,
struct puffs_node **res_inop, struct puffs_node **res_inop,
size_t *offsetp, size_t *offsetp,

2
lib/libsffs/inode.c
View File

@ -65,7 +65,7 @@ struct inode *init_inode(void)
/*===========================================================================* /*===========================================================================*
* find_inode * * find_inode *
*===========================================================================*/ *===========================================================================*/
struct inode *find_inode(pino_t ino_nr) struct inode *find_inode(ino_t ino_nr)
{ {
/* Get an inode based on its inode number. Do not increase its reference count. /* Get an inode based on its inode number. Do not increase its reference count.
*/ */

2
lib/libsffs/lookup.c
View File

@ -57,7 +57,7 @@ static int access_as_dir(
/* Check whether the given inode may be accessed as directory. /* Check whether the given inode may be accessed as directory.
* Return OK or an appropriate error code. * Return OK or an appropriate error code.
*/ */
pmode_t mode; mode_t mode;
assert(attr->a_mask & SFFS_ATTR_MODE); assert(attr->a_mask & SFFS_ATTR_MODE);

4
lib/libsffs/proto.h
View File

@ -13,7 +13,7 @@ void put_handle(struct inode *ino);
/* inode.c */ /* inode.c */
struct inode *init_inode(void); struct inode *init_inode(void);
struct inode *find_inode(pino_t ino_nr); struct inode *find_inode(ino_t ino_nr);
void get_inode(struct inode *ino); void get_inode(struct inode *ino);
void put_inode(struct inode *ino); void put_inode(struct inode *ino);
void link_inode(struct inode *parent, struct inode *ino); void link_inode(struct inode *parent, struct inode *ino);
@ -57,7 +57,7 @@ int do_read(void);
int do_getdents(void); int do_getdents(void);
/* stat.c */ /* stat.c */
pmode_t get_mode(struct inode *ino, int mode); mode_t get_mode(struct inode *ino, int mode);
int do_stat(void); int do_stat(void);
int do_chmod(void); int do_chmod(void);
int do_utime(void); int do_utime(void);

4
lib/libsffs/stat.c
View File

@ -15,7 +15,7 @@
/*===========================================================================* /*===========================================================================*
* get_mode * * get_mode *
*===========================================================================*/ *===========================================================================*/
pmode_t get_mode(struct inode *ino, int mode) mode_t get_mode(struct inode *ino, int mode)
{ {
/* Return the mode for an inode, given the inode and the retrieved mode. /* Return the mode for an inode, given the inode and the retrieved mode.
*/ */
@ -45,7 +45,7 @@ int do_stat(void)
struct sffs_attr attr; struct sffs_attr attr;
struct stat stat; struct stat stat;
char path[PATH_MAX]; char path[PATH_MAX];
pino_t ino_nr; ino_t ino_nr;
int r; int r;
ino_nr = m_in.m_vfs_fs_stat.inode; ino_nr = m_in.m_vfs_fs_stat.inode;

4
lib/libvtreefs/inode.c
View File

@ -426,7 +426,7 @@ struct inode *get_inode_by_index(struct inode *parent, index_t index)
/*===========================================================================* /*===========================================================================*
* find_inode * * find_inode *
*===========================================================================*/ *===========================================================================*/
struct inode *find_inode(pino_t num) struct inode *find_inode(ino_t num)
{ {
/* Retrieve an inode by inode number. /* Retrieve an inode by inode number.
*/ */
@ -442,7 +442,7 @@ struct inode *find_inode(pino_t num)
/*===========================================================================* /*===========================================================================*
* get_inode * * get_inode *
*===========================================================================*/ *===========================================================================*/
struct inode *get_inode(pino_t num) struct inode *get_inode(ino_t num)
{ {
/* Retrieve an inode by inode number, and increase its reference count. /* Retrieve an inode by inode number, and increase its reference count.
*/ */

2
lib/libvtreefs/path.c
View File

@ -10,7 +10,7 @@ static int access_as_dir(struct inode *node, vfs_ucred_t *ucred)
/* Check whether the given inode may be accessed as directory. /* Check whether the given inode may be accessed as directory.
* Return OK or an appropriate error code. * Return OK or an appropriate error code.
*/ */
pmode_t mask; mode_t mask;
int i; int i;
/* The inode must be a directory to begin with. */ /* The inode must be a directory to begin with. */

4
lib/libvtreefs/proto.h
View File

@ -5,8 +5,8 @@
void init_inodes(unsigned int inodes, struct inode_stat *stat, index_t void init_inodes(unsigned int inodes, struct inode_stat *stat, index_t
nr_indexed_entries); nr_indexed_entries);
void cleanup_inodes(void); void cleanup_inodes(void);
struct inode *find_inode(pino_t num); struct inode *find_inode(ino_t num);
struct inode *get_inode(pino_t num); struct inode *get_inode(ino_t num);
void put_inode(struct inode *node); void put_inode(struct inode *node);
void ref_inode(struct inode *node); void ref_inode(struct inode *node);
int get_inode_number(struct inode *node); int get_inode_number(struct inode *node);

2
servers/ext2/const.h
View File

@ -55,7 +55,7 @@
#define SUPER_BLOCK_BYTES (1024) /* bytes offset */ #define SUPER_BLOCK_BYTES (1024) /* bytes offset */
#define ROOT_INODE ((pino_t) 2) /* inode number for root directory */ #define ROOT_INODE ((ino_t) 2) /* inode number for root directory */
#define BOOT_BLOCK ((block_t) 0) /* block number of boot block */ #define BOOT_BLOCK ((block_t) 0) /* block number of boot block */
#define START_BLOCK ((block_t) 2) /* first block of FS (not counting SB) */ #define START_BLOCK ((block_t) 2) /* first block of FS (not counting SB) */
#define BLOCK_ADDRESS_BYTES 4 /* bytes per address */ #define BLOCK_ADDRESS_BYTES 4 /* bytes per address */

4
servers/ext2/ialloc.c
View File

@ -29,7 +29,7 @@ static void wipe_inode(struct inode *rip);
/*===========================================================================* /*===========================================================================*
* alloc_inode * * alloc_inode *
*===========================================================================*/ *===========================================================================*/
struct inode *alloc_inode(struct inode *parent, pmode_t bits) struct inode *alloc_inode(struct inode *parent, mode_t bits)
{ {
/* Allocate a free inode on parent's dev, and return a pointer to it. */ /* Allocate a free inode on parent's dev, and return a pointer to it. */
@ -125,7 +125,7 @@ struct inode *parent; /* parent of newly allocated inode */
int is_dir; /* inode will be a directory if it is TRUE */ int is_dir; /* inode will be a directory if it is TRUE */
{ {
int group; int group;
pino_t inumber = NO_BIT; ino_t inumber = NO_BIT;
bit_t bit; bit_t bit;
struct buf *bp; struct buf *bp;
struct group_desc *gd; struct group_desc *gd;

4
servers/ext2/inode.c
View File

@ -120,7 +120,7 @@ static void unhash_inode(struct inode *node)
*===========================================================================*/ *===========================================================================*/
struct inode *get_inode( struct inode *get_inode(
dev_t dev, /* device on which inode resides */ dev_t dev, /* device on which inode resides */
pino_t numb /* inode number (ANSI: may not be unshort) */ ino_t numb /* inode number (ANSI: may not be unshort) */
) )
{ {
/* Find the inode in the hash table. If it is not there, get a free inode /* Find the inode in the hash table. If it is not there, get a free inode
@ -198,7 +198,7 @@ struct inode *get_inode(
*===========================================================================*/ *===========================================================================*/
struct inode *find_inode( struct inode *find_inode(
dev_t dev, /* device on which inode resides */ dev_t dev, /* device on which inode resides */
pino_t numb /* inode number (ANSI: may not be unshort) */ ino_t numb /* inode number (ANSI: may not be unshort) */
) )
{ {
/* Find the inode specified by the inode and device number. */ /* Find the inode specified by the inode and device number. */

2
servers/ext2/inode.h
View File

@ -71,7 +71,7 @@ EXTERN struct inode {
/* The following items are not present on the disk. */ /* The following items are not present on the disk. */
dev_t i_dev; /* which device is the inode on */ dev_t i_dev; /* which device is the inode on */
pino_t i_num; /* inode number on its (minor) device */ ino_t i_num; /* inode number on its (minor) device */
int i_count; /* # times inode used; 0 means slot is free */ int i_count; /* # times inode used; 0 means slot is free */
struct super_block *i_sp; /* pointer to super block for inode's device */ struct super_block *i_sp; /* pointer to super block for inode's device */
char i_dirt; /* CLEAN or DIRTY */ char i_dirt; /* CLEAN or DIRTY */

12
servers/ext2/link.c
View File

@ -271,7 +271,7 @@ char file_name[NAME_MAX + 1]; /* name of file to be removed */
{ {
/* Unlink 'file_name'; rip must be the inode of 'file_name' or NULL. */ /* Unlink 'file_name'; rip must be the inode of 'file_name' or NULL. */
pino_t numb; /* inode number */ ino_t numb; /* inode number */
int r; int r;
/* If rip is not NULL, it is used to get faster access to the inode. */ /* If rip is not NULL, it is used to get faster access to the inode. */
@ -310,7 +310,7 @@ int fs_rename()
int odir, ndir; /* TRUE iff {old|new} file is dir */ int odir, ndir; /* TRUE iff {old|new} file is dir */
int same_pdir = 0; /* TRUE iff parent dirs are the same */ int same_pdir = 0; /* TRUE iff parent dirs are the same */
char old_name[NAME_MAX + 1], new_name[NAME_MAX + 1]; char old_name[NAME_MAX + 1], new_name[NAME_MAX + 1];
pino_t numb; ino_t numb;
phys_bytes len; phys_bytes len;
/* Copy the last component of the old name */ /* Copy the last component of the old name */
@ -334,7 +334,7 @@ int fs_rename()
NUL(new_name, len, sizeof(new_name)); NUL(new_name, len, sizeof(new_name));
/* Get old dir inode */ /* Get old dir inode */
if( (old_dirp = get_inode(fs_dev, (pino_t) fs_m_in.m_vfs_fs_rename.dir_old)) == NULL) if( (old_dirp = get_inode(fs_dev, fs_m_in.m_vfs_fs_rename.dir_old)) == NULL)
return(err_code); return(err_code);
old_ip = advance(old_dirp, old_name, IGN_PERM); old_ip = advance(old_dirp, old_name, IGN_PERM);
@ -350,7 +350,7 @@ int fs_rename()
} }
/* Get new dir inode */ /* Get new dir inode */
if ((new_dirp = get_inode(fs_dev, (pino_t) fs_m_in.m_vfs_fs_rename.dir_new)) == NULL){ if ((new_dirp = get_inode(fs_dev, fs_m_in.m_vfs_fs_rename.dir_new)) == NULL){
put_inode(old_ip); put_inode(old_ip);
put_inode(old_dirp); put_inode(old_dirp);
return(err_code); return(err_code);
@ -483,7 +483,7 @@ int fs_rename()
r = search_dir(new_dirp, new_name, &numb, ENTER, IGN_PERM, r = search_dir(new_dirp, new_name, &numb, ENTER, IGN_PERM,
old_ip->i_mode & I_TYPE); old_ip->i_mode & I_TYPE);
if(r == OK) { if(r == OK) {
(void) search_dir(old_dirp, old_name, (pino_t *) 0, (void) search_dir(old_dirp, old_name, NULL,
DELETE, IGN_PERM, 0); DELETE, IGN_PERM, 0);
} }
} }
@ -551,7 +551,7 @@ off_t newsize; /* inode must become this size */
* writing is done. * writing is done.
*/ */
int r; int r;
pmode_t file_type; mode_t file_type;
discard_preallocated_blocks(rip); discard_preallocated_blocks(rip);

9
servers/ext2/open.c
View File

@ -12,7 +12,7 @@
#include "super.h" #include "super.h"
#include <minix/vfsif.h> #include <minix/vfsif.h>
static struct inode *new_node(struct inode *ldirp, char *string, pmode_t static struct inode *new_node(struct inode *ldirp, char *string, mode_t
bits, block_t z0); bits, block_t z0);
@ -118,7 +118,7 @@ int fs_mknod()
int fs_mkdir() int fs_mkdir()
{ {
int r1, r2; /* status codes */ int r1, r2; /* status codes */
pino_t dot, dotdot; /* inode numbers for . and .. */ ino_t dot, dotdot; /* inode numbers for . and .. */
struct inode *rip, *ldirp; struct inode *rip, *ldirp;
char lastc[NAME_MAX + 1]; /* last component */ char lastc[NAME_MAX + 1]; /* last component */
phys_bytes len; phys_bytes len;
@ -213,8 +213,7 @@ int fs_slink()
return(EINVAL); return(EINVAL);
/* Create the inode for the symlink. */ /* Create the inode for the symlink. */
sip = new_node(ldirp, string, (pmode_t) (I_SYMBOLIC_LINK | RWX_MODES), sip = new_node(ldirp, string, (I_SYMBOLIC_LINK | RWX_MODES), 0);
(block_t) 0);
/* If we can then create fast symlink (store it in inode), /* If we can then create fast symlink (store it in inode),
* Otherwise allocate a disk block for the contents of the symlink and * Otherwise allocate a disk block for the contents of the symlink and
@ -278,7 +277,7 @@ int fs_slink()
* new_node * * new_node *
*===========================================================================*/ *===========================================================================*/
static struct inode *new_node(struct inode *ldirp, static struct inode *new_node(struct inode *ldirp,
char *string, pmode_t bits, block_t b0) char *string, mode_t bits, block_t b0)
{ {
/* New_node() is called by fs_open(), fs_mknod(), and fs_mkdir(). /* New_node() is called by fs_open(), fs_mknod(), and fs_mkdir().
* In all cases it allocates a new inode, makes a directory entry for it in * In all cases it allocates a new inode, makes a directory entry for it in

22
servers/ext2/path.c
View File

@ -29,7 +29,7 @@ char dot2[3] = ".."; /* permissions for . and .. */
static char *get_name(char *name, char string[NAME_MAX+1]); static char *get_name(char *name, char string[NAME_MAX+1]);
static int ltraverse(struct inode *rip, char *suffix); static int ltraverse(struct inode *rip, char *suffix);
static int parse_path(pino_t dir_ino, pino_t root_ino, int flags, struct static int parse_path(ino_t dir_ino, ino_t root_ino, int flags, struct
inode **res_inop, size_t *offsetp, int *symlinkp); inode **res_inop, size_t *offsetp, int *symlinkp);
/*===========================================================================* /*===========================================================================*
@ -41,7 +41,7 @@ int fs_lookup()
int r, r1, flags, symlinks; int r, r1, flags, symlinks;
unsigned int len; unsigned int len;
size_t offset = 0, path_size; size_t offset = 0, path_size;
pino_t dir_ino, root_ino; ino_t dir_ino, root_ino;
struct inode *rip; struct inode *rip;
grant = fs_m_in.m_vfs_fs_lookup.grant_path; grant = fs_m_in.m_vfs_fs_lookup.grant_path;
@ -121,8 +121,8 @@ int fs_lookup()
* parse_path * * parse_path *
*===========================================================================*/ *===========================================================================*/
static int parse_path(dir_ino, root_ino, flags, res_inop, offsetp, symlinkp) static int parse_path(dir_ino, root_ino, flags, res_inop, offsetp, symlinkp)
pino_t dir_ino; ino_t dir_ino;
pino_t root_ino; ino_t root_ino;
int flags; int flags;
struct inode **res_inop; struct inode **res_inop;
size_t *offsetp; size_t *offsetp;
@ -370,7 +370,7 @@ int chk_perm; /* check permissions when string is looked up*/
* the directory, find the inode, open it, and return a pointer to its inode * the directory, find the inode, open it, and return a pointer to its inode
* slot. * slot.
*/ */
pino_t numb; ino_t numb;
struct inode *rip; struct inode *rip;
/* If 'string' is empty, return an error. */ /* If 'string' is empty, return an error. */
@ -483,7 +483,7 @@ char string[NAME_MAX+1]; /* component extracted from 'old_name' */
int search_dir(ldir_ptr, string, numb, flag, check_permissions, ftype) int search_dir(ldir_ptr, string, numb, flag, check_permissions, ftype)
register struct inode *ldir_ptr; /* ptr to inode for dir to search */ register struct inode *ldir_ptr; /* ptr to inode for dir to search */
const char string[NAME_MAX + 1]; /* component to search for */ const char string[NAME_MAX + 1]; /* component to search for */
pino_t *numb; /* pointer to inode number */ ino_t *numb; /* pointer to inode number */
int flag; /* LOOK_UP, ENTER, DELETE or IS_EMPTY */ int flag; /* LOOK_UP, ENTER, DELETE or IS_EMPTY */
int check_permissions; /* check permissions when flag is !IS_EMPTY */ int check_permissions; /* check permissions when flag is !IS_EMPTY */
int ftype; /* used when ENTER and int ftype; /* used when ENTER and
@ -502,7 +502,7 @@ int ftype; /* used when ENTER and
register struct ext2_disk_dir_desc *prev_dp = NULL; register struct ext2_disk_dir_desc *prev_dp = NULL;
register struct buf *bp = NULL; register struct buf *bp = NULL;
int i, r, e_hit, t, match; int i, r, e_hit, t, match;
pmode_t bits; mode_t bits;
off_t pos; off_t pos;
unsigned new_slots; unsigned new_slots;
int extended = 0; int extended = 0;
@ -576,10 +576,10 @@ int ftype; /* used when ENTER and
r = OK; r = OK;
if (flag == IS_EMPTY) r = ENOTEMPTY; if (flag == IS_EMPTY) r = ENOTEMPTY;
else if (flag == DELETE) { else if (flag == DELETE) {
if (dp->d_name_len >= sizeof(pino_t)) { if (dp->d_name_len >= sizeof(ino_t)) {
/* Save d_ino for recovery. */ /* Save d_ino for recovery. */
t = dp->d_name_len - sizeof(pino_t); t = dp->d_name_len - sizeof(ino_t);
*((pino_t *) &dp->d_name[t])= dp->d_ino; *((ino_t *) &dp->d_name[t])= dp->d_ino;
} }
dp->d_ino = NO_ENTRY; /* erase entry */ dp->d_ino = NO_ENTRY; /* erase entry */
lmfs_markdirty(bp); lmfs_markdirty(bp);
@ -619,7 +619,7 @@ int ftype; /* used when ENTER and
} }
} else { } else {
/* 'flag' is LOOK_UP */ /* 'flag' is LOOK_UP */
*numb = (pino_t) conv4(le_CPU, dp->d_ino); *numb = (ino_t) conv4(le_CPU, dp->d_ino);
} }
assert(lmfs_dev(bp) != NO_DEV); assert(lmfs_dev(bp) != NO_DEV);
put_block(bp, DIRECTORY_BLOCK); put_block(bp, DIRECTORY_BLOCK);

6
servers/ext2/protect.c
View File

@ -18,7 +18,7 @@ int fs_chmod()
/* Perform the chmod(name, mode) system call. */ /* Perform the chmod(name, mode) system call. */
register struct inode *rip; register struct inode *rip;
pmode_t mode; mode_t mode;
mode = fs_m_in.m_vfs_fs_chmod.mode; mode = fs_m_in.m_vfs_fs_chmod.mode;
@ -72,7 +72,7 @@ int fs_chown()
/*===========================================================================* /*===========================================================================*
* forbidden * * forbidden *
*===========================================================================*/ *===========================================================================*/
int forbidden(register struct inode *rip, pmode_t access_desired) int forbidden(struct inode *rip, mode_t access_desired)
{ {
/* Given a pointer to an inode, 'rip', and the access desired, determine /* Given a pointer to an inode, 'rip', and the access desired, determine
* if the access is allowed, and if not why not. The routine looks up the * if the access is allowed, and if not why not. The routine looks up the
@ -81,7 +81,7 @@ int forbidden(register struct inode *rip, pmode_t access_desired)
*/ */
register struct inode *old_rip = rip; register struct inode *old_rip = rip;
register pmode_t bits, perm_bits; mode_t bits, perm_bits;
int r, shift; int r, shift;
/* Isolate the relevant rwx bits from the mode. */ /* Isolate the relevant rwx bits from the mode. */

10
servers/ext2/proto.h
View File

@ -19,15 +19,15 @@ block_t alloc_block(struct inode *rip, block_t goal);
void free_block(struct super_block *sp, bit_t bit); void free_block(struct super_block *sp, bit_t bit);
/* ialloc.c */ /* ialloc.c */
struct inode *alloc_inode(struct inode *parent, pmode_t bits); struct inode *alloc_inode(struct inode *parent, mode_t bits);
void free_inode(struct inode *rip); void free_inode(struct inode *rip);
/* inode.c */ /* inode.c */
void dup_inode(struct inode *ip); void dup_inode(struct inode *ip);
struct inode *find_inode(dev_t dev, pino_t numb); struct inode *find_inode(dev_t dev, ino_t numb);
int fs_putnode(void); int fs_putnode(void);
void init_inode_cache(void); void init_inode_cache(void);
struct inode *get_inode(dev_t dev, pino_t numb); struct inode *get_inode(dev_t dev, ino_t numb);
void put_inode(struct inode *rip); void put_inode(struct inode *rip);
void update_times(struct inode *rip); void update_times(struct inode *rip);
void rw_inode(struct inode *rip, int rw_flag); void rw_inode(struct inode *rip, int rw_flag);
@ -62,14 +62,14 @@ int fs_slink(void);
int fs_lookup(void); int fs_lookup(void);
struct inode *advance(struct inode *dirp, char string[NAME_MAX + 1], int struct inode *advance(struct inode *dirp, char string[NAME_MAX + 1], int
chk_perm); chk_perm);
int search_dir(struct inode *ldir_ptr, const char string [NAME_MAX + 1], pino_t int search_dir(struct inode *ldir_ptr, const char string [NAME_MAX + 1], ino_t
*numb, int flag, int check_permissions, int ftype); *numb, int flag, int check_permissions, int ftype);
/* protect.c */ /* protect.c */
int fs_chmod(void); int fs_chmod(void);
int fs_chown(void); int fs_chown(void);
int fs_getdents(void); int fs_getdents(void);
int forbidden(struct inode *rip, pmode_t access_desired); int forbidden(struct inode *rip, mode_t access_desired);
int read_only(struct inode *ip); int read_only(struct inode *ip);
/* read.c */ /* read.c */

2
servers/ext2/stadir.c
View File

@ -23,7 +23,7 @@ static int stat_inode(
/* Common code for stat and fstat system calls. */ /* Common code for stat and fstat system calls. */
struct stat statbuf; struct stat statbuf;
pmode_t mo; mode_t mo;
int r, s; int r, s;
/* Update the atime, ctime, and mtime fields in the inode, if need be. */ /* Update the atime, ctime, and mtime fields in the inode, if need be. */

6
servers/iso9660fs/inode.c
View File

@ -86,7 +86,7 @@ struct dir_record *get_free_dir_record(void)
* get_dir_record * * get_dir_record *
*===========================================================================*/ *===========================================================================*/
struct dir_record *get_dir_record(id_dir_record) struct dir_record *get_dir_record(id_dir_record)
pino_t id_dir_record; ino_t id_dir_record;
{ {
struct dir_record *dir = NULL; struct dir_record *dir = NULL;
u32_t address; u32_t address;
@ -209,8 +209,8 @@ u32_t address;
/* Set physical address of the dir record */ /* Set physical address of the dir record */
dir->d_phy_addr = address; dir->d_phy_addr = address;
dir->d_ino_nr = (pino_t) address; /* u32_t e ino_t are the same datatype so dir->d_ino_nr = address;
* the cast is safe */
return(OK); return(OK);
} }

4
servers/iso9660fs/inode.h
View File

@ -18,10 +18,10 @@ struct dir_record {
/* Memory attrs */ /* Memory attrs */
u8_t d_count; /* Count if the dir_record is in use or not */ u8_t d_count; /* Count if the dir_record is in use or not */
pmode_t d_mode; /* file type, protection, etc. */ mode_t d_mode; /* file type, protection, etc. */
/* struct hash_idi_entry *id; */ /* id associated */ /* struct hash_idi_entry *id; */ /* id associated */
u32_t d_phy_addr; /* physical address of this dir record */ u32_t d_phy_addr; /* physical address of this dir record */
pino_t d_ino_nr; /* inode number (identical to the address) */ ino_t d_ino_nr; /* inode number (identical to the address) */
char d_mountpoint; /* true if mounted on */ char d_mountpoint; /* true if mounted on */
struct dir_record *d_next; /* In case the file consists in more file sections struct dir_record *d_next; /* In case the file consists in more file sections
this points to the next one */ this points to the next one */

12
servers/iso9660fs/path.c
View File

@ -6,7 +6,7 @@
#include "buf.h" #include "buf.h"
static char *get_name(char *name, char string[NAME_MAX+1]); static char *get_name(char *name, char string[NAME_MAX+1]);
static int parse_path(pino_t dir_ino, pino_t root_ino, int flags, struct static int parse_path(ino_t dir_ino, ino_t root_ino, int flags, struct
dir_record **res_inop, size_t *offsetp); dir_record **res_inop, size_t *offsetp);
@ -82,7 +82,7 @@ int fs_lookup() {
int search_dir( int search_dir(
register struct dir_record *ldir_ptr, /* dir record parent */ register struct dir_record *ldir_ptr, /* dir record parent */
char string[NAME_MAX], /* component to search for */ char string[NAME_MAX], /* component to search for */
pino_t *numb /* pointer to new dir record */ ino_t *numb /* pointer to new dir record */
) { ) {
struct dir_record *dir_tmp; struct dir_record *dir_tmp;
register struct buf *bp; register struct buf *bp;
@ -182,8 +182,8 @@ int search_dir(
* parse_path * * parse_path *
*===========================================================================*/ *===========================================================================*/
static int parse_path( static int parse_path(
pino_t dir_ino, ino_t dir_ino,
pino_t root_ino, ino_t root_ino,
int flags, int flags,
struct dir_record **res_inop, struct dir_record **res_inop,
size_t *offsetp size_t *offsetp
@ -195,7 +195,7 @@ size_t *offsetp
/* Find starting inode inode according to the request message */ /* Find starting inode inode according to the request message */
if ((start_dir = get_dir_record(dir_ino)) == NULL) { if ((start_dir = get_dir_record(dir_ino)) == NULL) {
printf("ISOFS: couldn't find starting inode %u\n", dir_ino); printf("ISOFS: couldn't find starting inode %llu\n", dir_ino);
return(ENOENT); return(ENOENT);
} }
@ -292,7 +292,7 @@ struct dir_record **resp; /* resulting inode */
register struct dir_record *rip = NULL; register struct dir_record *rip = NULL;
int r; int r;
pino_t numb; ino_t numb;
/* If 'string' is empty, yield same inode straight away. */ /* If 'string' is empty, yield same inode straight away. */
if (string[0] == '\0') { if (string[0] == '\0') {

4
servers/iso9660fs/proto.h
View File

@ -19,7 +19,7 @@ int create_dir_record(struct dir_record *dir, char *buffer, u32_t
int create_ext_attr(struct ext_attr_rec *ext, char *buffer); int create_ext_attr(struct ext_attr_rec *ext, char *buffer);
int fs_getnode(void); int fs_getnode(void);
int fs_putnode(void); int fs_putnode(void);
struct dir_record *get_dir_record(pino_t id_dir); struct dir_record *get_dir_record(ino_t id_dir);
struct dir_record *get_free_dir_record(void); struct dir_record *get_free_dir_record(void);
struct ext_attr_rec *get_free_ext_attr(void); struct ext_attr_rec *get_free_ext_attr(void);
struct dir_record *load_dir_record_from_disk(u32_t address); struct dir_record *load_dir_record_from_disk(u32_t address);
@ -38,7 +38,7 @@ int fs_unmount(void);
int fs_lookup(void); int fs_lookup(void);
int advance(struct dir_record *dirp, char string[NAME_MAX], struct int advance(struct dir_record *dirp, char string[NAME_MAX], struct
dir_record **resp); dir_record **resp);
int search_dir(struct dir_record *ldir_ptr,char string [NAME_MAX],pino_t *numb); int search_dir(struct dir_record *ldir_ptr, char string [NAME_MAX], ino_t *numb);
/* read.c */ /* read.c */
int fs_read(void); int fs_read(void);

2
servers/iso9660fs/read.c
View File

@ -143,7 +143,7 @@ int fs_bread(void)
int fs_getdents(void) int fs_getdents(void)
{ {
struct dir_record *dir; struct dir_record *dir;
pino_t ino; ino_t ino;
cp_grant_id_t gid; cp_grant_id_t gid;
size_t block_size; size_t block_size;
off_t pos, block_pos, block, cur_pos, tmpbuf_offset, userbuf_off; off_t pos, block_pos, block, cur_pos, tmpbuf_offset, userbuf_off;

2
servers/mfs/const.h
View File

@ -60,7 +60,7 @@
#define END_OF_FILE (-104) /* eof detected */ #define END_OF_FILE (-104) /* eof detected */
#define ROOT_INODE ((pino_t) 1) /* inode number for root directory */ #define ROOT_INODE ((ino_t) 1) /* inode number for root directory */
#define BOOT_BLOCK ((block_t) 0) /* block number of boot block */ #define BOOT_BLOCK ((block_t) 0) /* block number of boot block */
#define SUPER_BLOCK_BYTES (1024) /* bytes offset */ #define SUPER_BLOCK_BYTES (1024) /* bytes offset */
#define START_BLOCK ((block_t) 2) /* first block of FS (not counting SB) */ #define START_BLOCK ((block_t) 2) /* first block of FS (not counting SB) */

12
servers/mfs/inode.c
View File

@ -25,7 +25,7 @@
static void addhash_inode(struct inode *node); static void addhash_inode(struct inode *node);
static void free_inode(dev_t dev, pino_t numb); static void free_inode(dev_t dev, ino_t numb);
static void new_icopy(struct inode *rip, d2_inode *dip, int direction, static void new_icopy(struct inode *rip, d2_inode *dip, int direction,
int norm); int norm);
static void unhash_inode(struct inode *node); static void unhash_inode(struct inode *node);
@ -123,7 +123,7 @@ static void unhash_inode(struct inode *node)
*===========================================================================*/ *===========================================================================*/
struct inode *get_inode( struct inode *get_inode(
dev_t dev, /* device on which inode resides */ dev_t dev, /* device on which inode resides */
pino_t numb /* inode number */ ino_t numb /* inode number */
) )
{ {
/* Find the inode in the hash table. If it is not there, get a free inode /* Find the inode in the hash table. If it is not there, get a free inode
@ -185,7 +185,7 @@ struct inode *get_inode(
*===========================================================================*/ *===========================================================================*/
struct inode *find_inode( struct inode *find_inode(
dev_t dev, /* device on which inode resides */ dev_t dev, /* device on which inode resides */
pino_t numb /* inode number */ ino_t numb /* inode number */
) )
{ {
/* Find the inode specified by the inode and device number. /* Find the inode specified by the inode and device number.
@ -255,7 +255,7 @@ register struct inode *rip; /* pointer to inode to be released */
/*===========================================================================* /*===========================================================================*
* alloc_inode * * alloc_inode *
*===========================================================================*/ *===========================================================================*/
struct inode *alloc_inode(dev_t dev, pmode_t bits) struct inode *alloc_inode(dev_t dev, mode_t bits)
{ {
/* Allocate a free inode on 'dev', and return a pointer to it. */ /* Allocate a free inode on 'dev', and return a pointer to it. */
@ -333,7 +333,7 @@ register struct inode *rip; /* the inode to be erased */
*===========================================================================*/ *===========================================================================*/
static void free_inode( static void free_inode(
dev_t dev, /* on which device is the inode? */ dev_t dev, /* on which device is the inode? */
pino_t inumb /* number of the inode to be freed */ ino_t inumb /* number of the inode to be freed */
) )
{ {
/* Return an inode to the pool of unallocated inodes. */ /* Return an inode to the pool of unallocated inodes. */
@ -428,7 +428,7 @@ int norm; /* TRUE = do not swap bytes; FALSE = swap */
if (direction == READING) { if (direction == READING) {
/* Copy V2.x inode to the in-core table, swapping bytes if need be. */ /* Copy V2.x inode to the in-core table, swapping bytes if need be. */
rip->i_mode = (pmode_t) conv2(norm,dip->d2_mode); rip->i_mode = (mode_t) conv2(norm,dip->d2_mode);
rip->i_uid = (uid_t) conv2(norm,dip->d2_uid); rip->i_uid = (uid_t) conv2(norm,dip->d2_uid);
rip->i_nlinks = (nlink_t) conv2(norm,dip->d2_nlinks); rip->i_nlinks = (nlink_t) conv2(norm,dip->d2_nlinks);
rip->i_gid = (gid_t) conv2(norm,dip->d2_gid); rip->i_gid = (gid_t) conv2(norm,dip->d2_gid);

2
servers/mfs/inode.h
View File

@ -30,7 +30,7 @@ EXTERN struct inode {
/* The following items are not present on the disk. */ /* The following items are not present on the disk. */
dev_t i_dev; /* which device is the inode on */ dev_t i_dev; /* which device is the inode on */
pino_t i_num; /* inode number on its (minor) device */ ino_t i_num; /* inode number on its (minor) device */
int i_count; /* # times inode used; 0 means slot is free */ int i_count; /* # times inode used; 0 means slot is free */
unsigned int i_ndzones; /* # direct zones (Vx_NR_DZONES) */ unsigned int i_ndzones; /* # direct zones (Vx_NR_DZONES) */
unsigned int i_nindirs; /* # indirect zones per indirect block */ unsigned int i_nindirs; /* # indirect zones per indirect block */

8
servers/mfs/link.c
View File

@ -252,7 +252,7 @@ char file_name[MFS_NAME_MAX]; /* name of file to be removed */
{ {
/* Unlink 'file_name'; rip must be the inode of 'file_name' or NULL. */ /* Unlink 'file_name'; rip must be the inode of 'file_name' or NULL. */
pino_t numb; /* inode number */ ino_t numb; /* inode number */
int r; int r;
/* If rip is not NULL, it is used to get faster access to the inode. */ /* If rip is not NULL, it is used to get faster access to the inode. */
@ -291,7 +291,7 @@ int fs_rename()
int odir, ndir; /* TRUE iff {old|new} file is dir */ int odir, ndir; /* TRUE iff {old|new} file is dir */
int same_pdir; /* TRUE iff parent dirs are the same */ int same_pdir; /* TRUE iff parent dirs are the same */
char old_name[MFS_NAME_MAX], new_name[MFS_NAME_MAX]; char old_name[MFS_NAME_MAX], new_name[MFS_NAME_MAX];
pino_t numb; ino_t numb;
phys_bytes len; phys_bytes len;
/* Copy the last component of the old name */ /* Copy the last component of the old name */
@ -328,7 +328,7 @@ int fs_rename()
} }
/* Get new dir inode */ /* Get new dir inode */
if ((new_dirp = get_inode(fs_dev, (pino_t) fs_m_in.m_vfs_fs_rename.dir_new)) == NULL){ if ((new_dirp = get_inode(fs_dev, fs_m_in.m_vfs_fs_rename.dir_new)) == NULL){
put_inode(old_ip); put_inode(old_ip);
put_inode(old_dirp); put_inode(old_dirp);
return(err_code); return(err_code);
@ -527,7 +527,7 @@ off_t newsize; /* inode must become this size */
* writing is done. * writing is done.
*/ */
int r; int r;
pmode_t file_type; mode_t file_type;
file_type = rip->i_mode & I_TYPE; /* check to see if file is special */ file_type = rip->i_mode & I_TYPE; /* check to see if file is special */
if (file_type == I_CHAR_SPECIAL || file_type == I_BLOCK_SPECIAL) if (file_type == I_CHAR_SPECIAL || file_type == I_BLOCK_SPECIAL)

2
servers/mfs/mount.c
View File

@ -129,7 +129,7 @@ int fs_mountpoint()
*/ */
register struct inode *rip; register struct inode *rip;
int r = OK; int r = OK;
pmode_t bits; mode_t bits;
/* Temporarily open the file. */ /* Temporarily open the file. */
if( (rip = get_inode(fs_dev, fs_m_in.m_vfs_fs_mountpoint.inode)) == NULL) if( (rip = get_inode(fs_dev, fs_m_in.m_vfs_fs_mountpoint.inode)) == NULL)

11
servers/mfs/open.c
View File

@ -7,7 +7,7 @@
#include "super.h" #include "super.h"
#include <minix/vfsif.h> #include <minix/vfsif.h>
static struct inode *new_node(struct inode *ldirp, char *string, pmode_t static struct inode *new_node(struct inode *ldirp, char *string, mode_t
bits, zone_t z0); bits, zone_t z0);
/*===========================================================================* /*===========================================================================*
@ -106,7 +106,7 @@ int fs_mknod()
int fs_mkdir() int fs_mkdir()
{ {
int r1, r2; /* status codes */ int r1, r2; /* status codes */
pino_t dot, dotdot; /* inode numbers for . and .. */ ino_t dot, dotdot; /* inode numbers for . and .. */
struct inode *rip, *ldirp; struct inode *rip, *ldirp;
char lastc[MFS_NAME_MAX]; /* last component */ char lastc[MFS_NAME_MAX]; /* last component */
phys_bytes len; phys_bytes len;
@ -155,7 +155,7 @@ int fs_mkdir()
/* It was not possible to enter . or .. probably disk was full - /* It was not possible to enter . or .. probably disk was full -
* links counts haven't been touched. */ * links counts haven't been touched. */
if(search_dir(ldirp, lastc, NULL, DELETE, IGN_PERM) != OK) if(search_dir(ldirp, lastc, NULL, DELETE, IGN_PERM) != OK)
panic("Dir disappeared: %ul", rip->i_num); panic("Dir disappeared: %llu", rip->i_num);
rip->i_nlinks--; /* undo the increment done in new_node() */ rip->i_nlinks--; /* undo the increment done in new_node() */
} }
IN_MARKDIRTY(rip); /* either way, i_nlinks has changed */ IN_MARKDIRTY(rip); /* either way, i_nlinks has changed */
@ -193,8 +193,7 @@ int fs_slink()
return(EINVAL); return(EINVAL);
/* Create the inode for the symlink. */ /* Create the inode for the symlink. */
sip = new_node(ldirp, string, (pmode_t) (I_SYMBOLIC_LINK | RWX_MODES), sip = new_node(ldirp, string, (I_SYMBOLIC_LINK | RWX_MODES), 0);
(zone_t) 0);
/* Allocate a disk block for the contents of the symlink. /* Allocate a disk block for the contents of the symlink.
* Copy contents of symlink (the name pointed to) into first disk block. */ * Copy contents of symlink (the name pointed to) into first disk block. */
@ -250,7 +249,7 @@ int fs_slink()
* new_node * * new_node *
*===========================================================================*/ *===========================================================================*/
static struct inode *new_node(struct inode *ldirp, static struct inode *new_node(struct inode *ldirp,
char *string, pmode_t bits, zone_t z0) char *string, mode_t bits, zone_t z0)
{ {
/* New_node() is called by fs_open(), fs_mknod(), and fs_mkdir(). /* New_node() is called by fs_open(), fs_mknod(), and fs_mkdir().
* In all cases it allocates a new inode, makes a directory entry for it in * In all cases it allocates a new inode, makes a directory entry for it in

18
servers/mfs/path.c
View File

@ -27,7 +27,7 @@ char dot2[3] = ".."; /* permissions for . and .. */
static char *get_name(char *name, char string[MFS_NAME_MAX+1]); static char *get_name(char *name, char string[MFS_NAME_MAX+1]);
static int ltraverse(struct inode *rip, char *suffix); static int ltraverse(struct inode *rip, char *suffix);
static int parse_path(pino_t dir_ino, pino_t root_ino, int flags, struct static int parse_path(ino_t dir_ino, ino_t root_ino, int flags, struct
inode **res_inop, size_t *offsetp, int *symlinkp); inode **res_inop, size_t *offsetp, int *symlinkp);
@ -121,8 +121,8 @@ int fs_lookup()
* parse_path * * parse_path *
*===========================================================================*/ *===========================================================================*/
static int parse_path( static int parse_path(
pino_t dir_ino, ino_t dir_ino,
pino_t root_ino, ino_t root_ino,
int flags, int flags,
struct inode **res_inop, struct inode **res_inop,
size_t *offsetp, size_t *offsetp,
@ -355,7 +355,7 @@ int chk_perm; /* check permissions when string is looked up*/
* the directory, find the inode, open it, and return a pointer to its inode * the directory, find the inode, open it, and return a pointer to its inode
* slot. * slot.
*/ */
pino_t numb; ino_t numb;
struct inode *rip; struct inode *rip;
/* If 'string' is empty, return an error. */ /* If 'string' is empty, return an error. */
@ -463,7 +463,7 @@ char string[MFS_NAME_MAX+1]; /* component extracted from 'old_name' */
int search_dir(ldir_ptr, string, numb, flag, check_permissions) int search_dir(ldir_ptr, string, numb, flag, check_permissions)
register struct inode *ldir_ptr; /* ptr to inode for dir to search */ register struct inode *ldir_ptr; /* ptr to inode for dir to search */
char string[MFS_NAME_MAX]; /* component to search for */ char string[MFS_NAME_MAX]; /* component to search for */
pino_t *numb; /* pointer to inode number */ ino_t *numb; /* pointer to inode number */
int flag; /* LOOK_UP, ENTER, DELETE or IS_EMPTY */ int flag; /* LOOK_UP, ENTER, DELETE or IS_EMPTY */
int check_permissions; /* check permissions when flag is !IS_EMPTY */ int check_permissions; /* check permissions when flag is !IS_EMPTY */
{ {
@ -479,7 +479,7 @@ int check_permissions; /* check permissions when flag is !IS_EMPTY */
register struct direct *dp = NULL; register struct direct *dp = NULL;
register struct buf *bp = NULL; register struct buf *bp = NULL;
int i, r, e_hit, t, match; int i, r, e_hit, t, match;
pmode_t bits; mode_t bits;
off_t pos; off_t pos;
unsigned new_slots, old_slots; unsigned new_slots, old_slots;
struct super_block *sp; struct super_block *sp;
@ -558,8 +558,8 @@ int check_permissions; /* check permissions when flag is !IS_EMPTY */
if (flag == IS_EMPTY) r = ENOTEMPTY; if (flag == IS_EMPTY) r = ENOTEMPTY;
else if (flag == DELETE) { else if (flag == DELETE) {
/* Save d_ino for recovery. */ /* Save d_ino for recovery. */
t = MFS_NAME_MAX - sizeof(pino_t); t = MFS_NAME_MAX - sizeof(ino_t);
*((pino_t *) &dp->mfs_d_name[t]) = dp->mfs_d_ino; *((ino_t *) &dp->mfs_d_name[t]) = dp->mfs_d_ino;
dp->mfs_d_ino = NO_ENTRY; /* erase entry */ dp->mfs_d_ino = NO_ENTRY; /* erase entry */
MARKDIRTY(bp); MARKDIRTY(bp);
ldir_ptr->i_update |= CTIME | MTIME; ldir_ptr->i_update |= CTIME | MTIME;
@ -568,7 +568,7 @@ int check_permissions; /* check permissions when flag is !IS_EMPTY */
ldir_ptr->i_last_dpos = pos; ldir_ptr->i_last_dpos = pos;
} else { } else {
sp = ldir_ptr->i_sp; /* 'flag' is LOOK_UP */ sp = ldir_ptr->i_sp; /* 'flag' is LOOK_UP */
*numb = (pino_t) conv4(sp->s_native, *numb = (ino_t) conv4(sp->s_native,
(int) dp->mfs_d_ino); (int) dp->mfs_d_ino);
} }
assert(lmfs_dev(bp) != NO_DEV); assert(lmfs_dev(bp) != NO_DEV);

6
servers/mfs/protect.c
View File

@ -14,7 +14,7 @@ int fs_chmod()
/* Perform the chmod(name, mode) system call. */ /* Perform the chmod(name, mode) system call. */
register struct inode *rip; register struct inode *rip;
pmode_t mode; mode_t mode;
mode = fs_m_in.m_vfs_fs_chmod.mode; mode = fs_m_in.m_vfs_fs_chmod.mode;
@ -73,7 +73,7 @@ int fs_chown()
/*===========================================================================* /*===========================================================================*
* forbidden * * forbidden *
*===========================================================================*/ *===========================================================================*/
int forbidden(register struct inode *rip, pmode_t access_desired) int forbidden(struct inode *rip, mode_t access_desired)
{ {
/* Given a pointer to an inode, 'rip', and the access desired, determine /* Given a pointer to an inode, 'rip', and the access desired, determine
* if the access is allowed, and if not why not. The routine looks up the * if the access is allowed, and if not why not. The routine looks up the
@ -82,7 +82,7 @@ int forbidden(register struct inode *rip, pmode_t access_desired)
*/ */
register struct inode *old_rip = rip; register struct inode *old_rip = rip;
register pmode_t bits, perm_bits; mode_t bits, perm_bits;
int r, shift; int r, shift;
/* Isolate the relevant rwx bits from the mode. */ /* Isolate the relevant rwx bits from the mode. */

10
servers/mfs/proto.h
View File

@ -19,12 +19,12 @@ zone_t alloc_zone(dev_t dev, zone_t z);
void free_zone(dev_t dev, zone_t numb); void free_zone(dev_t dev, zone_t numb);
/* inode.c */ /* inode.c */
struct inode *alloc_inode(dev_t dev, pmode_t bits); struct inode *alloc_inode(dev_t dev, mode_t bits);
void dup_inode(struct inode *ip); void dup_inode(struct inode *ip);
struct inode *find_inode(dev_t dev, pino_t numb); struct inode *find_inode(dev_t dev, ino_t numb);
int fs_putnode(void); int fs_putnode(void);
void init_inode_cache(void); void init_inode_cache(void);
struct inode *get_inode(dev_t dev, pino_t numb); struct inode *get_inode(dev_t dev, ino_t numb);
void put_inode(struct inode *rip); void put_inode(struct inode *rip);
void update_times(struct inode *rip); void update_times(struct inode *rip);
void rw_inode(struct inode *rip, int rw_flag); void rw_inode(struct inode *rip, int rw_flag);
@ -59,7 +59,7 @@ int fs_slink(void);
int fs_lookup(void); int fs_lookup(void);
struct inode *advance(struct inode *dirp, char string[MFS_NAME_MAX], int struct inode *advance(struct inode *dirp, char string[MFS_NAME_MAX], int
chk_perm); chk_perm);
int search_dir(struct inode *ldir_ptr, char string [MFS_NAME_MAX], pino_t int search_dir(struct inode *ldir_ptr, char string [MFS_NAME_MAX], ino_t
*numb, int flag, int check_permissions); *numb, int flag, int check_permissions);
@ -67,7 +67,7 @@ int search_dir(struct inode *ldir_ptr, char string [MFS_NAME_MAX], pino_t
int fs_chmod(void); int fs_chmod(void);
int fs_chown(void); int fs_chown(void);
int fs_getdents(void); int fs_getdents(void);
int forbidden(struct inode *rip, pmode_t access_desired); int forbidden(struct inode *rip, mode_t access_desired);
int read_only(struct inode *ip); int read_only(struct inode *ip);
/* read.c */ /* read.c */

4
servers/mfs/read.c
View File

@ -38,7 +38,7 @@ int fs_readwrite(void)
r = OK; r = OK;
/* Find the inode referred */ /* Find the inode referred */
if ((rip = find_inode(fs_dev, (pino_t) fs_m_in.m_vfs_fs_readwrite.inode)) == NULL) if ((rip = find_inode(fs_dev, fs_m_in.m_vfs_fs_readwrite.inode)) == NULL)
return(EINVAL); return(EINVAL);
mode_word = rip->i_mode & I_TYPE; mode_word = rip->i_mode & I_TYPE;
@ -608,7 +608,7 @@ int fs_getdents(void)
register struct inode *rip; register struct inode *rip;
int o, r, done; int o, r, done;
unsigned int block_size, len, reclen; unsigned int block_size, len, reclen;
pino_t ino; ino_t ino;
cp_grant_id_t gid; cp_grant_id_t gid;
size_t size, tmpbuf_off, userbuf_off; size_t size, tmpbuf_off, userbuf_off;
off_t pos, off, block_pos, new_pos, ent_pos; off_t pos, off, block_pos, new_pos, ent_pos;

2
servers/mfs/stadir.c
View File

@ -50,7 +50,7 @@ static int stat_inode(
/* Common code for stat and fstat system calls. */ /* Common code for stat and fstat system calls. */
struct stat statbuf; struct stat statbuf;
pmode_t mo; mode_t mo;
int r, s; int r, s;
/* Update the atime, ctime, and mtime fields in the inode, if need be. */ /* Update the atime, ctime, and mtime fields in the inode, if need be. */

2
servers/mfs/super.c
View File

@ -273,7 +273,7 @@ int read_super(struct super_block *sp)
/* If the super block has the wrong byte order, swap the fields; the magic /* If the super block has the wrong byte order, swap the fields; the magic
* number doesn't need conversion. */ * number doesn't need conversion. */
sp->s_ninodes = (pino_t) conv4(native, (int) sp->s_ninodes); sp->s_ninodes = (ino_t) conv4(native, (int) sp->s_ninodes);
sp->s_nzones = (zone1_t) conv2(native, (int) sp->s_nzones); sp->s_nzones = (zone1_t) conv2(native, (int) sp->s_nzones);
sp->s_imap_blocks = (short) conv2(native, (int) sp->s_imap_blocks); sp->s_imap_blocks = (short) conv2(native, (int) sp->s_imap_blocks);
sp->s_zmap_blocks = (short) conv2(native, (int) sp->s_zmap_blocks); sp->s_zmap_blocks = (short) conv2(native, (int) sp->s_zmap_blocks);

2
servers/pfs/buf.h
View File

@ -11,7 +11,7 @@ struct buf {
/* Header portion of the buffer. */ /* Header portion of the buffer. */
struct buf *b_next; /* used to link all free bufs in a chain */ struct buf *b_next; /* used to link all free bufs in a chain */
struct buf *b_prev; /* used to link all free bufs the other way */ struct buf *b_prev; /* used to link all free bufs the other way */
pino_t b_num; /* inode number on minor device */ ino_t b_num; /* inode number on minor device */
dev_t b_dev; /* major | minor device where block resides */ dev_t b_dev; /* major | minor device where block resides */
int b_bytes; /* Number of bytes allocated in bp */ int b_bytes; /* Number of bytes allocated in bp */
int b_count; /* Number of users of this buffer */ int b_count; /* Number of users of this buffer */

8
servers/pfs/buffer.c
View File

@ -5,7 +5,7 @@
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
static struct buf *new_block(dev_t dev, pino_t inum); static struct buf *new_block(dev_t dev, ino_t inum);
/*===========================================================================* /*===========================================================================*
* buf_pool * * buf_pool *
@ -23,7 +23,7 @@ void buf_pool(void)
/*===========================================================================* /*===========================================================================*
* get_block * * get_block *
*===========================================================================*/ *===========================================================================*/
struct buf *get_block(dev_t dev, pino_t inum) struct buf *get_block(dev_t dev, ino_t inum)
{ {
struct buf *bp = front; struct buf *bp = front;
@ -43,7 +43,7 @@ struct buf *get_block(dev_t dev, pino_t inum)
/*===========================================================================* /*===========================================================================*
* new_block * * new_block *
*===========================================================================*/ *===========================================================================*/
static struct buf *new_block(dev_t dev, pino_t inum) static struct buf *new_block(dev_t dev, ino_t inum)
{ {
/* Allocate a new buffer and add it to the double linked buffer list */ /* Allocate a new buffer and add it to the double linked buffer list */
struct buf *bp; struct buf *bp;
@ -77,7 +77,7 @@ static struct buf *new_block(dev_t dev, pino_t inum)
/*===========================================================================* /*===========================================================================*
* put_block * * put_block *
*===========================================================================*/ *===========================================================================*/
void put_block(dev_t dev, pino_t inum) void put_block(dev_t dev, ino_t inum)
{ {
struct buf *bp; struct buf *bp;

14
servers/pfs/inode.c
View File

@ -38,7 +38,7 @@ int fs_putnode(message *fs_m_in, message *fs_m_out)
rip = find_inode(fs_m_in->m_vfs_fs_putnode.inode); rip = find_inode(fs_m_in->m_vfs_fs_putnode.inode);
if(!rip) { if(!rip) {
printf("%s:%d put_inode: inode #%ld not found\n", __FILE__, printf("%s:%d put_inode: inode #%llu not found\n", __FILE__,
__LINE__, fs_m_in->m_vfs_fs_putnode.inode); __LINE__, fs_m_in->m_vfs_fs_putnode.inode);
panic("fs_putnode failed"); panic("fs_putnode failed");
} }
@ -119,7 +119,7 @@ static void unhash_inode(struct inode * const node)
*===========================================================================*/ *===========================================================================*/
struct inode *get_inode( struct inode *get_inode(
dev_t dev, /* device on which inode resides */ dev_t dev, /* device on which inode resides */
pino_t numb /* inode number */ ino_t numb /* inode number */
) )
{ {
/* Find the inode in the hash table. If it is not there, get a free inode /* Find the inode in the hash table. If it is not there, get a free inode
@ -173,7 +173,7 @@ struct inode *get_inode(
/*===========================================================================* /*===========================================================================*
* find_inode * * find_inode *
*===========================================================================*/ *===========================================================================*/
struct inode *find_inode(pino_t numb /* inode number */) struct inode *find_inode(ino_t numb /* inode number */)
{ {
/* Find the inode specified by the inode and device number. /* Find the inode specified by the inode and device number.
*/ */
@ -237,13 +237,13 @@ struct inode *rip; /* pointer to inode to be released */
/*===========================================================================* /*===========================================================================*
* alloc_inode * * alloc_inode *
*===========================================================================*/ *===========================================================================*/
struct inode *alloc_inode(dev_t dev, pmode_t bits, uid_t uid, gid_t gid) struct inode *alloc_inode(dev_t dev, mode_t bits, uid_t uid, gid_t gid)
{ {
/* Allocate a free inode on 'dev', and return a pointer to it. */ /* Allocate a free inode on 'dev', and return a pointer to it. */
register struct inode *rip; register struct inode *rip;
bit_t b; bit_t b;
pino_t i_num; ino_t i_num;
int print_oos_msg = 1; int print_oos_msg = 1;
b = alloc_bit(); b = alloc_bit();
@ -254,7 +254,7 @@ struct inode *alloc_inode(dev_t dev, pmode_t bits, uid_t uid, gid_t gid)
print_oos_msg = 0; /* Don't repeat message */ print_oos_msg = 0; /* Don't repeat message */
return(NULL); return(NULL);
} }
i_num = (pino_t) b; i_num = (ino_t) b;
print_oos_msg = 1; print_oos_msg = 1;
@ -308,7 +308,7 @@ struct inode *rip;
bit_t b; bit_t b;
if (rip->i_num <= (pino_t) 0 || rip->i_num >= (pino_t) PFS_NR_INODES) return; if (rip->i_num <= 0 || rip->i_num >= PFS_NR_INODES) return;
b = (bit_t) rip->i_num; b = (bit_t) rip->i_num;
free_bit(b); free_bit(b);
} }

2
servers/pfs/inode.h
View File

@ -7,7 +7,7 @@
#include <sys/queue.h> #include <sys/queue.h>
EXTERN struct inode { EXTERN struct inode {
pmode_t i_mode; /* file type, protection, etc. */ mode_t i_mode; /* file type, protection, etc. */
nlink_t i_nlinks; /* how many links to this file */ nlink_t i_nlinks; /* how many links to this file */
uid_t i_uid; /* user id of the file's owner */ uid_t i_uid; /* user id of the file's owner */
gid_t i_gid; /* group number */ gid_t i_gid; /* group number */

10
servers/pfs/proto.h
View File

@ -8,20 +8,20 @@ struct buf;
struct inode; struct inode;
/* buffer.c */ /* buffer.c */
struct buf *get_block(dev_t dev, pino_t inum); struct buf *get_block(dev_t dev, ino_t inum);
void put_block(dev_t dev, pino_t inum); void put_block(dev_t dev, ino_t inum);
/* cache.c */ /* cache.c */
void buf_pool(void); void buf_pool(void);
/* inode.c */ /* inode.c */
struct inode *alloc_inode(dev_t dev, pmode_t mode, uid_t uid, gid_t gid); struct inode *alloc_inode(dev_t dev, mode_t mode, uid_t uid, gid_t gid);
void dup_inode(struct inode *ip); void dup_inode(struct inode *ip);
struct inode *find_inode(pino_t numb); struct inode *find_inode(ino_t numb);
void free_inode(struct inode *rip); void free_inode(struct inode *rip);
int fs_putnode(message *fs_m_in, message *fs_m_out); int fs_putnode(message *fs_m_in, message *fs_m_out);
void init_inode_cache(void); void init_inode_cache(void);
struct inode *get_inode(dev_t dev, pino_t numb); struct inode *get_inode(dev_t dev, ino_t numb);
void put_inode(struct inode *rip); void put_inode(struct inode *rip);
void update_times(struct inode *rip); void update_times(struct inode *rip);
void wipe_inode(struct inode *rip); void wipe_inode(struct inode *rip);

6
servers/pfs/read.c
View File

@ -14,7 +14,7 @@ int fs_readwrite(message *fs_m_in, message *fs_m_out)
struct buf *bp; struct buf *bp;
cp_grant_id_t gid; cp_grant_id_t gid;
off_t position, f_size; off_t position, f_size;
unsigned int nrbytes, cum_io; size_t nrbytes, cum_io;
mode_t mode_word; mode_t mode_word;
struct inode *rip; struct inode *rip;
ino_t inumb; ino_t inumb;
@ -33,7 +33,7 @@ int fs_readwrite(message *fs_m_in, message *fs_m_out)
/* Get the values from the request message */ /* Get the values from the request message */
rw_flag = (fs_m_in->m_type == REQ_READ ? READING : WRITING); rw_flag = (fs_m_in->m_type == REQ_READ ? READING : WRITING);
gid = fs_m_in->m_vfs_fs_readwrite.grant; gid = fs_m_in->m_vfs_fs_readwrite.grant;
nrbytes = (unsigned) fs_m_in->m_vfs_fs_readwrite.nbytes; nrbytes = fs_m_in->m_vfs_fs_readwrite.nbytes;
/* We can't read beyond the max file position */ /* We can't read beyond the max file position */
if (nrbytes > PIPE_BUF) return(EFBIG); if (nrbytes > PIPE_BUF) return(EFBIG);
@ -87,7 +87,7 @@ int fs_readwrite(message *fs_m_in, message *fs_m_out)
if (rw_flag == WRITING) rip->i_update |= CTIME | MTIME; if (rw_flag == WRITING) rip->i_update |= CTIME | MTIME;
} }
fs_m_out->m_fs_vfs_readwrite.nbytes = (size_t) cum_io; fs_m_out->m_fs_vfs_readwrite.nbytes = cum_io;
fs_m_out->m_fs_vfs_readwrite.seek_pos = rip->i_size; fs_m_out->m_fs_vfs_readwrite.seek_pos = rip->i_size;
put_inode(rip); put_inode(rip);

2
servers/pfs/stadir.c
View File

@ -14,7 +14,7 @@ static int stat_inode(
) )
{ {
/* Common code for stat and fstat system calls. */ /* Common code for stat and fstat system calls. */
pmode_t type; mode_t type;
struct stat statbuf; struct stat statbuf;
u32_t blocks; /* The unit of this is 512 */ u32_t blocks; /* The unit of this is 512 */
int r, s; int r, s;

2
servers/procfs/type.h
View File

@ -68,7 +68,7 @@ struct load {
*/ */
struct file { struct file {
char *name; /* file name, maximum length PNAME_MAX */ char *name; /* file name, maximum length PNAME_MAX */
pmode_t mode; /* file mode, including file type */ mode_t mode; /* file mode, including file type */
data_t data; /* custom data associated with this file */ data_t data; /* custom data associated with this file */
}; };

2
servers/vfs/request.c
View File

@ -828,7 +828,7 @@ int req_readsuper(
*===========================================================================*/ *===========================================================================*/
static int req_readwrite_actual(endpoint_t fs_e, ino_t inode_nr, off_t pos, static int req_readwrite_actual(endpoint_t fs_e, ino_t inode_nr, off_t pos,
int rw_flag, endpoint_t user_e, vir_bytes user_addr, int rw_flag, endpoint_t user_e, vir_bytes user_addr,
unsigned int num_of_bytes, off_t *new_posp, unsigned int *cum_iop, unsigned int num_of_bytes, off_t *new_posp, size_t *cum_iop,
int cpflag) int cpflag)
{ {
struct vmnt *vmp; struct vmnt *vmp;