Exercise 8.8. Write a routine bfree(p,n) that will free any arbitrary block p of n characters into the free list maintained by malloc and free.

Exercise 8.8. Write a routine bfree(p,n) that will free any arbitrary block p of n characters into the free list maintained by malloc and free. By using bfree, a user can add a static or external array to the free list at any time.








unsigned bfree(char *p, unsigned n)
{
    Header *hp;
   
    if(n < sizeof(Header))
        return 0;
    hp = (Header *) p;
    hp->s.size = n / sizeof(Header);
    free((void *) (hp + 1));
    return hp->s.size;
}

Exercise 8.7. malloc accepts a size request without checking its plausibility; free believes that the block it is asked to free contains a valid size field. Improve these routines so they make more pains with error checking.

Exercise 8.7. malloc accepts a size request without checking its plausibility; free believes that the block it is asked to free contains a valid size field. Improve these routines so they  make more pains with error checking.






#include <stdio.h>
#include <stdlib.h>

#define MAXBYT 10240

typedef long Align; //for alignment to long boundary
union header
{
    struct  //block header
    {
        union header *ptr; //next block if on free list
        unsigned size;      //size of this block
    } s;
    Align x; //force alignment of blocks
};

typedef union header Header;

static Header base; //empty list to get started
static Header *freep = NULL; //start of free list
static Header *morecore(unsigned nu);
static Header *freeptr;
static Header *prevptr;
static unsigned maxalloc; //max bytes

/* malloc: universal storage allocator */
void *_malloc(unsigned nbytes)
{
    Header *p, *prevp;
    Header *moreroce(unsigned);
    unsigned nunits;
   
    if(nbytes > MAXBYT)
    {
        fprintf(stderr, "alloc: i can`t allocate more than %d bytes/n",
                    MAXBYT);
        return NULL;
    }   
    nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
    if((prevp = freep) == NULL) //no free list yet
    {
        base.s.ptr = freeptr = prevptr = &base;
        base.s.size = 0;
    }
    for(p = prevp->s.ptr; ;prevp = p, p = p->s.ptr)
    {
        if(p->s.size >= nunits) //big enough
        {
            if(p->s.size == nunits) //exactly
                prevp->s.ptr = p->s.ptr;
            else //allocate tail end
            {
                p->s.size -= nunits;
                p += p->s.size;
                p->s.size = nunits;
            }
            freep = prevp;
            return (void *) (p+1);
        }
        if(p == freep) //wrapped around free list
            if((p = morecore(nunits)) == NULL)
                return NULL; // non left
    }
}

#define NALLOC 1024 //minimum units to request
/* morecore: ask system for more memory */
static Header *morecore(unsigned nu)
{
    char *cp, *sbrk(int);
    Header *up;
   
    if(nu < NALLOC)
        nu = NALLOC;
    cp = sbrk(nu * sizeof(Header));
    if(cp == (char *) -1) //no space at all
        return NULL;
    up = (Header *) cp;
    up->s.size = nu;
    maxalloc = (up->s.size > maxalloc) ? up->s.size : maxalloc;
    free((void *) (up + 1));
    return freep;
}

/* free: put block ap in free list */
void free(void *ap)
{
    Header *bp, *p;
   
    bp = (Header *) ap - 1; // point to block header
    if(bp->s.size == 0 || bp->s.size > maxalloc)
    {
        fprintf(stderr, "alloc: i can`t allocate more than %d bytes/n",
                    MAXBYT);
        return;
    }   
    for (p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
        if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
            break; //freed block at start or end of arena
    if(bp + bp->s.size == p->s.ptr) //join to upper nbr
    {
        bp->s.size +=p->s.ptr->s.size;
        bp->s.ptr = p->s.ptr->s.ptr;
    }
    else
        bp->s.ptr = p->s.ptr;
    if(p + p->s.size == bp) //join to lower nbr
    {
        p->s.size += bp->s.size;
        p->s.ptr = bp->s.ptr;
    }
    else
        p->s.ptr = bp;
    freep = p;
}

Exercise 8.6. The standard library function calloc(n,size) returns a pointer to n objects of size size, with the storage initialized to zero

Exercise 8.6. The standard library function calloc(n,size) returns a pointer to n objects of
size size, with the storage initialized to zero. Write calloc, by calling malloc or by
modifying it.









#include <stdio.h>
#include <stdlib.h>

/* calloc */
void _calloc(unsigned n, unsigned size)
{
    unsigned i, nsize;
    char *p, *q;
   
    nsize = n * size;
    if((p = q = malloc(nsize)) != NULL)
        for(i = 0; i < nsize; i++)
            *q++=0;
    return p;
}

Exercise 8.5. Modify the fsize program to print the other information contained in the inode entry

Exercise 8.5. Modify the fsize program to print the other information contained in the inode entry.



#include <stdio.h>
#include <string.h>
#include <sys/stat.h> //structure returned by stat
#include <sys/types.h> //typedefs
#include <sys/syscall.h>
#include <fcntl.h> //flags for read and write
#include <dirent.h>
#include <sys/dir.h> //local directory structure

int stat(char *, struct stat *);
void dirwalk(char *, void (*fcn) (char *));

/* fsize: print file "name" size */
void fsize(char *name)
{
    struct stat stbuf;
   
    stat(name, &stbuf) == -1)
    {
        fprintf(stderr, "fsize: can`t acces %s\n", name);
        return;
    }
    if(stbuf.st_mode & S_IFMT) == S_IFDIR)
        dirwalk(name, fsize);
    printf("%8ld %s\n%u %ld\n", stbuf.st_size, name,  stbuf.st_uid,stbuf.st_mtime);
}

