void ZGui::Create_MenuApp()
{
QString IDval; ZConfig IDini(Idioma, false);
QRect rect; QPixmap* p1 = new QPixmap();
menu = new ZOptionsMenu ( rect, softKey, NULL, 0);
menu->setItemSpacing(10); int idx=0;
p1 = new QPixmap(iconReader.getIcon("", false));
IDval = IDini.readEntry(QString("CRONTAB"), QString("MENU_ADD"), "");
menu->insertItem ( IDval, NULL, p1, true, idx, idx );
menu->connectItem ( idx, this, SLOT ( addtask() ) );
++idx;
p1 = new QPixmap(iconReader.getIcon("", false));
IDval = IDini.readEntry(QString("CRONTAB"), QString("MENU_REMOVE"), "");
menu->insertItem ( IDval, NULL, p1, true, idx, idx );
menu->connectItem ( idx, this, SLOT ( removetask() ) );
++idx;
menu->insertSeparator(idx, idx);
++idx;
p1 = new QPixmap(iconReader.getIcon("", false));
IDval = IDini.readEntry(QString("COMMON"), QString("MENU_ABOUT"), "");
menu->insertItem ( IDval, NULL, p1, true, idx, idx );
menu->connectItem ( idx, this, SLOT ( about() ) );
++idx;
p1 = new QPixmap(iconReader.getIcon("", false));
IDval = IDini.readEntry(QString("COMMON"), QString("MENU_EXIT"), "");
menu->insertItem ( IDval, NULL, p1, true, idx, idx );
menu->connectItem ( idx, qApp, SLOT ( quit() ) );
}
/*
* 同步一个文件，如果flag被置位的话就等直到这些文件真的被同步成功
* 否则只是添加一个任务，然后结果什么样就不管了
* 说实话，我并不知道这个flag原来实际上是什么用……
*/
int baiduapi_fsync(const char *path, int flag, struct fuse_file_info *fi)
{
if (fi->fh) {
int i ;
filedec *f = (filedec *) fi->fh;
switch (f->type) {
case forread:
break;
case forwrite:
pthread_mutex_lock(&f->lock);
for (i = 0; i <= GetWriteBlkNo(f->lengh); ++i) {
if ((f->cache.w.taskid[i] == 0) &&
(GETD(f->cache.w.flags, i) || GETZ(f->cache.w.flags, i))) {
block *b = malloc(sizeof(block));
b->bno = i;
b->fd = f;
f->cache.w.taskid[i] = addtask((taskfunc) uploadblock, b, 0);
}
}
pthread_mutex_unlock(&f->lock);
if (flag) {
int done = 0;
while (!done) {
done = 1;
for (i = 0; i <= GetWriteBlkNo(f->lengh); ++i) {
if (f->cache.w.taskid[i]) {
waittask(f->cache.w.taskid[i]);
}
if (GETD(f->cache.w.flags, i) || GETZ(f->cache.w.flags, i)) {
pthread_mutex_lock(&f->lock);
block *b = malloc(sizeof(block));
b->bno = i;
b->fd = f;
f->cache.w.taskid[i] = addtask((taskfunc) uploadblock, b, 0);
pthread_mutex_unlock(&f->lock);
done = 0;
}
};
}
}
break;
}
}
return 0;
}
/* 遍历fcache的处理函数
* 如果文件已经被释放，则同步该文件
* 否则：
* 对于写缓存：已经同步完的block取回结果
* 写满的脏block，上传该block
* 对于同步完有段时间的和被标记删除的，则删除该缓存
*/
void handlefcache(filedec *f)
{
size_t i;
if (pthread_mutex_trylock(&f->lock) == 0) {
if (f->flags == 0) { //如果该文件未被同步,未在同步，未被标记删除
if (f->count == 0) { //文件已被关闭
f->flags |= TRANSF;
addtask((taskfunc)fcachesync, f, 0);
} else {
switch (f->type) {
case forread:
break;
case forwrite:
for (i = 0; i < GetWriteBlkNo(f->lengh); ++i) {
if (f->cache.w.taskid[i] == 0 &&
GETD(f->cache.w.flags, i)) //如果这个block是脏的那么加个上传任务
{
block *b = (block *)malloc(sizeof(block));
b->bno = i;
b->fd = f;
f->cache.w.taskid[i] = addtask((taskfunc) uploadblock, b, 0);
}
}
break;
}
}
} else if (f->count == 0) {
if((f->flags & SYNCED) &&
(f->flags & DELETE) == 0 &&
(time(NULL) - f->mtime > 60 * 10)) //同步结束时间超过10分种
{
f->flags |= RELEASE;
f->flags |= ONDELE;
addtask((taskfunc)freefcache, f, 0); //释放它
}else if ((f->flags & (DELETE | RELEASE))&&
(f->flags & ONDELE) == 0) //删除被标记删除的项
{
f->flags |= ONDELE;
addtask((taskfunc)freefcache, f, 0);
}
}
pthread_mutex_unlock(&f->lock);
}
}
/*
* sleep and wakeup
*/
void
tasksleep(Rendez *r)
{
addtask(&r->waiting, taskrunning);
if (r->l) {
qunlock(r->l);
}
taskstate("sleep");
taskswitch();
if (r->l) {
qlock(r->l);
}
}
static int
_wlock(RWLock *l, int block)
{
if(l->writer == nil && l->readers == 0){
l->writer = taskrunning;
return 1;
}
if(!block)
return 0;
addtask(&l->wwaiting, taskrunning);
taskstate("wlock");
taskswitch();
return 1;
}
static int
_rlock(RWLock *l, int block)
{
if(l->writer == nil && l->wwaiting.head == nil){
l->readers++;
return 1;
}
if(!block)
return 0;
addtask(&l->rwaiting, taskrunning);
taskstate("rlock");
taskswitch();
return 1;
}
/*
* locking
*/
static int
_qlock(QLock *l, int block)
{
if(l->owner == nil){
l->owner = taskrunning;
return 1;
}
if(!block)
return 0;
addtask(&l->waiting, taskrunning);
taskstate("qlock");
taskswitch();
if(l->owner != taskrunning){
fprint(2, "qlock: owner=%p self=%p oops\n", l->owner, taskrunning);
abort();
}
return 1;
}
// 协程添加到就绪队列
void
taskready(Task *t)
{
t->ready = 1;
addtask(&taskrunqueue, t);
}
void
taskready(Task *t)
{
t->ready = 1;//状态设置为可以运行的状态，然后加到运行 任务队列末尾里面去
addtask(&taskrunqueue, t);
}
//读
int baiduapi_read(const char *path, char *buf, size_t size, off_t offset, struct fuse_file_info *fi)
{
filedec *f = (filedec *) fi->fh;
int c, ret, i;
if (offset > f->lengh) { //如果偏移超过文件长度
errno = EFAULT;
return -errno;
}
if (offset + size > f->lengh) { //如果剩余长度不足size，则最多读到文件末尾
size = f->lengh - offset;
}
switch (f->type) {
case forread:
c = offset / RBS; //计算一下在哪个块
pthread_mutex_lock(&f->lock);
for (i = 0; i < MAXCACHE; ++i) { //一般读取的时候绝大部分是向后读，所以缓存下面的几个block
int p = i + c;
if (p >= 0 &&
p <= f->lengh / RBS &&
f->cache.r.taskid[p] == 0 &&
!(f->cache.r.mask[p / 32] & (1 << (p % 32)))) {
block *b = (block *) malloc(sizeof(block));
b->fd = f;
b->bno = p;
f->cache.r.taskid[p] = addtask((taskfunc) readblock, b, 0);
f->flags &= ~SYNCED;
}
}
pthread_mutex_unlock(&f->lock);
waittask(f->cache.r.taskid[c]);
pthread_mutex_lock(&f->lock);
if (!(f->cache.r.mask[c / 32] & (1 << (c % 32)))) {
pthread_mutex_unlock(&f->lock);
return -EIO; //如果在这里返回那么读取出错
}
lseek(f->file, offset, SEEK_SET);
int len = Min(size, (c + 1) * RBS - offset); //计算最长能读取的字节
ret = read(f->file,buf, len);
pthread_mutex_unlock(&f->lock);
if (ret != len) { //读取出错了
return ret;
}
if (len < size) { //需要读取下一个block
int tmp = baiduapi_read(f->path, buf + len, size - len, offset + len, fi);
if (tmp < 0) { //调用出错
return tmp;
} else
ret += tmp;
}
return ret; //成功返回
case forwrite:
pthread_mutex_lock(&f->lock);
lseek(f->file, offset, SEEK_SET);
ret = read(f->file,buf, size);
pthread_mutex_unlock(&f->lock);
return ret;
}
errno = EPERM;
return -errno;
}
