sanchayanmaity/minix
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages 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];
} 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 */
#define REQ_GETNODE (FS_BASE + 1) /* Should be removed */
#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 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);
/*===========================================================================*
@ -129,8 +129,8 @@ int fs_lookup(void)
* parse_path *
*===========================================================================*/
static int parse_path(
pino_t dir_ino,
pino_t root_ino,
ino_t dir_ino,
ino_t root_ino,
int flags,
struct puffs_node **res_inop,
size_t *offsetp,

2
lib/libsffs/inode.c
View file

@ -65,7 +65,7 @@ struct inode *init_inode(void)
/*===========================================================================*
* 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.
*/

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.
* Return OK or an appropriate error code.
*/
pmode_t mode;
mode_t 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 */
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 put_inode(struct inode *ino);
void link_inode(struct inode *parent, struct inode *ino);
@ -57,7 +57,7 @@ int do_read(void);
int do_getdents(void);
/* 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_chmod(void);
int do_utime(void);

4
lib/libsffs/stat.c
View file

@ -15,7 +15,7 @@
/*===========================================================================*
* 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.
*/
@ -45,7 +45,7 @@ int do_stat(void)
struct sffs_attr attr;
struct stat stat;
char path[PATH_MAX];
pino_t ino_nr;
ino_t ino_nr;
int r;
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 *
*===========================================================================*/
struct inode *find_inode(pino_t num)
struct inode *find_inode(ino_t num)
{
/* Retrieve an inode by inode number.
*/
@ -442,7 +442,7 @@ struct inode *find_inode(pino_t num)
/*===========================================================================*
* 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.
*/

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.
* Return OK or an appropriate error code.
*/
pmode_t mask;
mode_t mask;
int i;
/* 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
nr_indexed_entries);
void cleanup_inodes(void);
struct inode *find_inode(pino_t num);
struct inode *get_inode(pino_t num);
struct inode *find_inode(ino_t num);
struct inode *get_inode(ino_t num);
void put_inode(struct inode *node);
void ref_inode(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 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 START_BLOCK ((block_t) 2) /* first block of FS (not counting SB) */
#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 *
*===========================================================================*/
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. */
@ -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 group;
pino_t inumber = NO_BIT;
ino_t inumber = NO_BIT;
bit_t bit;
struct buf *bp;
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(
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
@ -198,7 +198,7 @@ struct inode *get_inode(
*===========================================================================*/
struct inode *find_inode(
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. */

2
servers/ext2/inode.h
View file

@ -71,7 +71,7 @@ EXTERN struct inode {
/* The following items are not present on the disk. */
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 */
struct super_block *i_sp; /* pointer to super block for inode's device */
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. */
pino_t numb; /* inode number */
ino_t numb; /* inode number */
int r;
/* 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 same_pdir = 0; /* TRUE iff parent dirs are the same */
char old_name[NAME_MAX + 1], new_name[NAME_MAX + 1];
pino_t numb;
ino_t numb;
phys_bytes len;
/* Copy the last component of the old name */
@ -334,7 +334,7 @@ int fs_rename()
NUL(new_name, len, sizeof(new_name));
/* 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);
old_ip = advance(old_dirp, old_name, IGN_PERM);
@ -350,7 +350,7 @@ int fs_rename()
}
/* 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_dirp);
return(err_code);
@ -483,7 +483,7 @@ int fs_rename()
r = search_dir(new_dirp, new_name, &numb, ENTER, IGN_PERM,
old_ip->i_mode & I_TYPE);
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);
}
}
@ -551,7 +551,7 @@ off_t newsize; /* inode must become this size */
* writing is done.
*/
int r;
pmode_t file_type;
mode_t file_type;
discard_preallocated_blocks(rip);

9
servers/ext2/open.c
View file

@ -12,7 +12,7 @@
#include "super.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);
@ -118,7 +118,7 @@ int fs_mknod()
int fs_mkdir()
{
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;
char lastc[NAME_MAX + 1]; /* last component */
phys_bytes len;
@ -213,8 +213,7 @@ int fs_slink()
return(EINVAL);
/* Create the inode for the symlink. */
sip = new_node(ldirp, string, (pmode_t) (I_SYMBOLIC_LINK | RWX_MODES),
(block_t) 0);
sip = new_node(ldirp, string, (I_SYMBOLIC_LINK | RWX_MODES), 0);
/* If we can then create fast symlink (store it in inode),
* Otherwise allocate a disk block for the contents of the symlink and
@ -278,7 +277,7 @@ int fs_slink()
* new_node *
*===========================================================================*/
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().
* 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 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);
/*===========================================================================*
@ -41,7 +41,7 @@ int fs_lookup()
int r, r1, flags, symlinks;
unsigned int len;
size_t offset = 0, path_size;
pino_t dir_ino, root_ino;
ino_t dir_ino, root_ino;
struct inode *rip;
grant = fs_m_in.m_vfs_fs_lookup.grant_path;
@ -121,8 +121,8 @@ int fs_lookup()
* parse_path *
*===========================================================================*/
static int parse_path(dir_ino, root_ino, flags, res_inop, offsetp, symlinkp)
pino_t dir_ino;
pino_t root_ino;
ino_t dir_ino;
ino_t root_ino;
int flags;
struct inode **res_inop;
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
* slot.
*/
pino_t numb;
ino_t numb;
struct inode *rip;
/* 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)
register struct inode *ldir_ptr; /* ptr to inode for dir to search */
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 check_permissions; /* check permissions when flag is !IS_EMPTY */
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 buf *bp = NULL;
int i, r, e_hit, t, match;
pmode_t bits;
mode_t bits;
off_t pos;
unsigned new_slots;
int extended = 0;
@ -576,10 +576,10 @@ int ftype; /* used when ENTER and
r = OK;
if (flag == IS_EMPTY) r = ENOTEMPTY;
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. */
t = dp->d_name_len - sizeof(pino_t);
*((pino_t *) &dp->d_name[t])= dp->d_ino;
t = dp->d_name_len - sizeof(ino_t);
*((ino_t *) &dp->d_name[t])= dp->d_ino;
}
dp->d_ino = NO_ENTRY; /* erase entry */
lmfs_markdirty(bp);
@ -619,7 +619,7 @@ int ftype; /* used when ENTER and
}
} else {
/* '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);
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. */
register struct inode *rip;
pmode_t mode;
mode_t mode;
mode = fs_m_in.m_vfs_fs_chmod.mode;
@ -72,7 +72,7 @@ int fs_chown()
/*===========================================================================*
* 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
* 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 pmode_t bits, perm_bits;
mode_t bits, perm_bits;
int r, shift;
/* 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);
/* 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);
/* inode.c */
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);
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 update_times(struct inode *rip);
void rw_inode(struct inode *rip, int rw_flag);
@ -62,14 +62,14 @@ int fs_slink(void);
int fs_lookup(void);
struct inode *advance(struct inode *dirp, char string[NAME_MAX + 1], int
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);
/* protect.c */
int fs_chmod(void);
int fs_chown(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);
/* 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. */
struct stat statbuf;
pmode_t mo;
mode_t mo;
int r, s;
/* 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 *
*===========================================================================*/
struct dir_record *get_dir_record(id_dir_record)
pino_t id_dir_record;
ino_t id_dir_record;
{
struct dir_record *dir = NULL;
u32_t address;
@ -209,8 +209,8 @@ u32_t address;
/* Set physical address of the dir record */
dir->d_phy_addr = address;
dir->d_ino_nr = (pino_t) address; /* u32_t e ino_t are the same datatype so
* the cast is safe */
dir->d_ino_nr = address;
return(OK);
}

4
servers/iso9660fs/inode.h
View file

@ -18,10 +18,10 @@ struct dir_record {
/* Memory attrs */
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 */
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 */
struct dir_record *d_next; /* In case the file consists in more file sections
this points to the next one */

12
servers/iso9660fs/path.c
View file

@ -6,7 +6,7 @@
#include "buf.h"
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);
@ -82,7 +82,7 @@ int fs_lookup() {
int search_dir(
register struct dir_record *ldir_ptr, /* dir record parent */
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;
register struct buf *bp;
@ -182,8 +182,8 @@ int search_dir(
* parse_path *
*===========================================================================*/
static int parse_path(
pino_t dir_ino,
pino_t root_ino,
ino_t dir_ino,
ino_t root_ino,
int flags,
struct dir_record **res_inop,
size_t *offsetp
@ -195,7 +195,7 @@ size_t *offsetp
/* Find starting inode inode according to the request message */
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);
}
@ -292,7 +292,7 @@ struct dir_record **resp; /* resulting inode */
register struct dir_record *rip = NULL;
int r;
pino_t numb;
ino_t numb;
/* If 'string' is empty, yield same inode straight away. */
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 fs_getnode(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 ext_attr_rec *get_free_ext_attr(void);
struct dir_record *load_dir_record_from_disk(u32_t address);
@ -38,7 +38,7 @@ int fs_unmount(void);
int fs_lookup(void);
int advance(struct dir_record *dirp, char string[NAME_MAX], struct
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 */
int fs_read(void);

2
servers/iso9660fs/read.c
View file

@ -143,7 +143,7 @@ int fs_bread(void)
int fs_getdents(void)
{
struct dir_record *dir;
pino_t ino;
ino_t ino;
cp_grant_id_t gid;
size_t block_size;
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 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 SUPER_BLOCK_BYTES (1024) /* bytes offset */
#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 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,
int norm);
static void unhash_inode(struct inode *node);
@ -123,7 +123,7 @@ static void unhash_inode(struct inode *node)
*===========================================================================*/
struct inode *get_inode(
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
@ -185,7 +185,7 @@ struct inode *get_inode(
*===========================================================================*/
struct inode *find_inode(
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.
@ -255,7 +255,7 @@ register struct inode *rip; /* pointer to inode to be released */
/*===========================================================================*
* 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. */
@ -333,7 +333,7 @@ register struct inode *rip; /* the inode to be erased */
*===========================================================================*/
static void free_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. */
@ -428,7 +428,7 @@ int norm; /* TRUE = do not swap bytes; FALSE = swap */
if (direction == READING) {
/* 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_nlinks = (nlink_t) conv2(norm,dip->d2_nlinks);
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. */
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 */
unsigned int i_ndzones; /* # direct zones (Vx_NR_DZONES) */
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. */
pino_t numb; /* inode number */
ino_t numb; /* inode number */
int r;
/* 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 same_pdir; /* TRUE iff parent dirs are the same */
char old_name[MFS_NAME_MAX], new_name[MFS_NAME_MAX];
pino_t numb;
ino_t numb;
phys_bytes len;
/* Copy the last component of the old name */
@ -328,7 +328,7 @@ int fs_rename()
}
/* 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_dirp);
return(err_code);
@ -527,7 +527,7 @@ off_t newsize; /* inode must become this size */
* writing is done.
*/
int r;
pmode_t file_type;
mode_t file_type;
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)

2
servers/mfs/mount.c
View file

@ -129,7 +129,7 @@ int fs_mountpoint()
*/
register struct inode *rip;
int r = OK;
pmode_t bits;
mode_t bits;
/* Temporarily open the file. */
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 <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);
/*===========================================================================*
@ -106,7 +106,7 @@ int fs_mknod()
int fs_mkdir()
{
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;
char lastc[MFS_NAME_MAX]; /* last component */
phys_bytes len;
@ -155,7 +155,7 @@ int fs_mkdir()
/* It was not possible to enter . or .. probably disk was full -
* links counts haven't been touched. */
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() */
}
IN_MARKDIRTY(rip); /* either way, i_nlinks has changed */
@ -193,8 +193,7 @@ int fs_slink()
return(EINVAL);
/* Create the inode for the symlink. */
sip = new_node(ldirp, string, (pmode_t) (I_SYMBOLIC_LINK | RWX_MODES),
(zone_t) 0);
sip = new_node(ldirp, string, (I_SYMBOLIC_LINK | RWX_MODES), 0);
/* Allocate a disk block for the contents of the symlink.
* Copy contents of symlink (the name pointed to) into first disk block. */
@ -250,7 +249,7 @@ int fs_slink()
* new_node *
*===========================================================================*/
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().
* 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 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);
@ -121,8 +121,8 @@ int fs_lookup()
* parse_path *
*===========================================================================*/
static int parse_path(
pino_t dir_ino,
pino_t root_ino,
ino_t dir_ino,
ino_t root_ino,
int flags,
struct inode **res_inop,
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
* slot.
*/
pino_t numb;
ino_t numb;
struct inode *rip;
/* 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)
register struct inode *ldir_ptr; /* ptr to inode for dir to search */
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 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 buf *bp = NULL;
int i, r, e_hit, t, match;
pmode_t bits;
mode_t bits;
off_t pos;
unsigned new_slots, old_slots;
struct super_block *sp;
@ -558,8 +558,8 @@ int check_permissions; /* check permissions when flag is !IS_EMPTY */
if (flag == IS_EMPTY) r = ENOTEMPTY;
else if (flag == DELETE) {
/* Save d_ino for recovery. */
t = MFS_NAME_MAX - sizeof(pino_t);
*((pino_t *) &dp->mfs_d_name[t]) = dp->mfs_d_ino;
t = MFS_NAME_MAX - sizeof(ino_t);
*((ino_t *) &dp->mfs_d_name[t]) = dp->mfs_d_ino;
dp->mfs_d_ino = NO_ENTRY; /* erase entry */
MARKDIRTY(bp);
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;
} else {
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);
}
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. */
register struct inode *rip;
pmode_t mode;
mode_t mode;
mode = fs_m_in.m_vfs_fs_chmod.mode;
@ -73,7 +73,7 @@ int fs_chown()
/*===========================================================================*
* 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
* 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 pmode_t bits, perm_bits;
mode_t bits, perm_bits;
int r, shift;
/* 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);
/* 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);
struct inode *find_inode(dev_t dev, pino_t numb);
struct inode *find_inode(dev_t dev, ino_t numb);
int fs_putnode(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 update_times(struct inode *rip);
void rw_inode(struct inode *rip, int rw_flag);
@ -59,7 +59,7 @@ int fs_slink(void);
int fs_lookup(void);
struct inode *advance(struct inode *dirp, char string[MFS_NAME_MAX], int
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);
@ -67,7 +67,7 @@ int search_dir(struct inode *ldir_ptr, char string [MFS_NAME_MAX], pino_t
int fs_chmod(void);
int fs_chown(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);
/* read.c */

4
servers/mfs/read.c
View file

@ -38,7 +38,7 @@ int fs_readwrite(void)
r = OK;
/* 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);
mode_word = rip->i_mode & I_TYPE;
@ -608,7 +608,7 @@ int fs_getdents(void)
register struct inode *rip;
int o, r, done;
unsigned int block_size, len, reclen;
pino_t ino;
ino_t ino;
cp_grant_id_t gid;
size_t size, tmpbuf_off, userbuf_off;
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. */
struct stat statbuf;
pmode_t mo;
mode_t mo;
int r, s;
/* 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
* 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_imap_blocks = (short) conv2(native, (int) sp->s_imap_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. */
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 */
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 */
int b_bytes; /* Number of bytes allocated in bp */
int b_count; /* Number of users of this buffer */

8
servers/pfs/buffer.c
View file

@ -5,7 +5,7 @@
#include <stdlib.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 *
@ -23,7 +23,7 @@ void buf_pool(void)
/*===========================================================================*
* 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;
@ -43,7 +43,7 @@ struct buf *get_block(dev_t dev, pino_t inum)
/*===========================================================================*
* 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 */
struct buf *bp;
@ -77,7 +77,7 @@ static struct buf *new_block(dev_t dev, pino_t inum)
/*===========================================================================*
* put_block *
*===========================================================================*/
void put_block(dev_t dev, pino_t inum)
void put_block(dev_t dev, ino_t inum)
{
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);
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);
panic("fs_putnode failed");
}
@ -119,7 +119,7 @@ static void unhash_inode(struct inode * const node)
*===========================================================================*/
struct inode *get_inode(
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
@ -173,7 +173,7 @@ struct inode *get_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.
*/
@ -237,13 +237,13 @@ struct inode *rip; /* pointer to inode to be released */
/*===========================================================================*
* 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. */
register struct inode *rip;
bit_t b;
pino_t i_num;
ino_t i_num;
int print_oos_msg = 1;
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 */
return(NULL);
}
i_num = (pino_t) b;
i_num = (ino_t) b;
print_oos_msg = 1;
@ -308,7 +308,7 @@ struct inode *rip;
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;
free_bit(b);
}

2
servers/pfs/inode.h
View file

@ -7,7 +7,7 @@
#include <sys/queue.h>
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 */
uid_t i_uid; /* user id of the file's owner */
gid_t i_gid; /* group number */

10
servers/pfs/proto.h
View file

@ -8,20 +8,20 @@ struct buf;
struct inode;
/* buffer.c */
struct buf *get_block(dev_t dev, pino_t inum);
void put_block(dev_t dev, pino_t inum);
struct buf *get_block(dev_t dev, ino_t inum);
void put_block(dev_t dev, ino_t inum);
/* cache.c */
void buf_pool(void);
/* 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);
struct inode *find_inode(pino_t numb);
struct inode *find_inode(ino_t numb);
void free_inode(struct inode *rip);
int fs_putnode(message *fs_m_in, message *fs_m_out);
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 update_times(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;
cp_grant_id_t gid;
off_t position, f_size;
unsigned int nrbytes, cum_io;
size_t nrbytes, cum_io;
mode_t mode_word;
struct inode *rip;
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 */
rw_flag = (fs_m_in->m_type == REQ_READ ? READING : WRITING);
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 */
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;
}
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;
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. */
pmode_t type;
mode_t type;
struct stat statbuf;
u32_t blocks; /* The unit of this is 512 */
int r, s;

2
servers/procfs/type.h
View file

@ -68,7 +68,7 @@ struct load {
*/
struct file {
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 */
};

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,
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)
{
struct vmnt *vmp;