if (input(buf, 80)) ip->i_mode = atoo(buf);
printf(" nlinks = %6u", ip->i_nlinks);
if (input(buf, 80)) ip->i_nlinks = atol(buf);
- printf(" size = %6ld", ip->i_size);
+ printf(" size = %6d", ip->i_size);
if (input(buf, 80)) ip->i_size = atol(buf);
if (yes("Write this back")) {
devwrite(inoblock(ino), inooff(ino), (char *) ip,
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 (VFS_BASE + 1) /* Should be removed */
#define REQ_PUTNODE (VFS_BASE + 2)
*/
struct puffs_node *pn;
int count = fs_m_in.REQ_COUNT;
- ino_t inum = fs_m_in.REQ_INODE_NR;
+ pino_t inum = fs_m_in.REQ_INODE_NR;
if ((pn = puffs_pn_nodewalk(global_pu, 0, &inum)) == NULL) {
/* XXX Probably removed from the list, see puffs_pn_remove() */
*/
int r = OK;
struct puffs_node *pn;
- mode_t bits;
+ pmode_t bits;
/*
* XXX: we assume that lookup was done first, so pnode can be found with
int r;
struct puffs_node *pn_dir;
struct puffs_node *pn;
- mode_t omode;
+ pmode_t omode;
struct puffs_newinfo pni;
struct puffs_kcn pkcnp;
PUFFS_MAKECRED(pcr, &global_kcred);
}
/* Read request message */
- omode = (mode_t) fs_m_in.REQ_MODE;
+ omode = (pmode_t) fs_m_in.REQ_MODE;
caller_uid = (uid_t) fs_m_in.REQ_UID;
caller_gid = (gid_t) fs_m_in.REQ_GID;
memset(&va, 0, sizeof(va));
va.va_type = VREG;
- va.va_mode = omode;
+ va.va_mode = (mode_t) omode;
va.va_uid = caller_uid;
va.va_gid = caller_gid;
va.va_atime = va.va_mtime = va.va_ctime = cur_time;
static char *get_name(char *name, char string[NAME_MAX+1]);
static int ltraverse(struct puffs_node *pn, char *suffix);
-static int parse_path(ino_t dir_ino, ino_t root_ino, int flags, struct
+static int parse_path(pino_t dir_ino, pino_t root_ino, int flags, struct
puffs_node **res_inop, size_t *offsetp, int *symlinkp);
/*===========================================================================*
int r, r1, flags, symlinks;
unsigned int len;
size_t offset = 0, path_size;
- ino_t dir_ino, root_ino;
+ pino_t dir_ino, root_ino;
struct puffs_node *pn;
grant = (cp_grant_id_t) fs_m_in.REQ_GRANT;
path_size = (size_t) fs_m_in.REQ_PATH_SIZE; /* Size of the buffer */
len = (int) fs_m_in.REQ_PATH_LEN; /* including terminating nul */
- dir_ino = (ino_t) fs_m_in.REQ_DIR_INO;
- root_ino = (ino_t) fs_m_in.REQ_ROOT_INO;
+ dir_ino = (pino_t) fs_m_in.REQ_DIR_INO;
+ root_ino = (pino_t) fs_m_in.REQ_ROOT_INO;
flags = (int) fs_m_in.REQ_FLAGS;
/* Check length. */
/*===========================================================================*
* parse_path *
*===========================================================================*/
-static int parse_path(dir_ino, root_ino, flags, res_inop, offsetp, symlinkp)
-ino_t dir_ino;
-ino_t root_ino;
-int flags;
-struct puffs_node **res_inop;
-size_t *offsetp;
-int *symlinkp;
-{
+static int parse_path(
+pino_t dir_ino,
+pino_t root_ino,
+int flags,
+struct puffs_node **res_inop,
+size_t *offsetp,
+int *symlinkp
+) {
/* Parse the path in user_path, starting at dir_ino. If the path is the empty
* string, just return dir_ino. It is upto the caller to treat an empty
* path in a special way. Otherwise, if the path consists of just one or
{
int r;
register struct puffs_node *pn;
- ino_t ino;
+ pino_t ino;
cp_grant_id_t gid;
size_t size, buf_left;
off_t pos;
size_t written;
PUFFS_MAKECRED(pcr, &global_kcred);
- ino = (ino_t) fs_m_in.REQ_INODE_NR;
- gid = (gid_t) fs_m_in.REQ_GRANT;
+ ino = (pino_t) fs_m_in.REQ_INODE_NR;
+ gid = (cp_grant_id_t) fs_m_in.REQ_GRANT;
size = buf_left = (size_t) fs_m_in.REQ_MEM_SIZE;
pos = (off_t) fs_m_in.REQ_SEEK_POS_LO;
register struct puffs_node *pn; /* target pnode */
struct vattr va;
struct stat statbuf;
- mode_t mo;
+ pmode_t mo;
int s;
PUFFS_MAKECRED(pcr, &global_kcred);
/*===========================================================================*
* find_inode *
*===========================================================================*/
-struct inode *find_inode(ino_nr)
-ino_t ino_nr;
+struct inode *find_inode(pino_t ino_nr)
{
/* Get an inode based on its inode number. Do not increase its reference count.
*/
/* Check whether the given inode may be accessed as directory.
* Return OK or an appropriate error code.
*/
- mode_t mode;
+ pmode_t mode;
assert(attr->a_mask & SFFS_ATTR_MODE);
{
/* Resolve a path string to an inode.
*/
- ino_t dir_ino_nr, root_ino_nr;
+ pino_t dir_ino_nr, root_ino_nr;
struct inode *cur_ino, *root_ino;
struct inode *next_ino = NULL;
struct sffs_attr attr;
char name[NAME_MAX+1];
char *ptr, *last;
vfs_ucred_t ucred;
- mode_t mask;
+ pmode_t mask;
size_t len;
int r;
/* inode.c */
struct inode *init_inode(void);
-struct inode *find_inode(ino_t ino_nr);
+struct inode *find_inode(pino_t ino_nr);
void get_inode(struct inode *ino);
void put_inode(struct inode *ino);
void link_inode(struct inode *parent, struct inode *ino);
int do_getdents(void);
/* stat.c */
-mode_t get_mode(struct inode *ino, int mode);
+pmode_t get_mode(struct inode *ino, int mode);
int do_stat(void);
int do_chmod(void);
int do_utime(void);
/*===========================================================================*
* get_mode *
*===========================================================================*/
-mode_t get_mode(ino, mode)
+pmode_t get_mode(ino, mode)
struct inode *ino;
int mode;
{
struct sffs_attr attr;
struct stat stat;
char path[PATH_MAX];
- ino_t ino_nr;
+ pino_t ino_nr;
int r;
ino_nr = m_in.REQ_INODE_NR;
/*===========================================================================*
* find_inode *
*===========================================================================*/
-struct inode *find_inode(ino_t num)
+struct inode *find_inode(pino_t num)
{
/* Retrieve an inode by inode number.
*/
/*===========================================================================*
* get_inode *
*===========================================================================*/
-struct inode *get_inode(ino_t num)
+struct inode *get_inode(pino_t num)
{
/* Retrieve an inode by inode number, and increase its reference count.
*/
/* Check whether the given inode may be accessed as directory.
* Return OK or an appropriate error code.
*/
- mode_t mask;
+ pmode_t mask;
int i;
/* The inode must be a directory to begin with. */
{
/* Resolve a path string to an inode.
*/
- ino_t dir_ino_nr, root_ino_nr;
+ pino_t dir_ino_nr, root_ino_nr;
struct inode *cur_ino, *next_ino, *root_ino;
char path[PATH_MAX], name[PNAME_MAX+1];
char *ptr, *last;
void init_inodes(unsigned int inodes, struct inode_stat *stat, index_t
nr_indexed_entries);
void cleanup_inodes(void);
-struct inode *find_inode(ino_t num);
-struct inode *get_inode(ino_t num);
+struct inode *find_inode(pino_t num);
+struct inode *get_inode(pino_t num);
void put_inode(struct inode *node);
void ref_inode(struct inode *node);
int get_inode_number(struct inode *node);
#define SUPER_BLOCK_BYTES (1024) /* bytes offset */
-#define ROOT_INODE ((ino_t) 2) /* inode number for root directory */
+#define ROOT_INODE ((pino_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 */
/*===========================================================================*
* alloc_inode *
*===========================================================================*/
-struct inode *alloc_inode(struct inode *parent, mode_t bits)
+struct inode *alloc_inode(struct inode *parent, pmode_t bits)
{
/* Allocate a free inode on parent's dev, and return a pointer to it. */
int is_dir; /* inode will be a directory if it is TRUE */
{
int group;
- ino_t inumber = NO_BIT;
+ pino_t inumber = NO_BIT;
bit_t bit;
struct buf *bp;
struct group_desc *gd;
struct inode *rip;
int count;
- rip = find_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR);
+ rip = find_inode(fs_dev, (pino_t) fs_m_in.REQ_INODE_NR);
if (!rip) {
printf("%s:%d put_inode: inode #%u dev: %d not found\n", __FILE__,
- __LINE__, (unsigned int) fs_m_in.REQ_INODE_NR, fs_dev);
+ __LINE__, (pino_t) fs_m_in.REQ_INODE_NR, fs_dev);
panic("fs_putnode failed");
}
*===========================================================================*/
struct inode *get_inode(
dev_t dev, /* device on which inode resides */
- ino_t numb /* inode number (ANSI: may not be unshort) */
+ pino_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
*===========================================================================*/
struct inode *find_inode(
dev_t dev, /* device on which inode resides */
- ino_t numb /* inode number (ANSI: may not be unshort) */
+ pino_t numb /* inode number (ANSI: may not be unshort) */
)
{
/* Find the inode specified by the inode and device number. */
/* The following items are not present on the disk. */
dev_t i_dev; /* which device is the inode on */
- ino_t i_num; /* inode number on its (minor) device */
+ pino_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 */
NUL(string, len, sizeof(string));
/* Temporarily open the dir. */
- if( (rldirp = get_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
+ if( (rldirp = get_inode(fs_dev, (pino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(EINVAL);
/* The last directory exists. Does the file also exist? */
copylen = min( (size_t) fs_m_in.REQ_MEM_SIZE, UMAX_FILE_POS);
/* Temporarily open the file. */
- if( (rip = get_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
+ if( (rip = get_inode(fs_dev, (pino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(EINVAL);
if (rip->i_size >= MAX_FAST_SYMLINK_LENGTH) {
{
/* Unlink 'file_name'; rip must be the inode of 'file_name' or NULL. */
- ino_t numb; /* inode number */
+ pino_t numb; /* inode number */
int r;
/* If rip is not NULL, it is used to get faster access to the inode. */
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];
- ino_t numb;
+ pino_t numb;
phys_bytes len;
/* Copy the last component of the old name */
NUL(new_name, len, sizeof(new_name));
/* Get old dir inode */
- if( (old_dirp = get_inode(fs_dev, (ino_t) fs_m_in.REQ_REN_OLD_DIR)) == NULL)
+ if( (old_dirp = get_inode(fs_dev, (pino_t) fs_m_in.REQ_REN_OLD_DIR)) == NULL)
return(err_code);
old_ip = advance(old_dirp, old_name, IGN_PERM);
}
/* Get new dir inode */
- if( (new_dirp = get_inode(fs_dev, (ino_t) fs_m_in.REQ_REN_NEW_DIR)) == NULL) {
+ if ((new_dirp = get_inode(fs_dev, (pino_t) fs_m_in.REQ_REN_NEW_DIR)) == NULL){
put_inode(old_ip);
put_inode(old_dirp);
return(err_code);
} else {
- if (new_dirp->i_links_count == NO_LINK) { /* Dir does not actually exist */
+ if (new_dirp->i_links_count == NO_LINK) { /* Dir does not exist */
put_inode(old_ip);
put_inode(old_dirp);
put_inode(new_dirp);
} else {
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, (ino_t *) 0, DELETE,
- IGN_PERM, 0);
+ if(r == OK) {
+ (void) search_dir(old_dirp, old_name, (pino_t *) 0,
+ DELETE, IGN_PERM, 0);
+ }
}
}
/* If r is OK, the ctime and mtime of old_dirp and new_dirp have been marked
off_t start, end;
int r;
- if( (rip = find_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
+ if( (rip = find_inode(fs_dev, (pino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(EINVAL);
start = fs_m_in.REQ_TRC_START_LO;
* writing is done.
*/
int r;
- mode_t file_type;
+ pmode_t file_type;
discard_preallocated_blocks(rip);
*/
register struct inode *rip;
int r = OK;
- mode_t bits;
+ pmode_t bits;
/* Temporarily open the file. */
if( (rip = get_inode(fs_dev, fs_m_in.REQ_INODE_NR)) == NULL)
#include "super.h"
#include <minix/vfsif.h>
-static struct inode *new_node(struct inode *ldirp, char *string, mode_t
+static struct inode *new_node(struct inode *ldirp, char *string, pmode_t
bits, block_t z0);
int r;
struct inode *ldirp;
struct inode *rip;
- mode_t omode;
+ pmode_t omode;
char lastc[NAME_MAX + 1];
/* Read request message */
- omode = (mode_t) fs_m_in.REQ_MODE;
+ omode = (pmode_t) fs_m_in.REQ_MODE;
caller_uid = (uid_t) fs_m_in.REQ_UID;
caller_gid = (gid_t) fs_m_in.REQ_GID;
NUL(lastc, len, sizeof(lastc));
/* Get last directory inode (i.e., directory that will hold the new inode) */
- if ((ldirp = get_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
+ if ((ldirp = get_inode(fs_dev, (pino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(ENOENT);
/* Create a new inode by calling new_node(). */
caller_gid = (gid_t) fs_m_in.REQ_GID;
/* Get last directory inode */
- if((ldirp = get_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
+ if((ldirp = get_inode(fs_dev, (pino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(ENOENT);
/* Try to create the new node */
- ip = new_node(ldirp, lastc, (mode_t) fs_m_in.REQ_MODE,
+ ip = new_node(ldirp, lastc, (pmode_t) fs_m_in.REQ_MODE,
(block_t) fs_m_in.REQ_DEV);
put_inode(ip);
int fs_mkdir()
{
int r1, r2; /* status codes */
- ino_t dot, dotdot; /* inode numbers for . and .. */
+ pino_t dot, dotdot; /* inode numbers for . and .. */
struct inode *rip, *ldirp;
char lastc[NAME_MAX + 1]; /* last component */
phys_bytes len;
caller_gid = (gid_t) fs_m_in.REQ_GID;
/* Get last directory inode */
- if((ldirp = get_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
+ if((ldirp = get_inode(fs_dev, (pino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(ENOENT);
/* Next make the inode. If that fails, return error code. */
- rip = new_node(ldirp, lastc, (ino_t) fs_m_in.REQ_MODE, (block_t) 0);
+ rip = new_node(ldirp, lastc, (pino_t) fs_m_in.REQ_MODE, (block_t) 0);
if(rip == NULL || err_code == EEXIST) {
put_inode(rip); /* can't make dir: it already exists */
/* Now make dir entries for . and .. unless the disk is completely full. */
/* Use dot1 and dot2, so the mode of the directory isn't important. */
- rip->i_mode = (mode_t) fs_m_in.REQ_MODE; /* set mode */
+ rip->i_mode = (pmode_t) fs_m_in.REQ_MODE; /* set mode */
/* enter . in the new dir*/
r1 = search_dir(rip, dot1, &dot, ENTER, IGN_PERM, I_DIRECTORY);
/* enter .. in the new dir */
NUL(string, len, sizeof(string));
/* Temporarily open the dir. */
- if( (ldirp = get_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
+ if( (ldirp = get_inode(fs_dev, (pino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(EINVAL);
/* Create the inode for the symlink. */
- sip = new_node(ldirp, string, (mode_t) (I_SYMBOLIC_LINK | RWX_MODES),
+ sip = new_node(ldirp, string, (pmode_t) (I_SYMBOLIC_LINK | RWX_MODES),
(block_t) 0);
/* If we can then create fast symlink (store it in inode),
* new_node *
*===========================================================================*/
static struct inode *new_node(struct inode *ldirp,
- char *string, mode_t bits, block_t b0)
+ char *string, pmode_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
{
struct inode *rip;
- if((rip = find_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
+ if((rip = find_inode(fs_dev, (pino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(EINVAL);
/* inhibit read ahead */
static char *get_name(char *name, char string[NAME_MAX+1]);
static int ltraverse(struct inode *rip, char *suffix);
-static int parse_path(ino_t dir_ino, ino_t root_ino, int flags, struct
+static int parse_path(pino_t dir_ino, pino_t root_ino, int flags, struct
inode **res_inop, size_t *offsetp, int *symlinkp);
/*===========================================================================*
int r, r1, flags, symlinks;
unsigned int len;
size_t offset = 0, path_size;
- ino_t dir_ino, root_ino;
+ pino_t dir_ino, root_ino;
struct inode *rip;
grant = (cp_grant_id_t) fs_m_in.REQ_GRANT;
path_size = (size_t) fs_m_in.REQ_PATH_SIZE; /* Size of the buffer */
len = (int) fs_m_in.REQ_PATH_LEN; /* including terminating nul */
- dir_ino = (ino_t) fs_m_in.REQ_DIR_INO;
- root_ino = (ino_t) fs_m_in.REQ_ROOT_INO;
+ dir_ino = (pino_t) fs_m_in.REQ_DIR_INO;
+ root_ino = (pino_t) fs_m_in.REQ_ROOT_INO;
flags = (int) fs_m_in.REQ_FLAGS;
/* Check length. */
* parse_path *
*===========================================================================*/
static int parse_path(dir_ino, root_ino, flags, res_inop, offsetp, symlinkp)
-ino_t dir_ino;
-ino_t root_ino;
+pino_t dir_ino;
+pino_t root_ino;
int flags;
struct inode **res_inop;
size_t *offsetp;
* the directory, find the inode, open it, and return a pointer to its inode
* slot.
*/
- ino_t numb;
+ pino_t numb;
struct inode *rip;
/* If 'string' is empty, return an error. */
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 */
-ino_t *numb; /* pointer to inode number */
+pino_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
register struct ext2_disk_dir_desc *prev_dp = NULL;
register struct buf *bp = NULL;
int i, r, e_hit, t, match;
- mode_t bits;
+ pmode_t bits;
off_t pos;
unsigned new_slots;
int extended = 0;
r = OK;
if (flag == IS_EMPTY) r = ENOTEMPTY;
else if (flag == DELETE) {
- if (dp->d_name_len >= sizeof(ino_t)) {
+ if (dp->d_name_len >= sizeof(pino_t)) {
/* Save d_ino for recovery. */
- t = dp->d_name_len - sizeof(ino_t);
- *((ino_t *) &dp->d_name[t]) = dp->d_ino;
+ t = dp->d_name_len - sizeof(pino_t);
+ *((pino_t *) &dp->d_name[t])= dp->d_ino;
}
dp->d_ino = NO_ENTRY; /* erase entry */
lmfs_markdirty(bp);
}
} else {
/* 'flag' is LOOK_UP */
- *numb = (ino_t) conv4(le_CPU, dp->d_ino);
+ *numb = (pino_t) conv4(le_CPU, dp->d_ino);
}
assert(lmfs_dev(bp) != NO_DEV);
put_block(bp, DIRECTORY_BLOCK);
/* Perform the chmod(name, mode) system call. */
register struct inode *rip;
- mode_t mode;
+ pmode_t mode;
- mode = (mode_t) fs_m_in.REQ_MODE;
+ mode = (pmode_t) fs_m_in.REQ_MODE;
/* Temporarily open the file. */
- if( (rip = get_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
+ if( (rip = get_inode(fs_dev, (pino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(EINVAL);
/* Now make the change. Clear setgid bit if file is not in caller's grp */
register int r;
/* Temporarily open the file. */
- if( (rip = get_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
+ if( (rip = get_inode(fs_dev, (pino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(EINVAL);
/* Not permitted to change the owner of a file on a read-only file sys. */
/*===========================================================================*
* forbidden *
*===========================================================================*/
-int forbidden(register struct inode *rip, mode_t access_desired)
+int forbidden(register struct inode *rip, pmode_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
*/
register struct inode *old_rip = rip;
- register mode_t bits, perm_bits;
+ register pmode_t bits, perm_bits;
int r, shift;
/* Isolate the relevant rwx bits from the mode. */
void free_block(struct super_block *sp, bit_t bit);
/* ialloc.c */
-struct inode *alloc_inode(struct inode *parent, mode_t bits);
+struct inode *alloc_inode(struct inode *parent, pmode_t bits);
void free_inode(struct inode *rip);
/* inode.c */
void dup_inode(struct inode *ip);
-struct inode *find_inode(dev_t dev, ino_t numb);
+struct inode *find_inode(dev_t dev, pino_t numb);
int fs_putnode(void);
void init_inode_cache(void);
-struct inode *get_inode(dev_t dev, ino_t numb);
+struct inode *get_inode(dev_t dev, pino_t numb);
void put_inode(struct inode *rip);
void update_times(struct inode *rip);
void rw_inode(struct inode *rip, int rw_flag);
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], ino_t
+int search_dir(struct inode *ldir_ptr, const char string [NAME_MAX + 1], pino_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, mode_t access_desired);
+int forbidden(struct inode *rip, pmode_t access_desired);
int read_only(struct inode *ip);
/* read.c */
cp_grant_id_t gid;
off_t position, f_size, bytes_left;
unsigned int off, cum_io, block_size, chunk;
- mode_t mode_word;
+ pmode_t mode_word;
int completed;
struct inode *rip;
size_t nrbytes;
r = OK;
/* Find the inode referred */
- if ((rip = find_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
+ if ((rip = find_inode(fs_dev, (pino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(EINVAL);
mode_word = rip->i_mode & I_TYPE;
struct inode *rip;
int o, r, done;
unsigned int block_size, len, reclen;
- ino_t ino;
+ pino_t ino;
cp_grant_id_t gid;
size_t size, tmpbuf_off, userbuf_off;
off_t pos, off, block_pos, new_pos, ent_pos;
struct ext2_disk_dir_desc *d_desc;
struct dirent *dep;
- ino = (ino_t) fs_m_in.REQ_INODE_NR;
- gid = (gid_t) fs_m_in.REQ_GRANT;
+ ino = (pino_t) fs_m_in.REQ_INODE_NR;
+ gid = (cp_grant_id_t) fs_m_in.REQ_GRANT;
size = (size_t) fs_m_in.REQ_MEM_SIZE;
pos = (off_t) fs_m_in.REQ_SEEK_POS_LO;
/* Common code for stat and fstat system calls. */
struct stat statbuf;
- mode_t mo;
+ pmode_t mo;
int r, s;
/* Update the atime, ctime, and mtime fields in the inode, if need be. */
register int r; /* return value */
register struct inode *rip; /* target inode */
- if ((rip = get_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
+ if ((rip = get_inode(fs_dev, (pino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(EINVAL);
r = stat_inode(rip, fs_m_in.m_source, (cp_grant_id_t) fs_m_in.REQ_GRANT);
register int r;
/* Temporarily open the file. */
- if( (rip = get_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
+ if( (rip = get_inode(fs_dev, (pino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(EINVAL);
/*
* get_dir_record *
*===========================================================================*/
struct dir_record *get_dir_record(id_dir_record)
-ino_t id_dir_record;
+pino_t id_dir_record;
{
struct dir_record *dir = NULL;
u32_t address;
/* Set physical address of the dir record */
dir->d_phy_addr = address;
- dir->d_ino_nr = (ino_t) address; /* u32_t e ino_t are the same datatype so
- * the cast is safe */
+ dir->d_ino_nr = (pino_t) address; /* u32_t e ino_t are the same datatype so
+ * the cast is safe */
return(OK);
}
/* Memory attrs */
u8_t d_count; /* Count if the dir_record is in use or not */
- mode_t d_mode; /* file type, protection, etc. */
+ pmode_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 */
- ino_t d_ino_nr; /* inode number (identical to the address) */
+ pino_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 */
#include "buf.h"
static char *get_name(char *name, char string[NAME_MAX+1]);
-static int parse_path(ino_t dir_ino, ino_t root_ino, int flags, struct
+static int parse_path(pino_t dir_ino, pino_t root_ino, int flags, struct
dir_record **res_inop, size_t *offsetp);
cp_grant_id_t grant;
int r, len, flags;
size_t offset;
- ino_t dir_ino, root_ino;
+ pino_t dir_ino, root_ino;
struct dir_record *dir;
grant = fs_m_in.REQ_GRANT;
len = fs_m_in.REQ_PATH_LEN; /* including terminating nul */
- dir_ino = fs_m_in.REQ_DIR_INO;
- root_ino = fs_m_in.REQ_ROOT_INO;
+ dir_ino = (pino_t) fs_m_in.REQ_DIR_INO;
+ root_ino = (pino_t) fs_m_in.REQ_ROOT_INO;
flags = fs_m_in.REQ_FLAGS;
- caller_uid = fs_m_in.REQ_UID;
- caller_gid = fs_m_in.REQ_GID;
+ caller_uid = (uid_t) fs_m_in.REQ_UID;
+ caller_gid = (gid_t) fs_m_in.REQ_GID;
/* Check length. */
if(len > sizeof(user_path)) return(E2BIG); /* too big for buffer */
/*===========================================================================*
* search_dir *
*===========================================================================*/
-int search_dir(ldir_ptr,string,numb)
- register struct dir_record *ldir_ptr; /* dir record parent */
- char string[NAME_MAX]; /* component to search for */
- ino_t *numb; /* pointer to new dir record */
-{
+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 */
+) {
struct dir_record *dir_tmp;
register struct buf *bp;
int pos;
}
if (create_dir_record(dir_tmp,b_data(bp) + pos,
- ldir_ptr->loc_extent_l*v_pri.logical_block_size_l + pos) == EINVAL)
+ ldir_ptr->loc_extent_l*v_pri.logical_block_size_l + pos) == EINVAL)
return EINVAL;
if (dir_tmp->length == 0) {
/*===========================================================================*
* parse_path *
*===========================================================================*/
-static int parse_path(dir_ino, root_ino, flags, res_inop, offsetp)
-ino_t dir_ino;
-ino_t root_ino;
-int flags;
-struct dir_record **res_inop;
-size_t *offsetp;
-{
+static int parse_path(
+pino_t dir_ino,
+pino_t root_ino,
+int flags,
+struct dir_record **res_inop,
+size_t *offsetp
+) {
int r;
char string[NAME_MAX+1];
char *cp, *ncp;
register struct dir_record *rip = NULL;
int r;
- ino_t numb;
+ pino_t numb;
/* If 'string' is empty, yield same inode straight away. */
if (string[0] == '\0') {
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(ino_t id_dir);
+struct dir_record *get_dir_record(pino_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);
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],
- ino_t *numb);
+int search_dir(struct dir_record *ldir_ptr,char string [NAME_MAX],pino_t *numb);
/* protect.c */
int fs_access(void);
*===========================================================================*/
int fs_getdents(void) {
struct dir_record *dir;
- ino_t ino;
+ pino_t ino;
cp_grant_id_t gid;
size_t block_size;
off_t pos, block_pos, block, cur_pos, tmpbuf_offset, userbuf_off;
/* The standard data structure is created using the
* data in the buffer. */
dirp = (struct dirent *) &getdents_buf[tmpbuf_offset];
- dirp->d_ino = (ino_t)(b_data(bp) + block_pos);
+ dirp->d_ino = (pino_t)(b_data(bp) + block_pos);
dirp->d_off= cur_pos;
dirp->d_reclen= reclen;
memcpy(dirp->d_name, name, len);
#define END_OF_FILE (-104) /* eof detected */
-#define ROOT_INODE ((ino_t) 1) /* inode number for root directory */
+#define ROOT_INODE ((pino_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) */
#include <limits.h>
#include <errno.h>
+#include <minix/vfsif.h>
#include <minix/syslib.h>
#include <minix/sysutil.h>
static void addhash_inode(struct inode *node);
-static void free_inode(dev_t dev, ino_t numb);
+static void free_inode(dev_t dev, pino_t numb);
static void new_icopy(struct inode *rip, d2_inode *dip, int direction,
int norm);
static void old_icopy(struct inode *rip, d1_inode *dip, int direction,
struct inode *rip;
int count;
- rip = find_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR);
+ rip = find_inode(fs_dev, (pino_t) fs_m_in.REQ_INODE_NR);
if(!rip) {
printf("%s:%d put_inode: inode #%u dev: %d not found\n", __FILE__,
- __LINE__, (ino_t) fs_m_in.REQ_INODE_NR, fs_dev);
+ __LINE__, (pino_t) fs_m_in.REQ_INODE_NR, fs_dev);
panic("fs_putnode failed");
}
*===========================================================================*/
struct inode *get_inode(
dev_t dev, /* device on which inode resides */
- ino_t numb /* inode number */
+ pino_t numb /* inode number */
)
{
/* Find the inode in the hash table. If it is not there, get a free inode
*===========================================================================*/
struct inode *find_inode(
dev_t dev, /* device on which inode resides */
- ino_t numb /* inode number */
+ pino_t numb /* inode number */
)
{
/* Find the inode specified by the inode and device number.
/*===========================================================================*
* alloc_inode *
*===========================================================================*/
-struct inode *alloc_inode(dev_t dev, mode_t bits)
+struct inode *alloc_inode(dev_t dev, pmode_t bits)
{
/* Allocate a free inode on 'dev', and return a pointer to it. */
*===========================================================================*/
static void free_inode(
dev_t dev, /* on which device is the inode? */
- ino_t inumb /* number of the inode to be freed */
+ pino_t inumb /* number of the inode to be freed */
)
{
/* Return an inode to the pool of unallocated inodes. */
if (direction == READING) {
/* Copy V1.x inode to the in-core table, swapping bytes if need be. */
- rip->i_mode = (mode_t) conv2(norm, (int) dip->d1_mode);
+ rip->i_mode = (pmode_t) conv2(norm, (int) dip->d1_mode);
rip->i_uid = (uid_t) conv2(norm, (int) dip->d1_uid );
rip->i_size = (off_t) conv4(norm, dip->d1_size);
rip->i_mtime = (time_t) conv4(norm, dip->d1_mtime);
if (direction == READING) {
/* Copy V2.x inode to the in-core table, swapping bytes if need be. */
- rip->i_mode = (mode_t) conv2(norm,dip->d2_mode);
+ rip->i_mode = (pmode_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);
*/
#include <sys/queue.h>
+#include <minix/vfsif.h>
#include "super.h"
NUL(string, len, sizeof(string));
/* Temporarily open the file. */
- if( (rip = get_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
+ if( (rip = get_inode(fs_dev, (pino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(EINVAL);
/* Check to see if the file has maximum number of links already. */
}
/* Temporarily open the last dir */
- if( (ip = get_inode(fs_dev, (ino_t) fs_m_in.REQ_DIR_INO)) == NULL) {
+ if( (ip = get_inode(fs_dev, (pino_t) fs_m_in.REQ_DIR_INO)) == NULL) {
put_inode(rip);
return(EINVAL);
}
NUL(string, len, sizeof(string));
/* Temporarily open the dir. */
- if( (rldirp = get_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
+ if( (rldirp = get_inode(fs_dev, (pino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(EINVAL);
/* The last directory exists. Does the file also exist? */
copylen = min( (size_t) fs_m_in.REQ_MEM_SIZE, UMAX_FILE_POS);
/* Temporarily open the file. */
- if( (rip = get_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
+ if( (rip = get_inode(fs_dev, (pino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(EINVAL);
if(!S_ISLNK(rip->i_mode))
{
/* Unlink 'file_name'; rip must be the inode of 'file_name' or NULL. */
- ino_t numb; /* inode number */
+ pino_t numb; /* inode number */
int r;
/* If rip is not NULL, it is used to get faster access to the inode. */
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];
- ino_t numb;
+ pino_t numb;
phys_bytes len;
/* Copy the last component of the old name */
NUL(new_name, len, sizeof(new_name));
/* Get old dir inode */
- if( (old_dirp = get_inode(fs_dev, (ino_t) fs_m_in.REQ_REN_OLD_DIR)) == NULL)
+ if ((old_dirp = get_inode(fs_dev, (pino_t) fs_m_in.REQ_REN_OLD_DIR)) == NULL)
return(err_code);
old_ip = advance(old_dirp, old_name, IGN_PERM);
}
/* Get new dir inode */
- if( (new_dirp = get_inode(fs_dev, (ino_t) fs_m_in.REQ_REN_NEW_DIR)) == NULL) {
+ if ((new_dirp = get_inode(fs_dev, (pino_t) fs_m_in.REQ_REN_NEW_DIR)) == NULL){
put_inode(old_ip);
put_inode(old_dirp);
return(err_code);
off_t start, end;
int r;
- if( (rip = find_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
+ if( (rip = find_inode(fs_dev, (pino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(EINVAL);
if(rip->i_sp->s_rd_only) {
* writing is done.
*/
int r;
- mode_t file_type;
+ pmode_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)
#define MFS_DIRSIZ 60
struct direct {
- ino_t mfs_d_ino;
+ pino_t mfs_d_ino;
char mfs_d_name[MFS_DIRSIZ];
} __packed;
*/
register struct inode *rip;
int r = OK;
- mode_t bits;
+ pmode_t bits;
/* Temporarily open the file. */
- if( (rip = get_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
+ if( (rip = get_inode(fs_dev, (pino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(EINVAL);
#include "super.h"
#include <minix/vfsif.h>
-static struct inode *new_node(struct inode *ldirp, char *string, mode_t
+static struct inode *new_node(struct inode *ldirp, char *string, pmode_t
bits, zone_t z0);
/*===========================================================================*
int r;
struct inode *ldirp;
struct inode *rip;
- mode_t omode;
+ pmode_t omode;
char lastc[MFS_NAME_MAX];
/* Read request message */
- omode = (mode_t) fs_m_in.REQ_MODE;
+ omode = (pmode_t) fs_m_in.REQ_MODE;
caller_uid = (uid_t) fs_m_in.REQ_UID;
caller_gid = (gid_t) fs_m_in.REQ_GID;
NUL(lastc, len, sizeof(lastc));
/* Get last directory inode (i.e., directory that will hold the new inode) */
- if ((ldirp = get_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
+ if ((ldirp = get_inode(fs_dev, (pino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(ENOENT);
/* Create a new inode by calling new_node(). */
caller_gid = (gid_t) fs_m_in.REQ_GID;
/* Get last directory inode */
- if((ldirp = get_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
+ if((ldirp = get_inode(fs_dev, (pino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(ENOENT);
/* Try to create the new node */
- ip = new_node(ldirp, lastc, (mode_t) fs_m_in.REQ_MODE,
+ ip = new_node(ldirp, lastc, (pmode_t) fs_m_in.REQ_MODE,
(zone_t) fs_m_in.REQ_DEV);
put_inode(ip);
int fs_mkdir()
{
int r1, r2; /* status codes */
- ino_t dot, dotdot; /* inode numbers for . and .. */
+ pino_t dot, dotdot; /* inode numbers for . and .. */
struct inode *rip, *ldirp;
char lastc[MFS_NAME_MAX]; /* last component */
phys_bytes len;
caller_gid = (gid_t) fs_m_in.REQ_GID;
/* Get last directory inode */
- if((ldirp = get_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
+ if((ldirp = get_inode(fs_dev, (pino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(ENOENT);
/* Next make the inode. If that fails, return error code. */
- rip = new_node(ldirp, lastc, (mode_t) fs_m_in.REQ_MODE, (zone_t) 0);
+ rip = new_node(ldirp, lastc, (pmode_t) fs_m_in.REQ_MODE, (zone_t) 0);
if(rip == NULL || err_code == EEXIST) {
put_inode(rip); /* can't make dir: it already exists */
/* Now make dir entries for . and .. unless the disk is completely full. */
/* Use dot1 and dot2, so the mode of the directory isn't important. */
- rip->i_mode = (mode_t) fs_m_in.REQ_MODE; /* set mode */
+ rip->i_mode = (pmode_t) fs_m_in.REQ_MODE; /* set mode */
r1 = search_dir(rip, dot1, &dot, ENTER, IGN_PERM);/* enter . in the new dir*/
r2 = search_dir(rip, dot2, &dotdot, ENTER, IGN_PERM); /* enter .. in the new
dir */
NUL(string, len, sizeof(string));
/* Temporarily open the dir. */
- if( (ldirp = get_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
+ if( (ldirp = get_inode(fs_dev, (pino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(EINVAL);
/* Create the inode for the symlink. */
- sip = new_node(ldirp, string, (mode_t) (I_SYMBOLIC_LINK | RWX_MODES),
+ sip = new_node(ldirp, string, (pmode_t) (I_SYMBOLIC_LINK | RWX_MODES),
(zone_t) 0);
/* Allocate a disk block for the contents of the symlink.
* new_node *
*===========================================================================*/
static struct inode *new_node(struct inode *ldirp,
- char *string, mode_t bits, zone_t z0)
+ char *string, pmode_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
{
struct inode *rip;
- if((rip = find_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
+ if((rip = find_inode(fs_dev, (pino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(EINVAL);
/* inhibit read ahead */
static char *get_name(char *name, char string[MFS_NAME_MAX+1]);
static int ltraverse(struct inode *rip, char *suffix);
-static int parse_path(ino_t dir_ino, ino_t root_ino, int flags, struct
+static int parse_path(pino_t dir_ino, pino_t root_ino, int flags, struct
inode **res_inop, size_t *offsetp, int *symlinkp);
int r, r1, flags, symlinks;
unsigned int len;
size_t offset = 0, path_size;
- ino_t dir_ino, root_ino;
+ pino_t dir_ino, root_ino;
struct inode *rip;
grant = (cp_grant_id_t) fs_m_in.REQ_GRANT;
path_size = (size_t) fs_m_in.REQ_PATH_SIZE; /* Size of the buffer */
len = (int) fs_m_in.REQ_PATH_LEN; /* including terminating nul */
- dir_ino = (ino_t) fs_m_in.REQ_DIR_INO;
- root_ino = (ino_t) fs_m_in.REQ_ROOT_INO;
+ dir_ino = (pino_t) fs_m_in.REQ_DIR_INO;
+ root_ino = (pino_t) fs_m_in.REQ_ROOT_INO;
flags = (int) fs_m_in.REQ_FLAGS;
/* Check length. */
/*===========================================================================*
* parse_path *
*===========================================================================*/
-static int parse_path(dir_ino, root_ino, flags, res_inop, offsetp, symlinkp)
-ino_t dir_ino;
-ino_t root_ino;
-int flags;
-struct inode **res_inop;
-size_t *offsetp;
-int *symlinkp;
-{
+static int parse_path(
+pino_t dir_ino,
+pino_t root_ino,
+int flags,
+struct inode **res_inop,
+size_t *offsetp,
+int *symlinkp
+) {
/* Parse the path in user_path, starting at dir_ino. If the path is the empty
* string, just return dir_ino. It is upto the caller to treat an empty
* path in a special way. Otherwise, if the path consists of just one or
* the directory, find the inode, open it, and return a pointer to its inode
* slot.
*/
- ino_t numb;
+ pino_t numb;
struct inode *rip;
/* If 'string' is empty, return an error. */
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 */
-ino_t *numb; /* pointer to inode number */
+pino_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 */
{
register struct direct *dp = NULL;
register struct buf *bp = NULL;
int i, r, e_hit, t, match;
- mode_t bits;
+ pmode_t bits;
off_t pos;
unsigned new_slots, old_slots;
struct super_block *sp;
if (flag == IS_EMPTY) r = ENOTEMPTY;
else if (flag == DELETE) {
/* Save d_ino for recovery. */
- t = MFS_NAME_MAX - sizeof(ino_t);
- *((ino_t *) &dp->mfs_d_name[t]) = dp->mfs_d_ino;
+ t = MFS_NAME_MAX - sizeof(pino_t);
+ *((pino_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;
ldir_ptr->i_last_dpos = pos;
} else {
sp = ldir_ptr->i_sp; /* 'flag' is LOOK_UP */
- *numb = (ino_t) conv4(sp->s_native,
+ *numb = (pino_t) conv4(sp->s_native,
(int) dp->mfs_d_ino);
}
assert(lmfs_dev(bp) != NO_DEV);
/* Perform the chmod(name, mode) system call. */
register struct inode *rip;
- mode_t mode;
+ pmode_t mode;
- mode = (mode_t) fs_m_in.REQ_MODE;
+ mode = (pmode_t) fs_m_in.REQ_MODE;
/* Temporarily open the file. */
- if( (rip = get_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
+ if( (rip = get_inode(fs_dev, (pino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(EINVAL);
if(rip->i_sp->s_rd_only) {
register int r;
/* Temporarily open the file. */
- if( (rip = get_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
+ if( (rip = get_inode(fs_dev, (pino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(EINVAL);
/* Not permitted to change the owner of a file on a read-only file sys. */
/*===========================================================================*
* forbidden *
*===========================================================================*/
-int forbidden(register struct inode *rip, mode_t access_desired)
+int forbidden(register struct inode *rip, pmode_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
*/
register struct inode *old_rip = rip;
- register mode_t bits, perm_bits;
+ register pmode_t bits, perm_bits;
int r, shift;
/* Isolate the relevant rwx bits from the mode. */
void free_zone(dev_t dev, zone_t numb);
/* inode.c */
-struct inode *alloc_inode(dev_t dev, mode_t bits);
+struct inode *alloc_inode(dev_t dev, pmode_t bits);
void dup_inode(struct inode *ip);
-struct inode *find_inode(dev_t dev, ino_t numb);
+struct inode *find_inode(dev_t dev, pino_t numb);
int fs_putnode(void);
void init_inode_cache(void);
-struct inode *get_inode(dev_t dev, ino_t numb);
+struct inode *get_inode(dev_t dev, pino_t numb);
void put_inode(struct inode *rip);
void update_times(struct inode *rip);
void rw_inode(struct inode *rip, int rw_flag);
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], ino_t
+int search_dir(struct inode *ldir_ptr, char string [MFS_NAME_MAX], pino_t
*numb, int flag, int check_permissions);
int fs_chmod(void);
int fs_chown(void);
int fs_getdents(void);
-int forbidden(struct inode *rip, mode_t access_desired);
+int forbidden(struct inode *rip, pmode_t access_desired);
int read_only(struct inode *ip);
/* read.c */
cp_grant_id_t gid;
off_t position, f_size, bytes_left;
unsigned int off, cum_io, block_size, chunk;
- mode_t mode_word;
+ pmode_t mode_word;
int completed;
struct inode *rip;
size_t nrbytes;
r = OK;
/* Find the inode referred */
- if ((rip = find_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
+ if ((rip = find_inode(fs_dev, (pino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(EINVAL);
mode_word = rip->i_mode & I_TYPE;
register struct inode *rip;
int o, r, done;
unsigned int block_size, len, reclen;
- ino_t ino;
+ pino_t ino;
cp_grant_id_t gid;
size_t size, tmpbuf_off, userbuf_off;
off_t pos, off, block_pos, new_pos, ent_pos;
struct dirent *dep;
char *cp;
- ino = (ino_t) fs_m_in.REQ_INODE_NR;
- gid = (gid_t) fs_m_in.REQ_GRANT;
+ ino = (pino_t) fs_m_in.REQ_INODE_NR;
+ gid = (cp_grant_id_t) fs_m_in.REQ_GRANT;
size = (size_t) fs_m_in.REQ_MEM_SIZE;
pos = (off_t) fs_m_in.REQ_SEEK_POS_LO;
/* Common code for stat and fstat system calls. */
struct stat statbuf;
- mode_t mo;
+ pmode_t mo;
int r, s;
/* Update the atime, ctime, and mtime fields in the inode, if need be. */
register int r; /* return value */
register struct inode *rip; /* target inode */
- if ((rip = get_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
+ if ((rip = get_inode(fs_dev, (pino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(EINVAL);
r = stat_inode(rip, fs_m_in.m_source, (cp_grant_id_t) fs_m_in.REQ_GRANT);
/* If the super block has the wrong byte order, swap the fields; the magic
* number doesn't need conversion. */
- sp->s_ninodes = (ino_t) conv4(native, (int) sp->s_ninodes);
+ sp->s_ninodes = (pino_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);
*/
EXTERN struct super_block {
- ino_t s_ninodes; /* # usable inodes on the minor device */
+ pino_t s_ninodes; /* # usable inodes on the minor device */
zone1_t s_nzones; /* total device size, including bit maps etc */
short s_imap_blocks; /* # of blocks used by inode bit map */
short s_zmap_blocks; /* # of blocks used by zone bit map */
register int r;
/* Temporarily open the file. */
- if( (rip = get_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
+ if( (rip = get_inode(fs_dev, (pino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(EINVAL);
/*
/* 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 */
- ino_t b_num; /* inode number on minor device */
+ pino_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 */
#include <stdlib.h>
#include <string.h>
-static struct buf *new_block(dev_t dev, ino_t inum);
+static struct buf *new_block(dev_t dev, pino_t inum);
/*===========================================================================*
* buf_pool *
/*===========================================================================*
* get_block *
*===========================================================================*/
-struct buf *get_block(dev_t dev, ino_t inum)
+struct buf *get_block(dev_t dev, pino_t inum)
{
struct buf *bp = front;
/*===========================================================================*
* new_block *
*===========================================================================*/
-static struct buf *new_block(dev_t dev, ino_t inum)
+static struct buf *new_block(dev_t dev, pino_t inum)
{
/* Allocate a new buffer and add it to the double linked buffer list */
struct buf *bp;
/*===========================================================================*
* put_block *
*===========================================================================*/
-void put_block(dev_t dev, ino_t inum)
+void put_block(dev_t dev, pino_t inum)
{
struct buf *bp;
#include <minix/sysutil.h>
#include <minix/keymap.h>
#include <minix/bitmap.h>
+#include <minix/vfsif.h>
#include <stdlib.h>
#include <stdio.h>
struct inode *rip;
int count;
dev_t dev;
- ino_t inum;
+ pino_t inum;
- rip = find_inode( (ino_t) fs_m_in->REQ_INODE_NR);
+ rip = find_inode( (pino_t) fs_m_in->REQ_INODE_NR);
if(!rip) {
printf("%s:%d put_inode: inode #%ld dev: %d not found\n", __FILE__,
*===========================================================================*/
struct inode *get_inode(
dev_t dev, /* device on which inode resides */
- ino_t numb /* inode number */
+ pino_t numb /* inode number */
)
{
/* Find the inode in the hash table. If it is not there, get a free inode
/*===========================================================================*
* find_inode *
*===========================================================================*/
-struct inode *find_inode(numb)
-ino_t numb; /* inode number */
+struct inode *find_inode(pino_t numb /* inode number */)
{
/* Find the inode specified by the inode and device number.
*/
/*===========================================================================*
* alloc_inode *
*===========================================================================*/
-struct inode *alloc_inode(dev_t dev, mode_t bits)
+struct inode *alloc_inode(dev_t dev, pmode_t bits)
{
/* Allocate a free inode on 'dev', and return a pointer to it. */
register struct inode *rip;
bit_t b;
- ino_t i_num;
+ pino_t i_num;
int print_oos_msg = 1;
b = alloc_bit();
print_oos_msg = 0; /* Don't repeat message */
return(NULL);
}
- i_num = (ino_t) b;
+ i_num = (pino_t) b;
print_oos_msg = 1;
bit_t b;
- if (rip->i_num <= (ino_t) 0 || rip->i_num >= (ino_t) PFS_NR_INODES) return;
+ if (rip->i_num <= (pino_t) 0 || rip->i_num >= (pino_t) PFS_NR_INODES) return;
b = (bit_t) rip->i_num;
free_bit(b);
}
#include <sys/queue.h>
EXTERN struct inode {
- mode_t i_mode; /* file type, protection, etc. */
+ pmode_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 */
{
struct inode *rip;
off_t start;
- ino_t inumb;
+ pino_t inumb;
- inumb = (ino_t) fs_m_in->REQ_INODE_NR;
+ inumb = (pino_t) fs_m_in->REQ_INODE_NR;
if( (rip = find_inode(inumb)) == NULL) return(EINVAL);
int fs_newnode(message *fs_m_in, message *fs_m_out)
{
register int r = OK;
- mode_t bits;
+ pmode_t bits;
struct inode *rip;
dev_t dev;
caller_uid = (uid_t) fs_m_in->REQ_UID;
caller_gid = (gid_t) fs_m_in->REQ_GID;
- bits = (mode_t) fs_m_in->REQ_MODE;
+ bits = (pmode_t) fs_m_in->REQ_MODE;
dev = (dev_t) fs_m_in->REQ_DEV;
/* Try to allocate the inode */
struct ancillary;
/* buffer.c */
-struct buf *get_block(dev_t dev, ino_t inum);
-void put_block(dev_t dev, ino_t inum);
+struct buf *get_block(dev_t dev, pino_t inum);
+void put_block(dev_t dev, pino_t inum);
/* cache.c */
void buf_pool(void);
/* inode.c */
-struct inode *alloc_inode(dev_t dev, mode_t mode);
+struct inode *alloc_inode(dev_t dev, pmode_t mode);
void dup_inode(struct inode *ip);
-struct inode *find_inode(ino_t numb);
+struct inode *find_inode(pino_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, ino_t numb);
+struct inode *get_inode(dev_t dev, pino_t numb);
void put_inode(struct inode *rip);
void update_times(struct inode *rip);
void wipe_inode(struct inode *rip);
cp_grant_id_t gid;
off_t position, f_size;
unsigned int nrbytes, cum_io;
- mode_t mode_word;
+ pmode_t mode_word;
struct inode *rip;
- ino_t inumb;
+ pino_t inumb;
r = OK;
cum_io = 0;
- inumb = (ino_t) fs_m_in->REQ_INODE_NR;
+ inumb = (pino_t) fs_m_in->REQ_INODE_NR;
/* Find the inode referred */
if ((rip = find_inode(inumb)) == NULL) return(EINVAL);
)
{
/* Common code for stat and fstat system calls. */
- mode_t type;
+ pmode_t type;
struct stat statbuf;
u32_t blocks; /* The unit of this is 512 */
int r, s;
* uds_close(). Data is sent/written to a peer's PIPE.
* Data is recv/read from this PIPE.
*/
- ino_t inode_nr;
+ pino_t inode_nr;
/* position in the PIPE where the data starts */
* for read and write, read only, write only, or neither.
* default is S_IRUSR|S_IWUSR.
*/
- mode_t mode;
+ pmode_t mode;
/* Socket Info */
*/
struct file {
char *name; /* file name, maximum length PNAME_MAX */
- mode_t mode; /* file mode, including file type */
+ pmode_t mode; /* file mode, including file type */
data_t data; /* custom data associated with this file */
};
/* Fill in request message */
m.m_type = REQ_CHMOD;
- m.REQ_INODE_NR = inode_nr;
- m.REQ_MODE = rmode;
+ m.REQ_INODE_NR = (pino_t) inode_nr;
+ m.REQ_MODE = (pmode_t) rmode;
/* Send/rec request */
r = fs_sendrec(fs_e, &m);
/* Copy back actual mode. */
- *new_modep = m.RES_MODE;
+ *new_modep = (mode_t) m.RES_MODE;
return(r);
}
/* Fill in request message */
m.m_type = REQ_CHOWN;
- m.REQ_INODE_NR = inode_nr;
- m.REQ_UID = newuid;
- m.REQ_GID = newgid;
+ m.REQ_INODE_NR = (pino_t) inode_nr;
+ m.REQ_UID = (puid_t) newuid;
+ m.REQ_GID = (pgid_t) newgid;
/* Send/rec request */
r = fs_sendrec(fs_e, &m);
/* Return new mode to caller. */
- *new_modep = m.RES_MODE;
+ *new_modep = (mode_t) m.RES_MODE;
return(r);
}
panic("req_create: cpf_grant_direct failed");
/* Fill in request message */
- m.m_type = REQ_CREATE;
- m.REQ_INODE_NR = inode_nr;
- m.REQ_MODE = omode;
- m.REQ_UID = uid;
- m.REQ_GID = gid;
- m.REQ_GRANT = grant_id;
+ m.m_type = REQ_CREATE;
+ m.REQ_INODE_NR = (pino_t) inode_nr;
+ m.REQ_MODE = (pmode_t) omode;
+ m.REQ_UID = (puid_t) uid;
+ m.REQ_GID = (pgid_t) gid;
+ m.REQ_GRANT = grant_id;
m.REQ_PATH_LEN = len;
/* Send/rec request */
/* Fill in response structure */
res->fs_e = m.m_source;
- res->inode_nr = m.RES_INODE_NR;
- res->fmode = m.RES_MODE;
+ res->inode_nr = (ino_t) m.RES_INODE_NR;
+ res->fmode = (mode_t) m.RES_MODE;
res->fsize = m.RES_FILE_SIZE_LO;
- res->uid = m.RES_UID;
- res->gid = m.RES_GID;
+ res->uid = (uid_t) m.RES_UID;
+ res->gid = (gid_t) m.RES_GID;
res->dev = NO_DEV;
return(OK);
/* Fill in request message */
m.m_type = REQ_FTRUNC;
- m.REQ_INODE_NR = inode_nr;
+ m.REQ_INODE_NR = (pino_t) inode_nr;
m.REQ_TRC_START_LO = start;
m.REQ_TRC_START_HI = 0; /* Not used for now, so clear it. */
m.REQ_TRC_END_LO = end;
grant_id);
m.m_type = REQ_GETDENTS;
- m.REQ_INODE_NR = inode_nr;
+ m.REQ_INODE_NR = (pino_t) inode_nr;
m.REQ_GRANT = grant_id;
m.REQ_MEM_SIZE = size;
m.REQ_SEEK_POS_LO = ex64lo(pos);
/* Fill in request message */
m.m_type = REQ_INHIBREAD;
- m.REQ_INODE_NR = inode_nr;
+ m.REQ_INODE_NR = (pino_t) inode_nr;
/* Send/rec request */
return fs_sendrec(fs_e, &m);
/* Fill in request message */
m.m_type = REQ_LINK;
- m.REQ_INODE_NR = linked_file;
- m.REQ_DIR_INO = link_parent;
+ m.REQ_INODE_NR = (pino_t) linked_file;
+ m.REQ_DIR_INO = (pino_t) link_parent;
m.REQ_GRANT = grant_id;
m.REQ_PATH_LEN = len;
m.REQ_GRANT = grant_id;
m.REQ_PATH_LEN = len;
m.REQ_PATH_SIZE = PATH_MAX + 1;
- m.REQ_DIR_INO = dir_ino;
- m.REQ_ROOT_INO = root_ino;
+ m.REQ_DIR_INO = (pino_t) dir_ino;
+ m.REQ_ROOT_INO = (pino_t) root_ino;
if(rfp->fp_ngroups > 0) { /* Is the process member of multiple groups? */
/* In that case the FS has to copy the uid/gid credentials */
flags |= PATH_GET_UCRED;
} else {
/* When there's only one gid, we can send it directly */
- m.REQ_UID = uid;
- m.REQ_GID = gid;
+ m.REQ_UID = (pgid_t) uid;
+ m.REQ_GID = (pgid_t) gid;
flags &= ~PATH_GET_UCRED;
}
switch (r) {
case OK:
- res->inode_nr = m.RES_INODE_NR;
- res->fmode = m.RES_MODE;
+ res->inode_nr = (ino_t) m.RES_INODE_NR;
+ res->fmode = (mode_t) m.RES_MODE;
res->fsize = m.RES_FILE_SIZE_LO;
res->dev = m.RES_DEV;
- res->uid= m.RES_UID;
- res->gid= m.RES_GID;
+ res->uid = (uid_t) m.RES_UID;
+ res->gid = (gid_t) m.RES_GID;
break;
case EENTERMOUNT:
- res->inode_nr = m.RES_INODE_NR;
+ res->inode_nr = (ino_t) m.RES_INODE_NR;
res->char_processed = m.RES_OFFSET;
res->symloop = m.RES_SYMLOOP;
break;
/* Fill in request message */
m.m_type = REQ_MKDIR;
- m.REQ_INODE_NR = inode_nr;
- m.REQ_MODE = dmode;
- m.REQ_UID = uid;
- m.REQ_GID = gid;
+ m.REQ_INODE_NR = (pino_t) inode_nr;
+ m.REQ_MODE = (pmode_t) dmode;
+ m.REQ_UID = (puid_t) uid;
+ m.REQ_GID = (pgid_t) gid;
m.REQ_GRANT = grant_id;
m.REQ_PATH_LEN = len;
/* Fill in request message */
m.m_type = REQ_MKNOD;
- m.REQ_INODE_NR = inode_nr;
- m.REQ_MODE = dmode;
+ m.REQ_INODE_NR = (pino_t) inode_nr;
+ m.REQ_MODE = (pmode_t) dmode;
m.REQ_DEV = dev;
- m.REQ_UID = uid;
- m.REQ_GID = gid;
+ m.REQ_UID = (puid_t) uid;
+ m.REQ_GID = (pgid_t) gid;
m.REQ_GRANT = grant_id;
m.REQ_PATH_LEN = len;
/* Fill in request message */
m.m_type = REQ_MOUNTPOINT;
- m.REQ_INODE_NR = inode_nr;
+ m.REQ_INODE_NR = (pino_t) inode_nr;
/* Send/rec request */
return fs_sendrec(fs_e, &m);
/* Fill in request message */
m.m_type = REQ_NEWNODE;
- m.REQ_MODE = dmode;
+ m.REQ_MODE = (pmode_t) dmode;
m.REQ_DEV = dev;
- m.REQ_UID = uid;
- m.REQ_GID = gid;
+ m.REQ_UID = (puid_t) uid;
+ m.REQ_GID = (pgid_t) gid;
/* Send/rec request */
r = fs_sendrec(fs_e, &m);
res->fs_e = m.m_source;
- res->inode_nr = m.RES_INODE_NR;
- res->fmode = m.RES_MODE;
+ res->inode_nr = (ino_t) m.RES_INODE_NR;
+ res->fmode = (mode_t) m.RES_MODE;
res->fsize = m.RES_FILE_SIZE_LO;
res->dev = m.RES_DEV;
- res->uid = m.RES_UID;
- res->gid = m.RES_GID;
+ res->uid = (uid_t) m.RES_UID;
+ res->gid = (gid_t) m.RES_GID;
return(r);
}
/* Fill in request message */
m.m_type = REQ_PUTNODE;
- m.REQ_INODE_NR = inode_nr;
+ m.REQ_INODE_NR = (pino_t) inode_nr;
m.REQ_COUNT = count;
/* Send/rec request */
/* Fill in request message */
m.m_type = REQ_RDLINK;
- m.REQ_INODE_NR = inode_nr;
+ m.REQ_INODE_NR = (pino_t) inode_nr;
m.REQ_GRANT = grant_id;
m.REQ_MEM_SIZE = len;
if(r == OK) {
/* Fill in response structure */
res_nodep->fs_e = m.m_source;
- res_nodep->inode_nr = m.RES_INODE_NR;
+ res_nodep->inode_nr = (ino_t) m.RES_INODE_NR;
vmp->m_proto = m.RES_PROTO;
printf("%d: proto = 0x%x, version=%d conreqs=%d\n", fs_e, vmp->m_proto,
VFS_FS_PROTO_VERSION(vmp->m_proto), VFS_FS_PROTO_CONREQS(vmp->m_proto));
- res_nodep->fmode = m.RES_MODE;
+ res_nodep->fmode = (mode_t) m.RES_MODE;
res_nodep->fsize = m.RES_FILE_SIZE_LO;
- res_nodep->uid = m.RES_UID;
- res_nodep->gid = m.RES_GID;
+ res_nodep->uid = (uid_t) m.RES_UID;
+ res_nodep->gid = (gid_t) m.RES_GID;
}
return(r);
/* Fill in request message */
m.m_type = rw_flag == READING ? REQ_READ : REQ_WRITE;
- m.REQ_INODE_NR = inode_nr;
+ m.REQ_INODE_NR = (pino_t) inode_nr;
m.REQ_GRANT = grant_id;
m.REQ_SEEK_POS_LO = ex64lo(pos);
m.REQ_SEEK_POS_HI = 0; /* Not used for now, so clear it. */
/* Fill in request message */
m.m_type = REQ_RENAME;
- m.REQ_REN_OLD_DIR = old_dir;
- m.REQ_REN_NEW_DIR = new_dir;
+ m.REQ_REN_OLD_DIR = (pino_t) old_dir;
+ m.REQ_REN_NEW_DIR = (pino_t) new_dir;
m.REQ_REN_GRANT_OLD = gid_old;
m.REQ_REN_LEN_OLD = len_old;
m.REQ_REN_GRANT_NEW = gid_new;
/* Fill in request message */
m.m_type = REQ_RMDIR;
- m.REQ_INODE_NR = inode_nr;
+ m.REQ_INODE_NR = (pino_t) inode_nr;
m.REQ_GRANT = grant_id;
m.REQ_PATH_LEN = len;
/* Fill in request message */
m.m_type = REQ_SLINK;
- m.REQ_INODE_NR = inode_nr;
- m.REQ_UID = uid;
- m.REQ_GID = gid;
+ m.REQ_INODE_NR = (pino_t) inode_nr;
+ m.REQ_UID = (puid_t) uid;
+ m.REQ_GID = (pgid_t) gid;
m.REQ_GRANT = gid_name;
m.REQ_PATH_LEN = len;
m.REQ_GRANT3 = gid_buf;
/* Fill in request message */
m.m_type = REQ_STAT;
- m.REQ_INODE_NR = inode_nr;
+ m.REQ_INODE_NR = (pino_t) inode_nr;
m.REQ_GRANT = grant_id;
/* Send/rec request */
/* Fill in request message */
m.m_type = REQ_UNLINK;
- m.REQ_INODE_NR = inode_nr;
+ m.REQ_INODE_NR = (pino_t) inode_nr;
m.REQ_GRANT = grant_id;
m.REQ_PATH_LEN = len;
/* Fill in request message */
m.m_type = REQ_UTIME;
+ m.REQ_INODE_NR = (pino_t) inode_nr;
m.REQ_INODE_NR = inode_nr;
m.REQ_ACTIME = actimespec->tv_sec;
m.REQ_MODTIME = modtimespec->tv_sec;