Lines Matching defs:ce
519 cache_ent *ce;
523 for (ce = cel->lru; ce; ce = ce->next) {
524 kprintf("ce %p dev %2d bnum %6" B_PRIdOFF " lock %d flag %d arg %p "
525 "clone %p\n", ce, ce->dev, ce->block_num, ce->lock,
526 ce->flags, ce->arg, ce->clone);
549 cache_ent *ce, *prev = NULL;
553 for(ce=bc.normal.lru; ce; prev=ce, ce=ce->next) {
557 for(ce=bc.locked.lru; ce; prev=ce, ce=ce->next) {
598 cache_ent *ce, *prev, *oce;
602 for(ce=cel->lru,prev=NULL; ce; prev=ce, ce=ce->next) {
604 if (oce == ce) {
606 beos_panic("1:ce @ 0x%x is in two lists(cel 0x%x &LOCKED)\n",ce,cel);
612 beos_panic("*** last element in list != cel mru (ce 0x%x, cel 0x%x)\n",
617 for(ce=cel->lru,prev=NULL; ce; prev=ce, ce=ce->next) {
619 if (oce == ce) {
621 beos_panic("3:ce @ 0x%x is in two lists(cel 0x%x & DIRTY)\n",ce,cel);
627 beos_panic("*** last element in list != cel mru (ce 0x%x, cel 0x%x)\n",
649 cache_ent *ce;
659 for(ce=bc.normal.lru; ce; ce=ce->next) {
660 if (ce->block_num == bnum) {
662 bnum, ce, ce->data);
666 for(ce=bc.locked.lru; ce; ce=ce->next) {
667 if (ce->block_num == bnum) {
669 bnum, ce, ce->data);
682 cache_ent *ce;
692 for(ce=bc.normal.lru; ce; ce=ce->next) {
693 if (ce->data == data) {
694 kprintf("found normal data ptr for bnum %ld @ ce 0x%lx\n",
695 ce->block_num, ce);
699 for(ce=bc.locked.lru; ce; ce=ce->next) {
700 if (ce->data == data) {
701 kprintf("found locked data ptr for bnum %ld @ ce 0x%lx\n",
702 ce->block_num, ce);
718 delete_from_list(cache_ent_list *cel, cache_ent *ce)
720 if (ce->next)
721 ce->next->prev = ce->prev;
722 if (ce->prev)
723 ce->prev->next = ce->next;
725 if (cel->lru == ce)
726 cel->lru = ce->next;
727 if (cel->mru == ce)
728 cel->mru = ce->prev;
730 ce->next = NULL;
731 ce->prev = NULL;
737 this function adds the cache_ent ce to the head of the
742 add_to_head(cache_ent_list *cel, cache_ent *ce)
744 if (ce->next != NULL || ce->prev != NULL) {
745 beos_panic("*** ath: ce has non-null next/prev ptr (ce %p nxt %p, prv %p)\n",
746 ce, ce->next, ce->prev);
749 ce->next = NULL;
750 ce->prev = cel->mru;
753 cel->mru->next = ce;
754 cel->mru = ce;
757 cel->lru = ce;
762 this function adds the cache_ent ce to the tail of the
767 add_to_tail(cache_ent_list *cel, cache_ent *ce)
769 if (ce->next != NULL || ce->prev != NULL) {
770 beos_panic("*** att: ce has non-null next/prev ptr (ce %p nxt %p, prv %p)\n",
771 ce, ce->next, ce->prev);
774 ce->next = cel->lru;
775 ce->prev = NULL;
778 cel->lru->prev = ce;
779 cel->lru = ce;
782 cel->mru = ce;
810 static cache_ent *ce = NULL;
822 ce = bc.normal.lru;
824 for(num_ents=0; ce && num_ents < NUM_FLUSH_BLOCKS; ce=ce->next) {
825 if (ce->flags & CE_BUSY)
828 if ((ce->flags & CE_DIRTY) == 0 && ce->clone == NULL)
831 ents[num_ents] = ce;
838 ce = bc.locked.lru;
842 ce && ((ce->flags & CE_BUSY) || ce->clone == NULL);
843 ce=ce->next)
846 if (ce == NULL)
849 ents[num_ents] = ce;
851 ce = ce->next;
876 flush_cache_ent(cache_ent *ce)
882 if ((ce->flags & CE_DIRTY) == 0 && ce->clone == NULL)
886 if (ce->clone == NULL && ce->lock != 0)
890 if (ce->clone)
891 data = ce->clone;
893 data = ce->data;
895 if (chatty_io > 2) printf("flush: %7" B_PRIdOFF "\n", ce->block_num);
896 ret = beos_write_phys_blocks(ce->dev, ce->block_num, data, 1, ce->bsize);
898 if (ce->func) {
899 ce->func(ce->logged_bnum, 1, ce->arg);
900 ce->func = NULL;
903 if (ce->clone) {
904 free(ce->clone);
905 ce->clone = NULL;
907 if (ce->lock == 0 && (ce->flags & CE_DIRTY))
910 ce->flags &= ~CE_DIRTY;
1046 cache_ent *ce, *next;
1048 for (ce = cel->lru; ce; ce = next) {
1049 next = ce->next;
1050 if (ce->lock != 0) {
1051 if (ce->func)
1054 ce->block_num, ce->lock, ce->arg);
1058 ce->block_num, ce->lock);
1061 if (ce->flags & CE_BUSY) {
1063 "bnum %" B_PRIdOFF " is busy? ce %p\n", ce->block_num, ce);
1066 if ((ce->flags & CE_DIRTY) || ce->clone) {
1067 flush_cache_ent(ce);
1070 if (ce->clone)
1071 free(ce->clone);
1072 ce->clone = NULL;
1074 if (ce->data)
1075 free(ce->data);
1076 ce->data = NULL;
1078 if ((junk = hash_delete(&bc.ht, ce->dev, ce->block_num)) != ce) {
1081 ce->block_num, junk, ce);
1084 explicit_bzero(ce, sizeof(*ce));
1085 free(ce);
1153 cache_ent *ce;
1156 ce = hash_lookup(&bc.ht, dev, bnum);
1157 if (ce == NULL)
1160 if ((ce->flags & CE_BUSY) == 0) /* it's ok, break out and return it */
1168 printf("block %" B_PRIdOFF " isn't coming un-busy (ce @ %p)\n",
1169 ce->block_num, ce);
1175 if (ce->flags & CE_BUSY)
1176 beos_panic("block lookup: returning a busy block @ %p?!?\n", ce);
1178 return ce;
1188 cache_ent *ce;
1197 ce = block_lookup(dev, blocks[i]);
1198 if (ce == NULL) {
1205 if (blocks[i] != ce->block_num || dev != ce->dev) {
1208 "bnum %ld\n", dev, blocks[i], ce->dev, ce->block_num);
1212 if (ce->lock == 0) {
1218 if ((ce->flags & CE_DIRTY) == 0) {
1223 ce->flags |= CE_BUSY; /* mark all blocks as busy till we're done */
1226 if (ce->clone && ce->func) {
1227 ents[cur++] = ce;
1262 ce = hash_lookup(&bc.ht, dev, blocks[i]);
1263 if (ce == NULL) {
1269 ce->flags &= ~(CE_DIRTY | CE_BUSY);
1271 if (ce->func != NULL) {
1273 ce->block_num);
1276 if (ce->clone != NULL) {
1277 beos_panic("*** ce->clone == %p, not NULL in set_block_info\n",
1278 ce->clone);
1281 ce->clone = (void *)malloc(ce->bsize);
1282 if (ce->clone == NULL)
1284 ce->block_num, ce->bsize);
1287 memcpy(ce->clone, ce->data, ce->bsize);
1289 ce->func = func;
1290 ce->arg = arg;
1292 ce->logged_bnum = blocks[i];
1294 ce->lock--;
1295 if (ce->lock < 0) {
1297 "whoa nellie! ce @ %p (%" B_PRIdOFF ") has lock == %d\n",
1298 ce, ce->block_num, ce->lock);
1301 if (ce->lock == 0) {
1302 delete_from_list(&bc.locked, ce);
1303 add_to_head(&bc.normal, ce);
1338 cache_ent *ce;
1344 ce = bc.normal.lru;
1345 while (ce) {
1346 if (ce->dev != dev || (ce->flags & CE_BUSY)) {
1347 ce = ce->next;
1351 if ((ce->flags & CE_DIRTY) || ce->clone) {
1352 ents[cur++] = ce;
1356 ce = bc.normal.lru;
1362 ce = ce->next;
1369 ce = bc.locked.lru;
1370 while (ce) {
1371 if (ce->dev != dev || (ce->flags & CE_BUSY)) {
1372 ce = ce->next;
1376 if (ce->clone) {
1377 ents[cur++] = ce;
1381 ce = bc.locked.lru;
1387 ce = ce->next;
1403 cache_ent *ce, *next = NULL;
1405 for(ce=cel->lru; ce; ce=next) {
1406 next = ce->next;
1408 if (ce->dev != dev) {
1412 if (ce->lock != 0 || (ce->flags & CE_BUSY)) {
1414 "block %" B_PRIdOFF " has lock = %d, flags 0x%x! ce @ %p\n",
1415 ce->block_num, ce->lock, ce->flags, ce);
1419 ((ce->flags & CE_DIRTY) || ce->clone)) {
1420 ce->flags |= CE_BUSY;
1421 flush_cache_ent(ce);
1422 ce->flags &= ~CE_BUSY;
1426 if (cel->lru == ce)
1427 cel->lru = ce->next;
1429 if (cel->mru == ce)
1430 cel->mru = ce->prev;
1432 if (ce->prev)
1433 ce->prev->next = ce->next;
1434 if (ce->next)
1435 ce->next->prev = ce->prev;
1437 if (ce->clone)
1438 free(ce->clone);
1439 ce->clone = NULL;
1441 if (ce->data)
1442 free(ce->data);
1443 ce->data = NULL;
1445 if ((junk = hash_delete(&bc.ht, ce->dev, ce->block_num)) != ce) {
1447 "%p != %p\n", ce->block_num, junk, ce);
1450 free(ce);
1478 cache_ent *ce;
1488 ce = block_lookup(dev, bnum);
1489 if (ce == NULL)
1492 if (bnum != ce->block_num || dev != ce->dev) {
1495 dev, bnum, ce->dev, ce->block_num);
1499 if ((ce->flags & CE_DIRTY) == 0 && ce->clone == NULL)
1502 ce->flags |= CE_BUSY;
1503 ents[cur++] = ce;
1540 cache_ent *ce;
1545 ce = block_lookup(dev, bnum);
1546 if (ce) {
1547 ce->flags |= CE_DIRTY;
1568 cache_ent *ce;
1573 ce = block_lookup(dev, bnum);
1574 if (ce) {
1575 if (bnum != ce->block_num || dev != ce->dev) {
1577 dev, bnum, ce->dev, ce->block_num);
1582 ce->lock--;
1584 if (ce->lock < 0) {
1585 printf("rlsb: whoa nellie! ce %" B_PRIdOFF " has lock == %d\n",
1586 ce->block_num, ce->lock);
1589 if (ce->lock == 0) {
1590 delete_from_list(&bc.locked, ce);
1591 add_to_head(&bc.normal, ce);
1608 cache_ent *ce;
1610 ce = (cache_ent *)calloc(1, sizeof(cache_ent));
1611 if (ce == NULL) {
1616 ce->data = malloc(bsize);
1617 if (ce->data == NULL) {
1618 free(ce);
1624 ce->dev = -1;
1625 ce->block_num = -1;
1627 return ce;
1635 cache_ent *ce;
1650 for(ce=bc.normal.lru; ce && cur < num_needed; ce=ce->next) {
1651 if (ce->lock)
1652 beos_panic("get_ents: normal list has locked blocks (ce %p)\n",ce);
1654 if (ce->flags & CE_BUSY) /* don't touch busy blocks */
1657 ce->flags |= CE_BUSY;
1658 ents[cur++] = ce;
1672 beos_panic("get_ents: waited too long; can't get enough ce's (c %d n %d)\n",
1683 for(ce=ents[cur-1]->next; ce && cur < max; ce=ce->next) {
1684 if (ce->flags & CE_BUSY) /* don't touch busy blocks */
1687 if (ce->lock)
1688 beos_panic("get_ents:2 dirty list has locked blocks (ce %p)\n",ce);
1690 ce->flags |= CE_BUSY;
1691 ents[cur++] = ce;
1764 cache_ent *ce;
1830 ce = block_lookup(dev, tmp);
1838 if (ce) {
1839 if (tmp != ce->block_num || dev != ce->dev) {
1842 "found %d %lld\n", dev, tmp, ce->dev,
1843 ce->block_num);
1846 memcpy(ptr, ce->data, bsize);
1857 ce = block_lookup(dev, tmp);
1858 if (ce) {
1859 if (tmp != ce->block_num || dev != ce->dev) {
1862 "found %d %lld\n", dev, tmp, ce->dev,
1863 ce->block_num);
1868 if (ce->clone) {
1870 "(ce %p bnum %" B_PRIdOFF ")...\n", ce, tmp);
1871 flush_cache_ent(ce);
1875 memcpy(ce->data, ptr, bsize);
1901 ce = block_lookup(dev, bnum);
1902 if (ce) {
1903 if (bnum != ce->block_num || dev != ce->dev) {
1906 "%d %ld\n", dev, bnum, ce->dev, ce->block_num);
1910 if (bsize != ce->bsize) {
1911 beos_panic("*** requested bsize %d but ce->bsize %d ce @ %p\n",
1912 bsize, ce->bsize, ce);
1916 if (ce->lock)
1921 delete_from_list(cel, ce);
1924 if (data && data != ce->data) {
1925 memcpy(data, ce->data, bsize);
1927 *dataptr = ce->data;
1929 printf("cbio:data %p dptr %p ce @ %p ce->data %p\n",
1930 data, dataptr, ce, ce->data);
1933 if (data && data != ce->data)
1934 memcpy(ce->data, data, bsize);
1936 ce->flags |= CE_DIRTY;
1938 memset(ce->data, 0, bsize);
1943 *dataptr = ce->data;
1945 ce->flags |= CE_DIRTY;
1951 ce->lock++;
1953 if (ce->lock)
1959 add_to_head(cel, ce);
2046 ce = ents[cur];
2047 ce->flags |= CE_BUSY;
2058 if (hash_insert(&bc.ht, dev, bnum + cur, ce) != 0)
2063 if (ce->dev == -1)
2066 if ((ce->flags & CE_DIRTY) || ce->clone)
2069 if (ce->lock) {
2070 beos_panic("cbio: can't use locked blocks here ce @ %p\n",ce);
2073 delete_from_list(cel, ce);
2076 ce = NULL;
2221 ce = ents[cur];
2222 if (ce->dev != -1) {
2223 tmp_ce = hash_delete(&bc.ht, ce->dev, ce->block_num);
2224 if (tmp_ce == NULL || tmp_ce != ce) {
2225 beos_panic("*** hash_delete failure (ce %p tce %p)\n",
2226 ce, tmp_ce);
2231 ce->dev = dev;
2232 ce->block_num = bnum + cur;
2233 ce->flags &= ~CE_BUSY;
2234 add_to_head(&bc.normal, ce);
2237 ce = NULL;
2247 beos_panic("should not have locked blocks here (ce %p)\n",
2267 ce = ents[cur];
2268 ce->flags &= ~CE_BUSY;
2270 free(ce->data);
2271 ce->data = NULL;
2273 free(ce);
2278 ce = NULL;
2290 ce = ents[cur];
2292 if (ce->dev != -1) { /* then clean this guy up */
2293 if (ce->next || ce->prev)
2294 beos_panic("ce @ %p should not be in a list yet!\n", ce);
2296 if (ce->clone)
2297 free(ce->clone);
2299 if (ce->data == NULL)
2300 beos_panic("ce @ %p has a null data ptr\n", ce);
2303 ce->dev = dev;
2304 ce->block_num = bnum + cur;
2305 ce->bsize = bsize;
2306 ce->flags = CE_NORMAL;
2307 ce->lock = 0;
2308 ce->clone = NULL;
2309 ce->func = ce->arg = NULL;
2310 ce->next = ce->prev = NULL;
2314 memcpy(data, ce->data, bsize);
2316 ce->flags |= CE_DIRTY;
2317 memcpy(ce->data, data, bsize);
2319 memset(ce->data, 0, bsize);
2323 ce->flags |= CE_DIRTY;
2327 ce->lock++;
2334 add_to_head(cel, ce);
2338 *dataptr = ce->data;
2412 cache_ent *ce;
2418 for(ce=bc.normal.lru; ce; ce=ce->next) {
2419 if ((ce->dev == dev) &&
2420 (ce->flags & CE_BUSY) == 0 &&
2421 ((ce->flags & CE_DIRTY) || ce->clone) &&
2422 ((prefer_log_blocks && ce->func) || (prefer_log_blocks == 0))) {
2424 ce->flags |= CE_BUSY;
2425 ents[count++] = ce;
2435 for(ce=bc.locked.lru; ce; ce=ce->next) {
2436 if ((ce->dev == dev) &&
2437 (ce->flags & CE_BUSY) == 0 &&
2438 (ce->clone)) {
2440 ce->flags |= CE_BUSY;
2441 ents[count++] = ce;