Exercise 8.4.Write int fseek(FILE *fp, long offset, int origin).

Exercise 8.4. The standard library function int fseek(FILE *fp, long offset, int origin) is identical to lseek except that fp is a file pointer instead of a file descriptor and return value is an int status, not a position. Write fseek.



/* fseek: random access using file pointer */
int _fseek(_FILE *fp, long offset, int origin)
{
    unsigned nc; //discharged characters
    long rc = 0; //return code
   
    if(fp->flag.f_read)
    {
        if(origin == 1)
            offset -= fp->cnt;
        rc = lseek(fp->fd, offset, origin);
        fp->cnt = 0; //buffer is empty
    }
    else if(fp->flag.f_write)
    {
        if((nc = fp->ptr - fp->base) > 0)
            if(write(fp->fd, fp->base, nc) != nc)
                rc = -1;
        if(rc != -1) // no error
            rc = lseek(fp->fd, offset, origin);
    }
    return (rc == -1) ? -1 : 0;
}

Exercise 8.3. Design and write _flushbuf, fflush, and fclose

Exercise 8.3. Design and write _flushbuf, fflush, and fclose.



/* _flushbuf: selects or clears the input buffer */
int _flushbuf(int x, _FILE *fp)
{
    unsigned nc; //amount discharged characters
    int bufsize; //size of the allocated buffer
   
    if (fp < _iob || fp >= _iob + OPEN_MAX)
        return EOF; //wrong pointer
    if(fp->flag.f_write == 0 || fp->flag.f_err == 1)
        return EOF;
    bufsize = (fp->flag.f_unbuf == 1) ? 1 : BUFSIZ;
    if(fp->base == NULL) //buffer is not yet
    {
        if((fp->base = (char *) malloc(bufsize)) == NULL)
        {
            fp->flag.f_err = 1;
            return EOF; //can not takes buffer
        }
    }
    else //buffer is already
    {
        nc = fp->ptr - fp->base;
        if(write(fp->fd, fp->base, nc) != nc)
        {
            fp->flag.f_err = 1;
            return EOF;//error, return EOF
        }
    }
    fp->ptr = fp->base; //beginning of the buffer
    *fp->ptr++=(char)x;
    fp->cnt = bufsize - 1;
    return x;
}

/* fclose: closed the file */
int _fclose(_FILE *fp)
{
    int rc; //return code
   
    if((rc = _fflush(fp)) != EOF)
    {
        free(fp->base); // release memory buffer
        fp->ptr = NULL;
        fp->cnt = 0;
        fp->base = NULL;
        fp->flag.f_unbuf = 0;
        fp->flag.f_buf = 1;
        fp->flag.f_eof = 0;
        fp->flag.f_err = 0;
        fp->flag.f_read = 0;
        fp->flag.f_write = 0; 
    }
    return rc;
}

/* fflush: reset the buffer corresponding to the file */
int _fflush(_FILE *fp)
{
    int rc = 0;
   
    if(fp < _iob || fp >= _iob + OPEN_MAX)
        return EOF; //wrong pointer
    if(fp->flag.f_write)
        rc = _flushbuf(0, fp);
    fp->ptr = fp->base;
    fp->cnt = (fp->flag.f_unbuf == 1) ? 1 : BUFSIZ;
    return rc;
}

Exercise 8.2. Rewrite fopen and _fillbuf with fields instead of explicit bit operations.

