Lines Matching defs:pkt
421 struct packet_data *pkt;
428 list_for_each_entry(pkt, &pd->cdrw.pkt_active_list, list) {
429 states[pkt->state]++;
549 struct packet_data *pkt;
551 pkt = kzalloc(sizeof(struct packet_data), GFP_KERNEL);
552 if (!pkt)
555 pkt->frames = frames;
556 pkt->w_bio = bio_kmalloc(frames, GFP_KERNEL);
557 if (!pkt->w_bio)
561 pkt->pages[i] = alloc_page(GFP_KERNEL|__GFP_ZERO);
562 if (!pkt->pages[i])
566 spin_lock_init(&pkt->lock);
567 bio_list_init(&pkt->orig_bios);
570 pkt->r_bios[i] = bio_kmalloc(1, GFP_KERNEL);
571 if (!pkt->r_bios[i])
575 return pkt;
579 kfree(pkt->r_bios[i]);
582 if (pkt->pages[i])
583 __free_page(pkt->pages[i]);
584 kfree(pkt->w_bio);
586 kfree(pkt);
594 static void pkt_free_packet_data(struct packet_data *pkt)
598 for (i = 0; i < pkt->frames; i++)
599 kfree(pkt->r_bios[i]);
600 for (i = 0; i < pkt->frames / FRAMES_PER_PAGE; i++)
601 __free_page(pkt->pages[i]);
602 kfree(pkt->w_bio);
603 kfree(pkt);
608 struct packet_data *pkt, *next;
612 list_for_each_entry_safe(pkt, next, &pd->cdrw.pkt_free_list, list) {
613 pkt_free_packet_data(pkt);
620 struct packet_data *pkt;
625 pkt = pkt_alloc_packet_data(pd->settings.size >> 2);
626 if (!pkt) {
630 pkt->id = nr_packets;
631 pkt->pd = pd;
632 list_add(&pkt->list, &pd->cdrw.pkt_free_list);
968 struct packet_data *pkt = bio->bi_private;
969 struct pktcdvd_device *pd = pkt->pd;
973 bio, pkt->sector, bio->bi_iter.bi_sector, bio->bi_status);
976 atomic_inc(&pkt->io_errors);
978 if (atomic_dec_and_test(&pkt->io_wait)) {
979 atomic_inc(&pkt->run_sm);
987 struct packet_data *pkt = bio->bi_private;
988 struct pktcdvd_device *pd = pkt->pd;
991 dev_dbg(disk_to_dev(pd->disk), "id=%d, err=%d\n", pkt->id, bio->bi_status);
997 atomic_dec(&pkt->io_wait);
998 atomic_inc(&pkt->run_sm);
1005 static void pkt_gather_data(struct pktcdvd_device *pd, struct packet_data *pkt)
1013 BUG_ON(bio_list_empty(&pkt->orig_bios));
1015 atomic_set(&pkt->io_wait, 0);
1016 atomic_set(&pkt->io_errors, 0);
1022 spin_lock(&pkt->lock);
1023 bio_list_for_each(bio, &pkt->orig_bios) {
1024 int first_frame = (bio->bi_iter.bi_sector - pkt->sector) /
1029 BUG_ON(first_frame + num_frames > pkt->frames);
1033 spin_unlock(&pkt->lock);
1035 if (pkt->cache_valid) {
1036 dev_dbg(ddev, "zone %llx cached\n", pkt->sector);
1043 for (f = 0; f < pkt->frames; f++) {
1049 bio = pkt->r_bios[f];
1051 bio->bi_iter.bi_sector = pkt->sector + f * (CD_FRAMESIZE >> 9);
1053 bio->bi_private = pkt;
1058 pkt->pages[p], offset);
1059 if (!bio_add_page(bio, pkt->pages[p], CD_FRAMESIZE, offset))
1062 atomic_inc(&pkt->io_wait);
1068 dev_dbg(ddev, "need %d frames for zone %llx\n", frames_read, pkt->sector);
1079 struct packet_data *pkt;
1081 list_for_each_entry(pkt, &pd->cdrw.pkt_free_list, list) {
1082 if (pkt->sector == zone || pkt->list.next == &pd->cdrw.pkt_free_list) {
1083 list_del_init(&pkt->list);
1084 if (pkt->sector != zone)
1085 pkt->cache_valid = 0;
1086 return pkt;
1093 static void pkt_put_packet_data(struct pktcdvd_device *pd, struct packet_data *pkt)
1095 if (pkt->cache_valid) {
1096 list_add(&pkt->list, &pd->cdrw.pkt_free_list);
1098 list_add_tail(&pkt->list, &pd->cdrw.pkt_free_list);
1102 static inline void pkt_set_state(struct device *ddev, struct packet_data *pkt,
1108 enum packet_data_state old_state = pkt->state;
1110 dev_dbg(ddev, "pkt %2d : s=%6llx %s -> %s\n",
1111 pkt->id, pkt->sector, state_name[old_state], state_name[state]);
1113 pkt->state = state;
1123 struct packet_data *pkt, *p;
1132 dev_dbg(ddev, "no pkt\n");
1173 pkt = pkt_get_packet_data(pd, zone);
1176 pkt->sector = zone;
1177 BUG_ON(pkt->frames != pd->settings.size >> 2);
1178 pkt->write_size = 0;
1194 spin_lock(&pkt->lock);
1195 bio_list_add(&pkt->orig_bios, bio);
1196 pkt->write_size += bio->bi_iter.bi_size / CD_FRAMESIZE;
1197 spin_unlock(&pkt->lock);
1209 pkt->sleep_time = max(PACKET_WAIT_TIME, 1);
1210 pkt_set_state(ddev, pkt, PACKET_WAITING_STATE);
1211 atomic_set(&pkt->run_sm, 1);
1214 list_add(&pkt->list, &pd->cdrw.pkt_active_list);
1260 static void pkt_start_write(struct pktcdvd_device *pd, struct packet_data *pkt)
1265 bio_init(pkt->w_bio, pd->bdev, pkt->w_bio->bi_inline_vecs, pkt->frames,
1267 pkt->w_bio->bi_iter.bi_sector = pkt->sector;
1268 pkt->w_bio->bi_end_io = pkt_end_io_packet_write;
1269 pkt->w_bio->bi_private = pkt;
1272 for (f = 0; f < pkt->frames; f++) {
1273 struct page *page = pkt->pages[(f * CD_FRAMESIZE) / PAGE_SIZE];
1276 if (!bio_add_page(pkt->w_bio, page, CD_FRAMESIZE, offset))
1279 dev_dbg(ddev, "vcnt=%d\n", pkt->w_bio->bi_vcnt);
1284 spin_lock(&pkt->lock);
1285 bio_list_copy_data(pkt->w_bio, pkt->orig_bios.head);
1287 pkt_set_state(ddev, pkt, PACKET_WRITE_WAIT_STATE);
1288 spin_unlock(&pkt->lock);
1290 dev_dbg(ddev, "Writing %d frames for zone %llx\n", pkt->write_size, pkt->sector);
1292 if (test_bit(PACKET_MERGE_SEGS, &pd->flags) || (pkt->write_size < pkt->frames))
1293 pkt->cache_valid = 1;
1295 pkt->cache_valid = 0;
1298 atomic_set(&pkt->io_wait, 1);
1299 pkt_queue_bio(pd, pkt->w_bio);
1302 static void pkt_finish_packet(struct packet_data *pkt, blk_status_t status)
1307 pkt->cache_valid = 0;
1310 while ((bio = bio_list_pop(&pkt->orig_bios))) {
1316 static void pkt_run_state_machine(struct pktcdvd_device *pd, struct packet_data *pkt)
1320 dev_dbg(ddev, "pkt %d\n", pkt->id);
1323 switch (pkt->state) {
1325 if ((pkt->write_size < pkt->frames) && (pkt->sleep_time > 0))
1328 pkt->sleep_time = 0;
1329 pkt_gather_data(pd, pkt);
1330 pkt_set_state(ddev, pkt, PACKET_READ_WAIT_STATE);
1334 if (atomic_read(&pkt->io_wait) > 0)
1337 if (atomic_read(&pkt->io_errors) > 0) {
1338 pkt_set_state(ddev, pkt, PACKET_RECOVERY_STATE);
1340 pkt_start_write(pd, pkt);
1345 if (atomic_read(&pkt->io_wait) > 0)
1348 if (!pkt->w_bio->bi_status) {
1349 pkt_set_state(ddev, pkt, PACKET_FINISHED_STATE);
1351 pkt_set_state(ddev, pkt, PACKET_RECOVERY_STATE);
1357 pkt_set_state(ddev, pkt, PACKET_FINISHED_STATE);
1361 pkt_finish_packet(pkt, pkt->w_bio->bi_status);
1374 struct packet_data *pkt, *next;
1379 list_for_each_entry(pkt, &pd->cdrw.pkt_active_list, list) {
1380 if (atomic_read(&pkt->run_sm) > 0) {
1381 atomic_set(&pkt->run_sm, 0);
1382 pkt_run_state_machine(pd, pkt);
1390 list_for_each_entry_safe(pkt, next, &pd->cdrw.pkt_active_list, list) {
1391 if (pkt->state == PACKET_FINISHED_STATE) {
1392 list_del(&pkt->list);
1393 pkt_put_packet_data(pd, pkt);
1394 pkt_set_state(ddev, pkt, PACKET_IDLE_STATE);
1409 struct packet_data *pkt;
1431 list_for_each_entry(pkt, &pd->cdrw.pkt_active_list, list) {
1432 if (atomic_read(&pkt->run_sm) > 0)
1446 list_for_each_entry(pkt, &pd->cdrw.pkt_active_list, list) {
1447 if (pkt->sleep_time && pkt->sleep_time < min_sleep_time)
1448 min_sleep_time = pkt->sleep_time;
1458 list_for_each_entry(pkt, &pd->cdrw.pkt_active_list, list) {
1459 if (!pkt->sleep_time)
1461 pkt->sleep_time -= min_sleep_time - residue;
1462 if (pkt->sleep_time <= 0) {
1463 pkt->sleep_time = 0;
1464 atomic_inc(&pkt->run_sm);
2340 struct packet_data *pkt;
2352 list_for_each_entry(pkt, &pd->cdrw.pkt_active_list, list) {
2353 if (pkt->sector == zone) {
2354 spin_lock(&pkt->lock);
2355 if ((pkt->state == PACKET_WAITING_STATE) ||
2356 (pkt->state == PACKET_READ_WAIT_STATE)) {
2357 bio_list_add(&pkt->orig_bios, bio);
2358 pkt->write_size +=
2360 if ((pkt->write_size >= pkt->frames) &&
2361 (pkt->state == PACKET_WAITING_STATE)) {
2362 atomic_inc(&pkt->run_sm);
2365 spin_unlock(&pkt->lock);
2371 spin_unlock(&pkt->lock);