xfnw/plan9fox
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
plan9fox/sys/src/9/port/cache.c

522 lines
8 KiB
C
Raw Normal View History

Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
#include "u.h"
#include "../port/lib.h"
#include "mem.h"
#include "dat.h"
#include "fns.h"
#include "../port/error.h"
enum
{
NHASH = 128,
kernel: new mount cache this is a new more simple version of the mount cache that does not require dynamic allocations for extends. the Mntcache structure now contains a page bitmap that is used for quick page invalidation. the size of the bitmap is proportional to MAXCACHE. instead of keeping track of cached range in the Extend data structure, we keep all the information in the Page itself. the offset from the page where the cache range starts is in the low PGSHIT bits and the end in the top bits of Page.va. we choose Page.daddr to map 1:1 the Mountcache number and page number (pn) in the Mountcache. to find a page, we first check the bitmap if the page is there and then do a pagelookup() with the daddr key.
2014-12-16 04:41:20 +00:00
NFILE = 4093, /* should be prime */
MAXCACHE = 8*1024*1024,
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
kernel: new mount cache this is a new more simple version of the mount cache that does not require dynamic allocations for extends. the Mntcache structure now contains a page bitmap that is used for quick page invalidation. the size of the bitmap is proportional to MAXCACHE. instead of keeping track of cached range in the Extend data structure, we keep all the information in the Page itself. the offset from the page where the cache range starts is in the low PGSHIT bits and the end in the top bits of Page.va. we choose Page.daddr to map 1:1 the Mountcache number and page number (pn) in the Mountcache. to find a page, we first check the bitmap if the page is there and then do a pagelookup() with the daddr key.
2014-12-16 04:41:20 +00:00
MAPBITS = 8*sizeof(ulong),
NBITMAP = (PGROUND(MAXCACHE)/BY2PG + MAPBITS-1) / MAPBITS,
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
};
kernel: pipelined read ahead for the mount cache this changes devmnt adding mntrahread() function and some helpers for it to do pipelined sequential read ahead for the mount cache. basically, cread() calls mntrahread() with Mntrah structure and it figures out if we where reading sequentially and if thats the case issues reads of c->iounit size in advance. the read ahead state (Mntrah) is kept in the mount cache so we can handle (read ahead) cache invalidation in the presence of writes.
2015-07-26 03:43:26 +00:00
/* devmnt.c: parallel read ahread implementation */
extern void mntrahinit(Mntrah *rah);
extern long mntrahread(Mntrah *rah, Chan *c, uchar *buf, long len, vlong off);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
typedef struct Mntcache Mntcache;
struct Mntcache
{
kernel: pipelined read ahead for the mount cache this changes devmnt adding mntrahread() function and some helpers for it to do pipelined sequential read ahead for the mount cache. basically, cread() calls mntrahread() with Mntrah structure and it figures out if we where reading sequentially and if thats the case issues reads of c->iounit size in advance. the read ahead state (Mntrah) is kept in the mount cache so we can handle (read ahead) cache invalidation in the presence of writes.
2015-07-26 03:43:26 +00:00
Qid qid;
int dev;
int type;
kernel: new mount cache this is a new more simple version of the mount cache that does not require dynamic allocations for extends. the Mntcache structure now contains a page bitmap that is used for quick page invalidation. the size of the bitmap is proportional to MAXCACHE. instead of keeping track of cached range in the Extend data structure, we keep all the information in the Page itself. the offset from the page where the cache range starts is in the low PGSHIT bits and the end in the top bits of Page.va. we choose Page.daddr to map 1:1 the Mountcache number and page number (pn) in the Mountcache. to find a page, we first check the bitmap if the page is there and then do a pagelookup() with the daddr key.
2014-12-16 04:41:20 +00:00
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
QLock;
kernel: pipelined read ahead for the mount cache this changes devmnt adding mntrahread() function and some helpers for it to do pipelined sequential read ahead for the mount cache. basically, cread() calls mntrahread() with Mntrah structure and it figures out if we where reading sequentially and if thats the case issues reads of c->iounit size in advance. the read ahead state (Mntrah) is kept in the mount cache so we can handle (read ahead) cache invalidation in the presence of writes.
2015-07-26 03:43:26 +00:00
Proc *locked;
ulong nlocked;
kernel: new mount cache this is a new more simple version of the mount cache that does not require dynamic allocations for extends. the Mntcache structure now contains a page bitmap that is used for quick page invalidation. the size of the bitmap is proportional to MAXCACHE. instead of keeping track of cached range in the Extend data structure, we keep all the information in the Page itself. the offset from the page where the cache range starts is in the low PGSHIT bits and the end in the top bits of Page.va. we choose Page.daddr to map 1:1 the Mountcache number and page number (pn) in the Mountcache. to find a page, we first check the bitmap if the page is there and then do a pagelookup() with the daddr key.
2014-12-16 04:41:20 +00:00
Mntcache *hash;
Mntcache *prev;
Mntcache *next;
/* page bitmap of valid pages */
ulong bitmap[NBITMAP];
kernel: pipelined read ahead for the mount cache this changes devmnt adding mntrahread() function and some helpers for it to do pipelined sequential read ahead for the mount cache. basically, cread() calls mntrahread() with Mntrah structure and it figures out if we where reading sequentially and if thats the case issues reads of c->iounit size in advance. the read ahead state (Mntrah) is kept in the mount cache so we can handle (read ahead) cache invalidation in the presence of writes.
2015-07-26 03:43:26 +00:00
/* read ahead state */
Mntrah rah;
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
};
typedef struct Cache Cache;
struct Cache
{
Lock;
kernel: new mount cache this is a new more simple version of the mount cache that does not require dynamic allocations for extends. the Mntcache structure now contains a page bitmap that is used for quick page invalidation. the size of the bitmap is proportional to MAXCACHE. instead of keeping track of cached range in the Extend data structure, we keep all the information in the Page itself. the offset from the page where the cache range starts is in the low PGSHIT bits and the end in the top bits of Page.va. we choose Page.daddr to map 1:1 the Mountcache number and page number (pn) in the Mountcache. to find a page, we first check the bitmap if the page is there and then do a pagelookup() with the daddr key.
2014-12-16 04:41:20 +00:00
Mntcache *alloc;
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
Mntcache *head;
Mntcache *tail;
Mntcache *hash[NHASH];
};
kernel: new pagecache, remove Lock from page, use cmpswap for Ref instead of Lock make the Page stucture less than half its original size by getting rid of the Lock and the lru. The Lock was required to coordinate the unchaining of pages that where both cached and on the lru freelist. now pages have a single next pointer that is used for palloc.head freelist xor for page cache hash chains in Image.pghash[]. cached pages are not on the freelist anymore, but will be reclaimed from images by the pager when the freelist runs out of pages. each Image has its own 512 hash chains for cached page lookup. That is 2MB worth of pages and there should be no collisions for most text images. page reclaiming can be done without holding palloc.lock as the Image is the owner of the page hash chains protected by the Image's lock. reclaiming Image structures can be done quickly by only reclaiming pages from inactive images, that is images which are not currently in use by segments. the Ref structure has no Lock anymore. Only a single long that is atomically incremented or decremnted using cmpswap(). there are various other changes as a consequence code. and lots of pikeshedding, sorry.
2014-06-22 13:12:45 +00:00
Image fscache;
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
static Cache cache;
void
cinit(void)
{
int i;
Mntcache *m;
kernel: remove obsolete comment regarding Mntcache size in */main.c
2014-12-16 07:11:21 +00:00
m = xalloc(sizeof(Mntcache)*NFILE);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
if (m == nil)
panic("cinit: no memory");
kernel: remove obsolete comment regarding Mntcache size in */main.c
2014-12-16 07:11:21 +00:00
cache.alloc = m;
kernel: new mount cache this is a new more simple version of the mount cache that does not require dynamic allocations for extends. the Mntcache structure now contains a page bitmap that is used for quick page invalidation. the size of the bitmap is proportional to MAXCACHE. instead of keeping track of cached range in the Extend data structure, we keep all the information in the Page itself. the offset from the page where the cache range starts is in the low PGSHIT bits and the end in the top bits of Page.va. we choose Page.daddr to map 1:1 the Mountcache number and page number (pn) in the Mountcache. to find a page, we first check the bitmap if the page is there and then do a pagelookup() with the daddr key.
2014-12-16 04:41:20 +00:00
cache.head = m;
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
for(i = 0; i < NFILE-1; i++) {
m->next = m+1;
m->prev = m-1;
m++;
}
cache.tail = m;
kernel: minor changes to mount cache change page cache ids (bid) to uintptr so we use the full address space of Page.daddr. make maxcache offset check consistent in cread(). use consistent types in cupdate() and simplify with goto. make internal functions static. use nil instead of 0 for pointers.
2014-12-15 05:28:27 +00:00
cache.tail->next = nil;
cache.head->prev = nil;
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
fscache.notext = 1;
}
kernel: new mount cache this is a new more simple version of the mount cache that does not require dynamic allocations for extends. the Mntcache structure now contains a page bitmap that is used for quick page invalidation. the size of the bitmap is proportional to MAXCACHE. instead of keeping track of cached range in the Extend data structure, we keep all the information in the Page itself. the offset from the page where the cache range starts is in the low PGSHIT bits and the end in the top bits of Page.va. we choose Page.daddr to map 1:1 the Mountcache number and page number (pn) in the Mountcache. to find a page, we first check the bitmap if the page is there and then do a pagelookup() with the daddr key.
2014-12-16 04:41:20 +00:00
static uintptr
cacheaddr(Mntcache *m, ulong pn)
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
{
kernel: new mount cache this is a new more simple version of the mount cache that does not require dynamic allocations for extends. the Mntcache structure now contains a page bitmap that is used for quick page invalidation. the size of the bitmap is proportional to MAXCACHE. instead of keeping track of cached range in the Extend data structure, we keep all the information in the Page itself. the offset from the page where the cache range starts is in the low PGSHIT bits and the end in the top bits of Page.va. we choose Page.daddr to map 1:1 the Mountcache number and page number (pn) in the Mountcache. to find a page, we first check the bitmap if the page is there and then do a pagelookup() with the daddr key.
2014-12-16 04:41:20 +00:00
uintptr da = pn * NFILE + (m - cache.alloc);
return (da << PGSHIFT) | (da >> (sizeof(da)*8 - PGSHIFT));
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
}
kernel: minor changes to mount cache change page cache ids (bid) to uintptr so we use the full address space of Page.daddr. make maxcache offset check consistent in cread(). use consistent types in cupdate() and simplify with goto. make internal functions static. use nil instead of 0 for pointers.
2014-12-15 05:28:27 +00:00
static void
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
cnodata(Mntcache *m)
{
kernel: new mount cache this is a new more simple version of the mount cache that does not require dynamic allocations for extends. the Mntcache structure now contains a page bitmap that is used for quick page invalidation. the size of the bitmap is proportional to MAXCACHE. instead of keeping track of cached range in the Extend data structure, we keep all the information in the Page itself. the offset from the page where the cache range starts is in the low PGSHIT bits and the end in the top bits of Page.va. we choose Page.daddr to map 1:1 the Mountcache number and page number (pn) in the Mountcache. to find a page, we first check the bitmap if the page is there and then do a pagelookup() with the daddr key.
2014-12-16 04:41:20 +00:00
memset(m->bitmap, 0, sizeof(m->bitmap));
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
}
kernel: minor changes to mount cache change page cache ids (bid) to uintptr so we use the full address space of Page.daddr. make maxcache offset check consistent in cread(). use consistent types in cupdate() and simplify with goto. make internal functions static. use nil instead of 0 for pointers.
2014-12-15 05:28:27 +00:00
static void
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
ctail(Mntcache *m)
{
/* Unlink and send to the tail */
kernel: minor changes to mount cache change page cache ids (bid) to uintptr so we use the full address space of Page.daddr. make maxcache offset check consistent in cread(). use consistent types in cupdate() and simplify with goto. make internal functions static. use nil instead of 0 for pointers.
2014-12-15 05:28:27 +00:00
if(m->prev != nil)
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
m->prev->next = m->next;
else
cache.head = m->next;
kernel: minor changes to mount cache change page cache ids (bid) to uintptr so we use the full address space of Page.daddr. make maxcache offset check consistent in cread(). use consistent types in cupdate() and simplify with goto. make internal functions static. use nil instead of 0 for pointers.
2014-12-15 05:28:27 +00:00
if(m->next != nil)
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
m->next->prev = m->prev;
else
cache.tail = m->prev;
kernel: minor changes to mount cache change page cache ids (bid) to uintptr so we use the full address space of Page.daddr. make maxcache offset check consistent in cread(). use consistent types in cupdate() and simplify with goto. make internal functions static. use nil instead of 0 for pointers.
2014-12-15 05:28:27 +00:00
if(cache.tail != nil) {
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
m->prev = cache.tail;
cache.tail->next = m;
kernel: minor changes to mount cache change page cache ids (bid) to uintptr so we use the full address space of Page.daddr. make maxcache offset check consistent in cread(). use consistent types in cupdate() and simplify with goto. make internal functions static. use nil instead of 0 for pointers.
2014-12-15 05:28:27 +00:00
m->next = nil;
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
cache.tail = m;
}
else {
cache.head = m;
cache.tail = m;
kernel: minor changes to mount cache change page cache ids (bid) to uintptr so we use the full address space of Page.daddr. make maxcache offset check consistent in cread(). use consistent types in cupdate() and simplify with goto. make internal functions static. use nil instead of 0 for pointers.
2014-12-15 05:28:27 +00:00
m->prev = nil;
m->next = nil;
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
}
}
kernel: mnt cache rework avoid double entries in the cache for copen() and properly handle locking so we wont just give up if we cant lock the Mntcache entry, but drop the cache lock, qlock the Mntcache entry, and then recheck the cache. general cleanup (cdev -> ccache, use eqchantdqid())
2012-10-17 13:48:30 +00:00
/* called with cache locked */
static Mntcache*
clookup(Chan *c, int skipvers)
{
Mntcache *m;
kernel: minor changes to mount cache change page cache ids (bid) to uintptr so we use the full address space of Page.daddr. make maxcache offset check consistent in cread(). use consistent types in cupdate() and simplify with goto. make internal functions static. use nil instead of 0 for pointers.
2014-12-15 05:28:27 +00:00
for(m = cache.hash[c->qid.path%NHASH]; m != nil; m = m->hash)
kernel: mnt cache rework avoid double entries in the cache for copen() and properly handle locking so we wont just give up if we cant lock the Mntcache entry, but drop the cache lock, qlock the Mntcache entry, and then recheck the cache. general cleanup (cdev -> ccache, use eqchantdqid())
2012-10-17 13:48:30 +00:00
if(eqchantdqid(c, m->type, m->dev, m->qid, skipvers) && c->qid.type == m->qid.type)
return m;
kernel: minor changes to mount cache change page cache ids (bid) to uintptr so we use the full address space of Page.daddr. make maxcache offset check consistent in cread(). use consistent types in cupdate() and simplify with goto. make internal functions static. use nil instead of 0 for pointers.
2014-12-15 05:28:27 +00:00
return nil;
kernel: mnt cache rework avoid double entries in the cache for copen() and properly handle locking so we wont just give up if we cant lock the Mntcache entry, but drop the cache lock, qlock the Mntcache entry, and then recheck the cache. general cleanup (cdev -> ccache, use eqchantdqid())
2012-10-17 13:48:30 +00:00
}
kernel: pipelined read ahead for the mount cache this changes devmnt adding mntrahread() function and some helpers for it to do pipelined sequential read ahead for the mount cache. basically, cread() calls mntrahread() with Mntrah structure and it figures out if we where reading sequentially and if thats the case issues reads of c->iounit size in advance. the read ahead state (Mntrah) is kept in the mount cache so we can handle (read ahead) cache invalidation in the presence of writes.
2015-07-26 03:43:26 +00:00
/*
* resursive Mntcache locking. Mntcache.rah is protected by the
* same lock and we want to call cupdate() from mntrahread()
* while holding the lock.
*/
static int
cancachelock(Mntcache *m)
{
if(m->locked == up || canqlock(m)){
m->locked = up;
m->nlocked++;
return 1;
}
return 0;
}
static void
cachelock(Mntcache *m)
{
if(m->locked != up){
qlock(m);
assert(m->nlocked == 0);
m->locked = up;
}
m->nlocked++;
}
static void
cacheunlock(Mntcache *m)
{
assert(m->locked == up);
if(--m->nlocked == 0){
m->locked = nil;
qunlock(m);
}
}
/* return locked Mntcache if still valid else reset mcp */
static Mntcache*
ccache(Chan *c)
{
Mntcache *m;
m = c->mcp;
if(m != nil) {
cachelock(m);
if(eqchantdqid(c, m->type, m->dev, m->qid, 0) && c->qid.type == m->qid.type)
return m;
c->mcp = nil;
cacheunlock(m);
}
return nil;
}
kernel: make the mntcache robust against fileserver like fossil that do not change the qid.vers on wstat introducing new ctrunc() function that invalidates any caches for the passed in chan, invoked when handling wstat with a specified file length or on file creation/truncation. test program to reproduce the problem: #include <u.h> #include <libc.h> #include <libsec.h> void main(int argc, char *argv[]) { int fd; Dir *d, nd; fd = create("xxx", ORDWR, 0666); write(fd, "1234", 4); d = dirstat("xxx"); assert(d->length == 4); nulldir(&nd); nd.length = 0; dirwstat("xxx", &nd); d = dirstat("xxx"); assert(d->length == 0); fd = open("xxx", OREAD); assert(read(fd, (void*)&d, 4) == 0); }
2017-01-12 19:13:20 +00:00
int
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
copen(Chan *c)
{
Mntcache *m, *f, **l;
kernel: pipelined read ahead for the mount cache this changes devmnt adding mntrahread() function and some helpers for it to do pipelined sequential read ahead for the mount cache. basically, cread() calls mntrahread() with Mntrah structure and it figures out if we where reading sequentially and if thats the case issues reads of c->iounit size in advance. the read ahead state (Mntrah) is kept in the mount cache so we can handle (read ahead) cache invalidation in the presence of writes.
2015-07-26 03:43:26 +00:00
/* directories aren't cacheable */
if(c->qid.type&QTDIR){
kernel: minor changes to mount cache change page cache ids (bid) to uintptr so we use the full address space of Page.daddr. make maxcache offset check consistent in cread(). use consistent types in cupdate() and simplify with goto. make internal functions static. use nil instead of 0 for pointers.
2014-12-15 05:28:27 +00:00
c->mcp = nil;
kernel: make the mntcache robust against fileserver like fossil that do not change the qid.vers on wstat introducing new ctrunc() function that invalidates any caches for the passed in chan, invoked when handling wstat with a specified file length or on file creation/truncation. test program to reproduce the problem: #include <u.h> #include <libc.h> #include <libsec.h> void main(int argc, char *argv[]) { int fd; Dir *d, nd; fd = create("xxx", ORDWR, 0666); write(fd, "1234", 4); d = dirstat("xxx"); assert(d->length == 4); nulldir(&nd); nd.length = 0; dirwstat("xxx", &nd); d = dirstat("xxx"); assert(d->length == 0); fd = open("xxx", OREAD); assert(read(fd, (void*)&d, 4) == 0); }
2017-01-12 19:13:20 +00:00
return 0;
kernel: mnt cache rework avoid double entries in the cache for copen() and properly handle locking so we wont just give up if we cant lock the Mntcache entry, but drop the cache lock, qlock the Mntcache entry, and then recheck the cache. general cleanup (cdev -> ccache, use eqchantdqid())
2012-10-17 13:48:30 +00:00
}
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
lock(&cache);
kernel: make the mntcache robust against fileserver like fossil that do not change the qid.vers on wstat introducing new ctrunc() function that invalidates any caches for the passed in chan, invoked when handling wstat with a specified file length or on file creation/truncation. test program to reproduce the problem: #include <u.h> #include <libc.h> #include <libsec.h> void main(int argc, char *argv[]) { int fd; Dir *d, nd; fd = create("xxx", ORDWR, 0666); write(fd, "1234", 4); d = dirstat("xxx"); assert(d->length == 4); nulldir(&nd); nd.length = 0; dirwstat("xxx", &nd); d = dirstat("xxx"); assert(d->length == 0); fd = open("xxx", OREAD); assert(read(fd, (void*)&d, 4) == 0); }
2017-01-12 19:13:20 +00:00
m = clookup(c, 0);
if(m != nil){
kernel: mnt cache rework avoid double entries in the cache for copen() and properly handle locking so we wont just give up if we cant lock the Mntcache entry, but drop the cache lock, qlock the Mntcache entry, and then recheck the cache. general cleanup (cdev -> ccache, use eqchantdqid())
2012-10-17 13:48:30 +00:00
ctail(m);
unlock(&cache);
c->mcp = m;
kernel: make the mntcache robust against fileserver like fossil that do not change the qid.vers on wstat introducing new ctrunc() function that invalidates any caches for the passed in chan, invoked when handling wstat with a specified file length or on file creation/truncation. test program to reproduce the problem: #include <u.h> #include <libc.h> #include <libsec.h> void main(int argc, char *argv[]) { int fd; Dir *d, nd; fd = create("xxx", ORDWR, 0666); write(fd, "1234", 4); d = dirstat("xxx"); assert(d->length == 4); nulldir(&nd); nd.length = 0; dirwstat("xxx", &nd); d = dirstat("xxx"); assert(d->length == 0); fd = open("xxx", OREAD); assert(read(fd, (void*)&d, 4) == 0); }
2017-01-12 19:13:20 +00:00
return 1;
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
}
kernel: make the mntcache robust against fileserver like fossil that do not change the qid.vers on wstat introducing new ctrunc() function that invalidates any caches for the passed in chan, invoked when handling wstat with a specified file length or on file creation/truncation. test program to reproduce the problem: #include <u.h> #include <libc.h> #include <libsec.h> void main(int argc, char *argv[]) { int fd; Dir *d, nd; fd = create("xxx", ORDWR, 0666); write(fd, "1234", 4); d = dirstat("xxx"); assert(d->length == 4); nulldir(&nd); nd.length = 0; dirwstat("xxx", &nd); d = dirstat("xxx"); assert(d->length == 0); fd = open("xxx", OREAD); assert(read(fd, (void*)&d, 4) == 0); }
2017-01-12 19:13:20 +00:00
m = clookup(c, 1);
if(m == nil)
m = cache.head;
kernel: mnt cache rework avoid double entries in the cache for copen() and properly handle locking so we wont just give up if we cant lock the Mntcache entry, but drop the cache lock, qlock the Mntcache entry, and then recheck the cache. general cleanup (cdev -> ccache, use eqchantdqid())
2012-10-17 13:48:30 +00:00
ctail(m);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
l = &cache.hash[m->qid.path%NHASH];
kernel: minor changes to mount cache change page cache ids (bid) to uintptr so we use the full address space of Page.daddr. make maxcache offset check consistent in cread(). use consistent types in cupdate() and simplify with goto. make internal functions static. use nil instead of 0 for pointers.
2014-12-15 05:28:27 +00:00
for(f = *l; f != nil; f = f->hash) {
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
if(f == m) {
*l = m->hash;
break;
}
l = &f->hash;
}
kernel: pipelined read ahead for the mount cache this changes devmnt adding mntrahread() function and some helpers for it to do pipelined sequential read ahead for the mount cache. basically, cread() calls mntrahread() with Mntrah structure and it figures out if we where reading sequentially and if thats the case issues reads of c->iounit size in advance. the read ahead state (Mntrah) is kept in the mount cache so we can handle (read ahead) cache invalidation in the presence of writes.
2015-07-26 03:43:26 +00:00
if(!cancachelock(m)){
kernel: mnt cache rework avoid double entries in the cache for copen() and properly handle locking so we wont just give up if we cant lock the Mntcache entry, but drop the cache lock, qlock the Mntcache entry, and then recheck the cache. general cleanup (cdev -> ccache, use eqchantdqid())
2012-10-17 13:48:30 +00:00
unlock(&cache);
kernel: pipelined read ahead for the mount cache this changes devmnt adding mntrahread() function and some helpers for it to do pipelined sequential read ahead for the mount cache. basically, cread() calls mntrahread() with Mntrah structure and it figures out if we where reading sequentially and if thats the case issues reads of c->iounit size in advance. the read ahead state (Mntrah) is kept in the mount cache so we can handle (read ahead) cache invalidation in the presence of writes.
2015-07-26 03:43:26 +00:00
cachelock(m);
kernel: mnt cache rework avoid double entries in the cache for copen() and properly handle locking so we wont just give up if we cant lock the Mntcache entry, but drop the cache lock, qlock the Mntcache entry, and then recheck the cache. general cleanup (cdev -> ccache, use eqchantdqid())
2012-10-17 13:48:30 +00:00
lock(&cache);
f = clookup(c, 0);
kernel: minor changes to mount cache change page cache ids (bid) to uintptr so we use the full address space of Page.daddr. make maxcache offset check consistent in cread(). use consistent types in cupdate() and simplify with goto. make internal functions static. use nil instead of 0 for pointers.
2014-12-15 05:28:27 +00:00
if(f != nil) {
kernel: mnt cache rework avoid double entries in the cache for copen() and properly handle locking so we wont just give up if we cant lock the Mntcache entry, but drop the cache lock, qlock the Mntcache entry, and then recheck the cache. general cleanup (cdev -> ccache, use eqchantdqid())
2012-10-17 13:48:30 +00:00
/*
* someone got there first while cache lock
* was released and added a updated Mntcache
* for us. update LRU and use it.
*/
ctail(f);
unlock(&cache);
kernel: pipelined read ahead for the mount cache this changes devmnt adding mntrahread() function and some helpers for it to do pipelined sequential read ahead for the mount cache. basically, cread() calls mntrahread() with Mntrah structure and it figures out if we where reading sequentially and if thats the case issues reads of c->iounit size in advance. the read ahead state (Mntrah) is kept in the mount cache so we can handle (read ahead) cache invalidation in the presence of writes.
2015-07-26 03:43:26 +00:00
cacheunlock(m);
kernel: mnt cache rework avoid double entries in the cache for copen() and properly handle locking so we wont just give up if we cant lock the Mntcache entry, but drop the cache lock, qlock the Mntcache entry, and then recheck the cache. general cleanup (cdev -> ccache, use eqchantdqid())
2012-10-17 13:48:30 +00:00
c->mcp = f;
kernel: make the mntcache robust against fileserver like fossil that do not change the qid.vers on wstat introducing new ctrunc() function that invalidates any caches for the passed in chan, invoked when handling wstat with a specified file length or on file creation/truncation. test program to reproduce the problem: #include <u.h> #include <libc.h> #include <libsec.h> void main(int argc, char *argv[]) { int fd; Dir *d, nd; fd = create("xxx", ORDWR, 0666); write(fd, "1234", 4); d = dirstat("xxx"); assert(d->length == 4); nulldir(&nd); nd.length = 0; dirwstat("xxx", &nd); d = dirstat("xxx"); assert(d->length == 0); fd = open("xxx", OREAD); assert(read(fd, (void*)&d, 4) == 0); }
2017-01-12 19:13:20 +00:00
return 1;
kernel: mnt cache rework avoid double entries in the cache for copen() and properly handle locking so we wont just give up if we cant lock the Mntcache entry, but drop the cache lock, qlock the Mntcache entry, and then recheck the cache. general cleanup (cdev -> ccache, use eqchantdqid())
2012-10-17 13:48:30 +00:00
}
}
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
m->qid = c->qid;
m->dev = c->dev;
m->type = c->type;
kernel: mnt cache rework avoid double entries in the cache for copen() and properly handle locking so we wont just give up if we cant lock the Mntcache entry, but drop the cache lock, qlock the Mntcache entry, and then recheck the cache. general cleanup (cdev -> ccache, use eqchantdqid())
2012-10-17 13:48:30 +00:00
l = &cache.hash[c->qid.path%NHASH];
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
m->hash = *l;
*l = m;
kernel: pipelined read ahead for the mount cache this changes devmnt adding mntrahread() function and some helpers for it to do pipelined sequential read ahead for the mount cache. basically, cread() calls mntrahread() with Mntrah structure and it figures out if we where reading sequentially and if thats the case issues reads of c->iounit size in advance. the read ahead state (Mntrah) is kept in the mount cache so we can handle (read ahead) cache invalidation in the presence of writes.
2015-07-26 03:43:26 +00:00
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
unlock(&cache);
kernel: pipelined read ahead for the mount cache this changes devmnt adding mntrahread() function and some helpers for it to do pipelined sequential read ahead for the mount cache. basically, cread() calls mntrahread() with Mntrah structure and it figures out if we where reading sequentially and if thats the case issues reads of c->iounit size in advance. the read ahead state (Mntrah) is kept in the mount cache so we can handle (read ahead) cache invalidation in the presence of writes.
2015-07-26 03:43:26 +00:00
m->rah.vers = m->qid.vers;
mntrahinit(&m->rah);
kernel: make mntcache effective, be carefull
2011-12-22 01:17:29 +00:00
cnodata(m);
kernel: pipelined read ahead for the mount cache this changes devmnt adding mntrahread() function and some helpers for it to do pipelined sequential read ahead for the mount cache. basically, cread() calls mntrahread() with Mntrah structure and it figures out if we where reading sequentially and if thats the case issues reads of c->iounit size in advance. the read ahead state (Mntrah) is kept in the mount cache so we can handle (read ahead) cache invalidation in the presence of writes.
2015-07-26 03:43:26 +00:00
cacheunlock(m);
c->mcp = m;
kernel: make the mntcache robust against fileserver like fossil that do not change the qid.vers on wstat introducing new ctrunc() function that invalidates any caches for the passed in chan, invoked when handling wstat with a specified file length or on file creation/truncation. test program to reproduce the problem: #include <u.h> #include <libc.h> #include <libsec.h> void main(int argc, char *argv[]) { int fd; Dir *d, nd; fd = create("xxx", ORDWR, 0666); write(fd, "1234", 4); d = dirstat("xxx"); assert(d->length == 4); nulldir(&nd); nd.length = 0; dirwstat("xxx", &nd); d = dirstat("xxx"); assert(d->length == 0); fd = open("xxx", OREAD); assert(read(fd, (void*)&d, 4) == 0); }
2017-01-12 19:13:20 +00:00
return 0;
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
}
kernel: get rid of auxpage() and preserve cache index bits in Page.va in mount cache the mount cache uses Page.va to store cached range offset and limit, but mips kernel uses cache index bits from Page.va to maintain page coloring. Page.va was not initialized by auxpage(). this change removes auxpage() which was primarily used only by the mount cache and use newpage() with cache file offset page as va so we will get a page of the right color. mount cache keeps the index bits intact by only using the top and buttom PGSHIFT bits of Page.va for the range offset/limit.
2015-03-16 04:46:08 +00:00
enum {
VABITS = 8*sizeof(uintptr) - 2*PGSHIFT,
VAMASK = (((uintptr)1 << VABITS)-1) << PGSHIFT,
};
kernel: new mount cache this is a new more simple version of the mount cache that does not require dynamic allocations for extends. the Mntcache structure now contains a page bitmap that is used for quick page invalidation. the size of the bitmap is proportional to MAXCACHE. instead of keeping track of cached range in the Extend data structure, we keep all the information in the Page itself. the offset from the page where the cache range starts is in the low PGSHIT bits and the end in the top bits of Page.va. we choose Page.daddr to map 1:1 the Mountcache number and page number (pn) in the Mountcache. to find a page, we first check the bitmap if the page is there and then do a pagelookup() with the daddr key.
2014-12-16 04:41:20 +00:00
static Page*
cpage(Mntcache *m, ulong pn, ulong *po, ulong *pe)
{
ulong b;
Page *p;
b = 1 << (pn%MAPBITS);
if((m->bitmap[pn/MAPBITS] & b) == 0)
return nil;
p = lookpage(&fscache, cacheaddr(m, pn));
if(p == nil){
m->bitmap[pn/MAPBITS] &= ~b;
return nil;
}
kernel: get rid of auxpage() and preserve cache index bits in Page.va in mount cache the mount cache uses Page.va to store cached range offset and limit, but mips kernel uses cache index bits from Page.va to maintain page coloring. Page.va was not initialized by auxpage(). this change removes auxpage() which was primarily used only by the mount cache and use newpage() with cache file offset page as va so we will get a page of the right color. mount cache keeps the index bits intact by only using the top and buttom PGSHIFT bits of Page.va for the range offset/limit.
2015-03-16 04:46:08 +00:00
*po = p->va & (BY2PG-1);
*pe = 1 + (p->va >> (PGSHIFT+VABITS));
assert(*po < *pe);
kernel: new mount cache this is a new more simple version of the mount cache that does not require dynamic allocations for extends. the Mntcache structure now contains a page bitmap that is used for quick page invalidation. the size of the bitmap is proportional to MAXCACHE. instead of keeping track of cached range in the Extend data structure, we keep all the information in the Page itself. the offset from the page where the cache range starts is in the low PGSHIT bits and the end in the top bits of Page.va. we choose Page.daddr to map 1:1 the Mountcache number and page number (pn) in the Mountcache. to find a page, we first check the bitmap if the page is there and then do a pagelookup() with the daddr key.
2014-12-16 04:41:20 +00:00
return p;
}
kernel: get rid of auxpage() and preserve cache index bits in Page.va in mount cache the mount cache uses Page.va to store cached range offset and limit, but mips kernel uses cache index bits from Page.va to maintain page coloring. Page.va was not initialized by auxpage(). this change removes auxpage() which was primarily used only by the mount cache and use newpage() with cache file offset page as va so we will get a page of the right color. mount cache keeps the index bits intact by only using the top and buttom PGSHIFT bits of Page.va for the range offset/limit.
2015-03-16 04:46:08 +00:00
static void
cpageset(Page *p, ulong po, ulong pe)
{
assert(po < pe);
p->va = po | (p->va & VAMASK) | ((uintptr)pe - 1) << (PGSHIFT+VABITS);
}
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
int
cread(Chan *c, uchar *buf, int len, vlong off)
{
KMap *k;
Page *p;
Mntcache *m;
kernel: pipelined read ahead for the mount cache this changes devmnt adding mntrahread() function and some helpers for it to do pipelined sequential read ahead for the mount cache. basically, cread() calls mntrahread() with Mntrah structure and it figures out if we where reading sequentially and if thats the case issues reads of c->iounit size in advance. the read ahead state (Mntrah) is kept in the mount cache so we can handle (read ahead) cache invalidation in the presence of writes.
2015-07-26 03:43:26 +00:00
int l, tot;
kernel: new mount cache this is a new more simple version of the mount cache that does not require dynamic allocations for extends. the Mntcache structure now contains a page bitmap that is used for quick page invalidation. the size of the bitmap is proportional to MAXCACHE. instead of keeping track of cached range in the Extend data structure, we keep all the information in the Page itself. the offset from the page where the cache range starts is in the low PGSHIT bits and the end in the top bits of Page.va. we choose Page.daddr to map 1:1 the Mountcache number and page number (pn) in the Mountcache. to find a page, we first check the bitmap if the page is there and then do a pagelookup() with the daddr key.
2014-12-16 04:41:20 +00:00
ulong offset, pn, po, pe;
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
kernel: pipelined read ahead for the mount cache this changes devmnt adding mntrahread() function and some helpers for it to do pipelined sequential read ahead for the mount cache. basically, cread() calls mntrahread() with Mntrah structure and it figures out if we where reading sequentially and if thats the case issues reads of c->iounit size in advance. the read ahead state (Mntrah) is kept in the mount cache so we can handle (read ahead) cache invalidation in the presence of writes.
2015-07-26 03:43:26 +00:00
if(len <= 0)
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
return 0;
kernel: mnt cache rework avoid double entries in the cache for copen() and properly handle locking so we wont just give up if we cant lock the Mntcache entry, but drop the cache lock, qlock the Mntcache entry, and then recheck the cache. general cleanup (cdev -> ccache, use eqchantdqid())
2012-10-17 13:48:30 +00:00
m = ccache(c);
kernel: minor changes to mount cache change page cache ids (bid) to uintptr so we use the full address space of Page.daddr. make maxcache offset check consistent in cread(). use consistent types in cupdate() and simplify with goto. make internal functions static. use nil instead of 0 for pointers.
2014-12-15 05:28:27 +00:00
if(m == nil)
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
return 0;
kernel: pipelined read ahead for the mount cache this changes devmnt adding mntrahread() function and some helpers for it to do pipelined sequential read ahead for the mount cache. basically, cread() calls mntrahread() with Mntrah structure and it figures out if we where reading sequentially and if thats the case issues reads of c->iounit size in advance. the read ahead state (Mntrah) is kept in the mount cache so we can handle (read ahead) cache invalidation in the presence of writes.
2015-07-26 03:43:26 +00:00
if(waserror()){
cacheunlock(m);
nexterror();
}
tot = 0;
if(off >= MAXCACHE)
goto Prefetch;
kernel: new mount cache this is a new more simple version of the mount cache that does not require dynamic allocations for extends. the Mntcache structure now contains a page bitmap that is used for quick page invalidation. the size of the bitmap is proportional to MAXCACHE. instead of keeping track of cached range in the Extend data structure, we keep all the information in the Page itself. the offset from the page where the cache range starts is in the low PGSHIT bits and the end in the top bits of Page.va. we choose Page.daddr to map 1:1 the Mountcache number and page number (pn) in the Mountcache. to find a page, we first check the bitmap if the page is there and then do a pagelookup() with the daddr key.
2014-12-16 04:41:20 +00:00
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
offset = off;
kernel: new mount cache this is a new more simple version of the mount cache that does not require dynamic allocations for extends. the Mntcache structure now contains a page bitmap that is used for quick page invalidation. the size of the bitmap is proportional to MAXCACHE. instead of keeping track of cached range in the Extend data structure, we keep all the information in the Page itself. the offset from the page where the cache range starts is in the low PGSHIT bits and the end in the top bits of Page.va. we choose Page.daddr to map 1:1 the Mountcache number and page number (pn) in the Mountcache. to find a page, we first check the bitmap if the page is there and then do a pagelookup() with the daddr key.
2014-12-16 04:41:20 +00:00
if(offset+len > MAXCACHE)
len = MAXCACHE - offset;
pn = offset / BY2PG;
offset &= (BY2PG-1);
while(len > 0){
p = cpage(m, pn, &po, &pe);
if(p == nil)
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
break;
kernel: get rid of auxpage() and preserve cache index bits in Page.va in mount cache the mount cache uses Page.va to store cached range offset and limit, but mips kernel uses cache index bits from Page.va to maintain page coloring. Page.va was not initialized by auxpage(). this change removes auxpage() which was primarily used only by the mount cache and use newpage() with cache file offset page as va so we will get a page of the right color. mount cache keeps the index bits intact by only using the top and buttom PGSHIFT bits of Page.va for the range offset/limit.
2015-03-16 04:46:08 +00:00
if(offset < po || offset >= pe){
kernel: new mount cache this is a new more simple version of the mount cache that does not require dynamic allocations for extends. the Mntcache structure now contains a page bitmap that is used for quick page invalidation. the size of the bitmap is proportional to MAXCACHE. instead of keeping track of cached range in the Extend data structure, we keep all the information in the Page itself. the offset from the page where the cache range starts is in the low PGSHIT bits and the end in the top bits of Page.va. we choose Page.daddr to map 1:1 the Mountcache number and page number (pn) in the Mountcache. to find a page, we first check the bitmap if the page is there and then do a pagelookup() with the daddr key.
2014-12-16 04:41:20 +00:00
putpage(p);
kernel: minor changes to mount cache change page cache ids (bid) to uintptr so we use the full address space of Page.daddr. make maxcache offset check consistent in cread(). use consistent types in cupdate() and simplify with goto. make internal functions static. use nil instead of 0 for pointers.
2014-12-15 05:28:27 +00:00
break;
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
}
kernel: new mount cache this is a new more simple version of the mount cache that does not require dynamic allocations for extends. the Mntcache structure now contains a page bitmap that is used for quick page invalidation. the size of the bitmap is proportional to MAXCACHE. instead of keeping track of cached range in the Extend data structure, we keep all the information in the Page itself. the offset from the page where the cache range starts is in the low PGSHIT bits and the end in the top bits of Page.va. we choose Page.daddr to map 1:1 the Mountcache number and page number (pn) in the Mountcache. to find a page, we first check the bitmap if the page is there and then do a pagelookup() with the daddr key.
2014-12-16 04:41:20 +00:00
l = pe - offset;
if(l > len)
l = len;
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
k = kmap(p);
if(waserror()) {
kunmap(k);
putpage(p);
nexterror();
}
kernel: new mount cache this is a new more simple version of the mount cache that does not require dynamic allocations for extends. the Mntcache structure now contains a page bitmap that is used for quick page invalidation. the size of the bitmap is proportional to MAXCACHE. instead of keeping track of cached range in the Extend data structure, we keep all the information in the Page itself. the offset from the page where the cache range starts is in the low PGSHIT bits and the end in the top bits of Page.va. we choose Page.daddr to map 1:1 the Mountcache number and page number (pn) in the Mountcache. to find a page, we first check the bitmap if the page is there and then do a pagelookup() with the daddr key.
2014-12-16 04:41:20 +00:00
memmove(buf, (uchar*)VA(k) + offset, l);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
kunmap(k);
putpage(p);
kernel: pipelined read ahead for the mount cache this changes devmnt adding mntrahread() function and some helpers for it to do pipelined sequential read ahead for the mount cache. basically, cread() calls mntrahread() with Mntrah structure and it figures out if we where reading sequentially and if thats the case issues reads of c->iounit size in advance. the read ahead state (Mntrah) is kept in the mount cache so we can handle (read ahead) cache invalidation in the presence of writes.
2015-07-26 03:43:26 +00:00
poperror();
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
kernel: pipelined read ahead for the mount cache this changes devmnt adding mntrahread() function and some helpers for it to do pipelined sequential read ahead for the mount cache. basically, cread() calls mntrahread() with Mntrah structure and it figures out if we where reading sequentially and if thats the case issues reads of c->iounit size in advance. the read ahead state (Mntrah) is kept in the mount cache so we can handle (read ahead) cache invalidation in the presence of writes.
2015-07-26 03:43:26 +00:00
tot += l;
buf += l;
len -= l;
kernel: new mount cache this is a new more simple version of the mount cache that does not require dynamic allocations for extends. the Mntcache structure now contains a page bitmap that is used for quick page invalidation. the size of the bitmap is proportional to MAXCACHE. instead of keeping track of cached range in the Extend data structure, we keep all the information in the Page itself. the offset from the page where the cache range starts is in the low PGSHIT bits and the end in the top bits of Page.va. we choose Page.daddr to map 1:1 the Mountcache number and page number (pn) in the Mountcache. to find a page, we first check the bitmap if the page is there and then do a pagelookup() with the daddr key.
2014-12-16 04:41:20 +00:00
offset += l;
offset &= (BY2PG-1);
if(offset != 0)
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
break;
kernel: new mount cache this is a new more simple version of the mount cache that does not require dynamic allocations for extends. the Mntcache structure now contains a page bitmap that is used for quick page invalidation. the size of the bitmap is proportional to MAXCACHE. instead of keeping track of cached range in the Extend data structure, we keep all the information in the Page itself. the offset from the page where the cache range starts is in the low PGSHIT bits and the end in the top bits of Page.va. we choose Page.daddr to map 1:1 the Mountcache number and page number (pn) in the Mountcache. to find a page, we first check the bitmap if the page is there and then do a pagelookup() with the daddr key.
2014-12-16 04:41:20 +00:00
pn++;
}
kernel: pipelined read ahead for the mount cache this changes devmnt adding mntrahread() function and some helpers for it to do pipelined sequential read ahead for the mount cache. basically, cread() calls mntrahread() with Mntrah structure and it figures out if we where reading sequentially and if thats the case issues reads of c->iounit size in advance. the read ahead state (Mntrah) is kept in the mount cache so we can handle (read ahead) cache invalidation in the presence of writes.
2015-07-26 03:43:26 +00:00
Prefetch:
if(len > 0){
if(m->rah.vers != m->qid.vers){
mntrahinit(&m->rah);
m->rah.vers = m->qid.vers;
}
off += tot;
tot += mntrahread(&m->rah, c, buf, len, off);
}
cacheunlock(m);
poperror();
return tot;
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
}
kernel: new mount cache this is a new more simple version of the mount cache that does not require dynamic allocations for extends. the Mntcache structure now contains a page bitmap that is used for quick page invalidation. the size of the bitmap is proportional to MAXCACHE. instead of keeping track of cached range in the Extend data structure, we keep all the information in the Page itself. the offset from the page where the cache range starts is in the low PGSHIT bits and the end in the top bits of Page.va. we choose Page.daddr to map 1:1 the Mountcache number and page number (pn) in the Mountcache. to find a page, we first check the bitmap if the page is there and then do a pagelookup() with the daddr key.
2014-12-16 04:41:20 +00:00
/* invalidate pages in page bitmap */
static void
invalidate(Mntcache *m, ulong offset, int len)
{
ulong pn;
for(pn = offset/BY2PG; len > 0; pn++, len -= BY2PG)
m->bitmap[pn/MAPBITS] &= ~(1 << (pn%MAPBITS));
}
/* replace buf data from [off, off+len) in the cache or invalidate */
static void
cachedata(Mntcache *m, uchar *buf, int len, vlong off)
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
{
int l;
Page *p;
KMap *k;
kernel: new mount cache this is a new more simple version of the mount cache that does not require dynamic allocations for extends. the Mntcache structure now contains a page bitmap that is used for quick page invalidation. the size of the bitmap is proportional to MAXCACHE. instead of keeping track of cached range in the Extend data structure, we keep all the information in the Page itself. the offset from the page where the cache range starts is in the low PGSHIT bits and the end in the top bits of Page.va. we choose Page.daddr to map 1:1 the Mountcache number and page number (pn) in the Mountcache. to find a page, we first check the bitmap if the page is there and then do a pagelookup() with the daddr key.
2014-12-16 04:41:20 +00:00
ulong offset, pn, po, pe;
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
kernel: new mount cache this is a new more simple version of the mount cache that does not require dynamic allocations for extends. the Mntcache structure now contains a page bitmap that is used for quick page invalidation. the size of the bitmap is proportional to MAXCACHE. instead of keeping track of cached range in the Extend data structure, we keep all the information in the Page itself. the offset from the page where the cache range starts is in the low PGSHIT bits and the end in the top bits of Page.va. we choose Page.daddr to map 1:1 the Mountcache number and page number (pn) in the Mountcache. to find a page, we first check the bitmap if the page is there and then do a pagelookup() with the daddr key.
2014-12-16 04:41:20 +00:00
if(off >= MAXCACHE || len <= 0){
kernel: pipelined read ahead for the mount cache this changes devmnt adding mntrahread() function and some helpers for it to do pipelined sequential read ahead for the mount cache. basically, cread() calls mntrahread() with Mntrah structure and it figures out if we where reading sequentially and if thats the case issues reads of c->iounit size in advance. the read ahead state (Mntrah) is kept in the mount cache so we can handle (read ahead) cache invalidation in the presence of writes.
2015-07-26 03:43:26 +00:00
cacheunlock(m);
kernel: new mount cache this is a new more simple version of the mount cache that does not require dynamic allocations for extends. the Mntcache structure now contains a page bitmap that is used for quick page invalidation. the size of the bitmap is proportional to MAXCACHE. instead of keeping track of cached range in the Extend data structure, we keep all the information in the Page itself. the offset from the page where the cache range starts is in the low PGSHIT bits and the end in the top bits of Page.va. we choose Page.daddr to map 1:1 the Mountcache number and page number (pn) in the Mountcache. to find a page, we first check the bitmap if the page is there and then do a pagelookup() with the daddr key.
2014-12-16 04:41:20 +00:00
return;
}
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
kernel: new mount cache this is a new more simple version of the mount cache that does not require dynamic allocations for extends. the Mntcache structure now contains a page bitmap that is used for quick page invalidation. the size of the bitmap is proportional to MAXCACHE. instead of keeping track of cached range in the Extend data structure, we keep all the information in the Page itself. the offset from the page where the cache range starts is in the low PGSHIT bits and the end in the top bits of Page.va. we choose Page.daddr to map 1:1 the Mountcache number and page number (pn) in the Mountcache. to find a page, we first check the bitmap if the page is there and then do a pagelookup() with the daddr key.
2014-12-16 04:41:20 +00:00
offset = off;
if(offset+len > MAXCACHE)
len = MAXCACHE - offset;
pn = offset / BY2PG;
offset &= (BY2PG-1);
while(len > 0){
l = BY2PG - offset;
if(l > len)
l = len;
p = cpage(m, pn, &po, &pe);
if(p != nil){
kernel: get rid of auxpage() and preserve cache index bits in Page.va in mount cache the mount cache uses Page.va to store cached range offset and limit, but mips kernel uses cache index bits from Page.va to maintain page coloring. Page.va was not initialized by auxpage(). this change removes auxpage() which was primarily used only by the mount cache and use newpage() with cache file offset page as va so we will get a page of the right color. mount cache keeps the index bits intact by only using the top and buttom PGSHIFT bits of Page.va for the range offset/limit.
2015-03-16 04:46:08 +00:00
if(offset > pe || (offset+l) < po){
/* cached range not extendable, set new cached range */
kernel: new mount cache this is a new more simple version of the mount cache that does not require dynamic allocations for extends. the Mntcache structure now contains a page bitmap that is used for quick page invalidation. the size of the bitmap is proportional to MAXCACHE. instead of keeping track of cached range in the Extend data structure, we keep all the information in the Page itself. the offset from the page where the cache range starts is in the low PGSHIT bits and the end in the top bits of Page.va. we choose Page.daddr to map 1:1 the Mountcache number and page number (pn) in the Mountcache. to find a page, we first check the bitmap if the page is there and then do a pagelookup() with the daddr key.
2014-12-16 04:41:20 +00:00
po = offset;
pe = offset+l;
} else {
/* extend cached range */
if(offset < po)
po = offset;
if((offset+l) > pe)
pe = offset+l;
}
} else {
kernel: remove waserror() arround newpage() in mntcache newpage() does not raise error().
2015-06-16 04:05:12 +00:00
if(needpages(nil)){
kernel: new mount cache this is a new more simple version of the mount cache that does not require dynamic allocations for extends. the Mntcache structure now contains a page bitmap that is used for quick page invalidation. the size of the bitmap is proportional to MAXCACHE. instead of keeping track of cached range in the Extend data structure, we keep all the information in the Page itself. the offset from the page where the cache range starts is in the low PGSHIT bits and the end in the top bits of Page.va. we choose Page.daddr to map 1:1 the Mountcache number and page number (pn) in the Mountcache. to find a page, we first check the bitmap if the page is there and then do a pagelookup() with the daddr key.
2014-12-16 04:41:20 +00:00
invalidate(m, offset + pn*BY2PG, len);
break;
}
kernel: get rid of auxpage() and preserve cache index bits in Page.va in mount cache the mount cache uses Page.va to store cached range offset and limit, but mips kernel uses cache index bits from Page.va to maintain page coloring. Page.va was not initialized by auxpage(). this change removes auxpage() which was primarily used only by the mount cache and use newpage() with cache file offset page as va so we will get a page of the right color. mount cache keeps the index bits intact by only using the top and buttom PGSHIFT bits of Page.va for the range offset/limit.
2015-03-16 04:46:08 +00:00
p = newpage(0, nil, pn*BY2PG);
kernel: new mount cache this is a new more simple version of the mount cache that does not require dynamic allocations for extends. the Mntcache structure now contains a page bitmap that is used for quick page invalidation. the size of the bitmap is proportional to MAXCACHE. instead of keeping track of cached range in the Extend data structure, we keep all the information in the Page itself. the offset from the page where the cache range starts is in the low PGSHIT bits and the end in the top bits of Page.va. we choose Page.daddr to map 1:1 the Mountcache number and page number (pn) in the Mountcache. to find a page, we first check the bitmap if the page is there and then do a pagelookup() with the daddr key.
2014-12-16 04:41:20 +00:00
p->daddr = cacheaddr(m, pn);
cachedel(&fscache, p->daddr);
cachepage(p, &fscache);
m->bitmap[pn/MAPBITS] |= 1 << (pn%MAPBITS);
po = offset;
pe = offset+l;
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
}
kernel: get rid of auxpage() and preserve cache index bits in Page.va in mount cache the mount cache uses Page.va to store cached range offset and limit, but mips kernel uses cache index bits from Page.va to maintain page coloring. Page.va was not initialized by auxpage(). this change removes auxpage() which was primarily used only by the mount cache and use newpage() with cache file offset page as va so we will get a page of the right color. mount cache keeps the index bits intact by only using the top and buttom PGSHIFT bits of Page.va for the range offset/limit.
2015-03-16 04:46:08 +00:00
cpageset(p, po, pe);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
k = kmap(p);
kernel: new mount cache this is a new more simple version of the mount cache that does not require dynamic allocations for extends. the Mntcache structure now contains a page bitmap that is used for quick page invalidation. the size of the bitmap is proportional to MAXCACHE. instead of keeping track of cached range in the Extend data structure, we keep all the information in the Page itself. the offset from the page where the cache range starts is in the low PGSHIT bits and the end in the top bits of Page.va. we choose Page.daddr to map 1:1 the Mountcache number and page number (pn) in the Mountcache. to find a page, we first check the bitmap if the page is there and then do a pagelookup() with the daddr key.
2014-12-16 04:41:20 +00:00
if(waserror()) {
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
kunmap(k);
kernel: new mount cache this is a new more simple version of the mount cache that does not require dynamic allocations for extends. the Mntcache structure now contains a page bitmap that is used for quick page invalidation. the size of the bitmap is proportional to MAXCACHE. instead of keeping track of cached range in the Extend data structure, we keep all the information in the Page itself. the offset from the page where the cache range starts is in the low PGSHIT bits and the end in the top bits of Page.va. we choose Page.daddr to map 1:1 the Mountcache number and page number (pn) in the Mountcache. to find a page, we first check the bitmap if the page is there and then do a pagelookup() with the daddr key.
2014-12-16 04:41:20 +00:00
putpage(p);
invalidate(m, offset + pn*BY2PG, len);
kernel: pipelined read ahead for the mount cache this changes devmnt adding mntrahread() function and some helpers for it to do pipelined sequential read ahead for the mount cache. basically, cread() calls mntrahread() with Mntrah structure and it figures out if we where reading sequentially and if thats the case issues reads of c->iounit size in advance. the read ahead state (Mntrah) is kept in the mount cache so we can handle (read ahead) cache invalidation in the presence of writes.
2015-07-26 03:43:26 +00:00
cacheunlock(m);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
nexterror();
}
kernel: new mount cache this is a new more simple version of the mount cache that does not require dynamic allocations for extends. the Mntcache structure now contains a page bitmap that is used for quick page invalidation. the size of the bitmap is proportional to MAXCACHE. instead of keeping track of cached range in the Extend data structure, we keep all the information in the Page itself. the offset from the page where the cache range starts is in the low PGSHIT bits and the end in the top bits of Page.va. we choose Page.daddr to map 1:1 the Mountcache number and page number (pn) in the Mountcache. to find a page, we first check the bitmap if the page is there and then do a pagelookup() with the daddr key.
2014-12-16 04:41:20 +00:00
memmove((uchar*)VA(k) + offset, buf, l);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
poperror();
kunmap(k);
putpage(p);
kernel: new mount cache this is a new more simple version of the mount cache that does not require dynamic allocations for extends. the Mntcache structure now contains a page bitmap that is used for quick page invalidation. the size of the bitmap is proportional to MAXCACHE. instead of keeping track of cached range in the Extend data structure, we keep all the information in the Page itself. the offset from the page where the cache range starts is in the low PGSHIT bits and the end in the top bits of Page.va. we choose Page.daddr to map 1:1 the Mountcache number and page number (pn) in the Mountcache. to find a page, we first check the bitmap if the page is there and then do a pagelookup() with the daddr key.
2014-12-16 04:41:20 +00:00
offset = 0;
pn++;
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
buf += l;
len -= l;
}
kernel: pipelined read ahead for the mount cache this changes devmnt adding mntrahread() function and some helpers for it to do pipelined sequential read ahead for the mount cache. basically, cread() calls mntrahread() with Mntrah structure and it figures out if we where reading sequentially and if thats the case issues reads of c->iounit size in advance. the read ahead state (Mntrah) is kept in the mount cache so we can handle (read ahead) cache invalidation in the presence of writes.
2015-07-26 03:43:26 +00:00
cacheunlock(m);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
}
void
cupdate(Chan *c, uchar *buf, int len, vlong off)
{
Mntcache *m;
kernel: mnt cache rework avoid double entries in the cache for copen() and properly handle locking so we wont just give up if we cant lock the Mntcache entry, but drop the cache lock, qlock the Mntcache entry, and then recheck the cache. general cleanup (cdev -> ccache, use eqchantdqid())
2012-10-17 13:48:30 +00:00
m = ccache(c);
kernel: minor changes to mount cache change page cache ids (bid) to uintptr so we use the full address space of Page.daddr. make maxcache offset check consistent in cread(). use consistent types in cupdate() and simplify with goto. make internal functions static. use nil instead of 0 for pointers.
2014-12-15 05:28:27 +00:00
if(m == nil)
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
return;
kernel: new mount cache this is a new more simple version of the mount cache that does not require dynamic allocations for extends. the Mntcache structure now contains a page bitmap that is used for quick page invalidation. the size of the bitmap is proportional to MAXCACHE. instead of keeping track of cached range in the Extend data structure, we keep all the information in the Page itself. the offset from the page where the cache range starts is in the low PGSHIT bits and the end in the top bits of Page.va. we choose Page.daddr to map 1:1 the Mountcache number and page number (pn) in the Mountcache. to find a page, we first check the bitmap if the page is there and then do a pagelookup() with the daddr key.
2014-12-16 04:41:20 +00:00
cachedata(m, buf, len, off);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
}
void
cwrite(Chan* c, uchar *buf, int len, vlong off)
{
Mntcache *m;
kernel: mnt cache rework avoid double entries in the cache for copen() and properly handle locking so we wont just give up if we cant lock the Mntcache entry, but drop the cache lock, qlock the Mntcache entry, and then recheck the cache. general cleanup (cdev -> ccache, use eqchantdqid())
2012-10-17 13:48:30 +00:00
m = ccache(c);
kernel: minor changes to mount cache change page cache ids (bid) to uintptr so we use the full address space of Page.daddr. make maxcache offset check consistent in cread(). use consistent types in cupdate() and simplify with goto. make internal functions static. use nil instead of 0 for pointers.
2014-12-15 05:28:27 +00:00
if(m == nil)
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
return;
m->qid.vers++;
c->qid.vers++;
kernel: pipelined read ahead for the mount cache this changes devmnt adding mntrahread() function and some helpers for it to do pipelined sequential read ahead for the mount cache. basically, cread() calls mntrahread() with Mntrah structure and it figures out if we where reading sequentially and if thats the case issues reads of c->iounit size in advance. the read ahead state (Mntrah) is kept in the mount cache so we can handle (read ahead) cache invalidation in the presence of writes.
2015-07-26 03:43:26 +00:00
if(c->qid.type&QTAPPEND){
cacheunlock(m);
return;
}
kernel: new mount cache this is a new more simple version of the mount cache that does not require dynamic allocations for extends. the Mntcache structure now contains a page bitmap that is used for quick page invalidation. the size of the bitmap is proportional to MAXCACHE. instead of keeping track of cached range in the Extend data structure, we keep all the information in the Page itself. the offset from the page where the cache range starts is in the low PGSHIT bits and the end in the top bits of Page.va. we choose Page.daddr to map 1:1 the Mountcache number and page number (pn) in the Mountcache. to find a page, we first check the bitmap if the page is there and then do a pagelookup() with the daddr key.
2014-12-16 04:41:20 +00:00
cachedata(m, buf, len, off);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
}
kernel: pipelined read ahead for the mount cache this changes devmnt adding mntrahread() function and some helpers for it to do pipelined sequential read ahead for the mount cache. basically, cread() calls mntrahread() with Mntrah structure and it figures out if we where reading sequentially and if thats the case issues reads of c->iounit size in advance. the read ahead state (Mntrah) is kept in the mount cache so we can handle (read ahead) cache invalidation in the presence of writes.
2015-07-26 03:43:26 +00:00
kernel: make the mntcache robust against fileserver like fossil that do not change the qid.vers on wstat introducing new ctrunc() function that invalidates any caches for the passed in chan, invoked when handling wstat with a specified file length or on file creation/truncation. test program to reproduce the problem: #include <u.h> #include <libc.h> #include <libsec.h> void main(int argc, char *argv[]) { int fd; Dir *d, nd; fd = create("xxx", ORDWR, 0666); write(fd, "1234", 4); d = dirstat("xxx"); assert(d->length == 4); nulldir(&nd); nd.length = 0; dirwstat("xxx", &nd); d = dirstat("xxx"); assert(d->length == 0); fd = open("xxx", OREAD); assert(read(fd, (void*)&d, 4) == 0); }
2017-01-12 19:13:20 +00:00
void
ctrunc(Chan *c)
{
Mntcache *m;
if(c->qid.type&QTDIR)
return;
if((c->flag&COPEN) == 0){
lock(&cache);
c->mcp = clookup(c, 0);
unlock(&cache);
}
m = ccache(c);
if(m == nil)
return;
mntrahinit(&m->rah);
cnodata(m);
cacheunlock(m);
if((c->flag&COPEN) == 0)
c->mcp = nil;
}
kernel: pipelined read ahead for the mount cache this changes devmnt adding mntrahread() function and some helpers for it to do pipelined sequential read ahead for the mount cache. basically, cread() calls mntrahread() with Mntrah structure and it figures out if we where reading sequentially and if thats the case issues reads of c->iounit size in advance. the read ahead state (Mntrah) is kept in the mount cache so we can handle (read ahead) cache invalidation in the presence of writes.
2015-07-26 03:43:26 +00:00
void
cclunk(Chan *c)
{
Mntcache *m;
m = ccache(c);
if(m == nil)
return;
mntrahinit(&m->rah);
cacheunlock(m);
c->mcp = nil;
}
Reference in a new issue Copy permalink