Exercise 8.2. Rewrite fopen and _fillbuf with fields instead of explicit bit operations.
Compare code size and execution speed.








#include <stdio.h>
#include <fcntl.h>
#include <stdlib.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <unistd.h>

#define PERMS 0666 //read/write for all

#define EOF (-1)
#define OPEN_MAX 20

struct flag_field
{
    unsigned f_read : 1;
    unsigned f_write : 1;
    unsigned f_unbuf : 1;
    unsigned f_buf : 1;
    unsigned f_eof : 1;
    unsigned f_err : 1;
} flag;


typedef struct _iobuf
{
    int cnt; //the number of remaining characters
    char *ptr; //position next symvol
    char *base; //buffer address
    struct flag_field flag; //access mode
    int fd; // file descriptor
} _FILE;

extern _FILE _iob[OPEN_MAX];

_FILE _iob[OPEN_MAX] = { /* stdin, stdout, stderr */
    {0, (char *) 0, (char *) 0, {1,0,0,0,0}, 0},
    {0, (char *) 0, (char *) 0, {0,1,0,0,0}, 1},
    {0, (char *) 0, (char *) 0, {0,1,1,0,0}, 2}
};

/* fopen: open the file, return file's point */
_FILE *_fopen(char *name, char *mode)
{
    int fd;
    _FILE *fp;
   
   
   
    if(*mode != 'r' && *mode != 'w' && *mode != 'a')
        return NULL;
    for(fp = _iob; fp< _iob + OPEN_MAX; fp++)
        if(fp->flag.f_read == 0 && fp->flag.f_write == 0)
            break; //find free position
    if(fp>=_iob + OPEN_MAX)
        return NULL; // no free position
    if(*mode == 'w') //makes file
        fd = creat(name, PERMS);
    else if(*mode == 'a')
    {
        if((fd = open(name, O_WRONLY, 0)) == -1)
            fd = creat(name, PERMS);
        lseek(fd, 0L, 2);
    }
    else
        fd = open(name, O_RDONLY, 0);
    if(fd == -1) //not open the file "name"
        return 0;
    fp->fd = fd;
    fp->cnt = 0;
    fp->base = 0;
    fp->flag.f_unbuf = 0;
    fp->flag.f_buf = 1;
    fp->flag.f_eof = 0;
    fp->flag.f_err = 0;
    if(*mode == 'r') //read
    {
        fp->flag.f_read = 1;
        fp->flag.f_write = 0;
    }
    else //write
    {
        fp->flag.f_read = 0;
        fp->flag.f_write = 1;
    }
    return fp;
}

/* _fillbuf: identify and fill the input buffer */
int _fillbuf(_FILE *fp)
{
    int bufsize;
   
    if(fp->flag.f_read == 0 || fp->flag.f_eof == 1 ||
        fp->flag.f_err == 1)
        return EOF;
    bufsize = (fp->flag.f_unbuf == 1) ? 1 : BUFSIZ;
    if (fp->base == NULL) // buffer isn`t yet
        if((fp->base = (char *) malloc(bufsize)) == NULL)
            return EOF; // can`t allocate memory
    fp->ptr = fp->base;
    fp->cnt = read(fp->fd, fp->ptr, bufsize);
    if(--fp->cnt < 0)
    {
        if(fp->cnt == -1)
            fp->flag.f_eof = 1;
        else
            fp->flag.f_err = 1;
        fp->cnt = 0;
        return EOF;
    }
    return (unsigned char) *fp->ptr++;
}

Exercise 8.1. Rewrite the program cat from Chapter 7 using read, write, open, and close instead of their standard library equivalents

Exercise 8.1. Rewrite the program cat from Chapter 7 using read, write, open, and close instead of their standard library equivalents. Perform experiments to determine the relative speeds of the two versions.


#include <stdio.h>
#include <fcntl.h>
#include "syscalls.h"


/* cat */
int main(int argc, char *argv[])
{
    int fp;
    void filecopy(int ifp, int ofp);
   
    if(argc == 1) //no arguments, default stdin
        filecopy(0, 1);
    else
        while(--argc > 0)
            if((fp = open(*++argv, 0_RDONLY)) == -1)
                error("cat: can`t open the file %s\n", *argv);
            else
            {
                filecopy(fp, 1);
                close(fp);
            }
    return 0;
}

/* filecopy: copy file ifp into file ofp */
void filecopy(int ifp, int ofp)
{
    int n;
    char buf[BUFSIZ];
   
    while((n = read(ifp, buf, BUFSIZ)) > 0)
        if(write(ofp, buf, n) != n)
            error("cat:write error");
}