Changeset 18daff9 in rtems for cpukit/libblock
- Timestamp:
- 11/29/09 13:35:32 (14 years ago)
- Branches:
- 4.10, 4.11, 5, master
- Children:
- 28352fae
- Parents:
- 0a7278e
- Location:
- cpukit/libblock/src
- Files:
-
- 8 edited
Legend:
- Unmodified
- Added
- Removed
-
cpukit/libblock/src/bdbuf.c
r0a7278e r18daff9 21 21 * 22 22 * Copyright (c) 2009 embedded brains GmbH. 23 * 23 * 24 24 * @(#) bdbuf.c,v 1.14 2004/04/17 08:15:17 ralf Exp 25 25 */ … … 99 99 rtems_chain_control swapout_workers; /**< The work threads for the swapout 100 100 * task. */ 101 101 102 102 rtems_bdbuf_buffer* bds; /**< Pointer to table of buffer 103 103 * descriptors. */ … … 133 133 size_t group_count; /**< The number of groups. */ 134 134 rtems_bdbuf_group* groups; /**< The groups. */ 135 135 136 136 bool initialised; /**< Initialised state. */ 137 137 } rtems_bdbuf_cache; … … 417 417 p = q; 418 418 } 419 419 420 420 q->avl.left = q->avl.right = NULL; 421 421 q->avl.bal = 0; … … 952 952 rtems_status_code sc; 953 953 rtems_mode prev_mode; 954 954 955 955 /* 956 956 * Indicate we are waiting. … … 969 969 */ 970 970 prev_mode = rtems_bdbuf_disable_preemption (); 971 971 972 972 /* 973 973 * Unlock the cache, wait, and lock the cache when we return. … … 979 979 if (sc == RTEMS_TIMEOUT) 980 980 rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAIT_TO); 981 981 982 982 if (sc != RTEMS_UNSATISFIED) 983 983 rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAIT_2); 984 984 985 985 rtems_bdbuf_lock_cache (); 986 986 987 987 rtems_bdbuf_restore_preemption (prev_mode); 988 988 989 989 --waiters->count; 990 990 } … … 1061 1061 if (bd->state == RTEMS_BDBUF_STATE_ACCESS) 1062 1062 bd->hold_timer = bdbuf_config.swap_block_hold; 1063 1063 1064 1064 rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_MODIFIED); 1065 1065 … … 1108 1108 size_t bufs_per_size; 1109 1109 size_t bds_per_size; 1110 1110 1111 1111 if (size > bdbuf_config.buffer_max) 1112 1112 return 0; 1113 1113 1114 1114 bufs_per_size = ((size - 1) / bdbuf_config.buffer_min) + 1; 1115 1115 1116 1116 for (bds_per_size = 1; 1117 1117 bds_per_size < bufs_per_size; … … 1136 1136 rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_10); 1137 1137 } 1138 1138 1139 1139 rtems_chain_extract (&bd->link); 1140 1140 } … … 1167 1167 group - bdbuf_cache.groups, group->bds_per_group, 1168 1168 new_bds_per_group); 1169 1169 1170 1170 bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group; 1171 1171 1172 1172 for (b = 0, bd = group->bdbuf; 1173 1173 b < group->bds_per_group; 1174 1174 b++, bd += bufs_per_bd) 1175 1175 rtems_bdbuf_remove_from_cache_and_lru_list (bd); 1176 1176 1177 1177 group->bds_per_group = new_bds_per_group; 1178 1178 bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group; 1179 1179 1180 1180 for (b = 1, bd = group->bdbuf + bufs_per_bd; 1181 1181 b < group->bds_per_group; … … 1280 1280 if ((bdbuf_config.buffer_max % bdbuf_config.buffer_min) != 0) 1281 1281 return RTEMS_INVALID_NUMBER; 1282 1282 1283 1283 /* 1284 1284 * We use a special variable to manage the initialisation incase we have … … 1296 1296 bdbuf_cache.initialised = true; 1297 1297 rtems_bdbuf_restore_preemption (prev_mode); 1298 1298 1299 1299 /* 1300 1300 * For unspecified cache alignments we use the CPU alignment. … … 1321 1321 1322 1322 rtems_bdbuf_lock_cache (); 1323 1323 1324 1324 sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 's'), 1325 1325 1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0, … … 1327 1327 if (sc != RTEMS_SUCCESSFUL) 1328 1328 goto error; 1329 1329 1330 1330 sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'a'), 1331 1331 0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0, … … 1345 1345 if (sc != RTEMS_SUCCESSFUL) 1346 1346 goto error; 1347 1347 1348 1348 /* 1349 1349 * Compute the various number of elements in the cache. … … 1371 1371 if (!bdbuf_cache.groups) 1372 1372 goto error; 1373 1373 1374 1374 /* 1375 1375 * Allocate memory for buffer memory. The buffer memory will be cache … … 1377 1377 * with free(). Return 0 if allocated. 1378 1378 * 1379 * The memory allocate allows a 1379 * The memory allocate allows a 1380 1380 */ 1381 1381 if (rtems_memalign ((void **) &bdbuf_cache.buffers, … … 1396 1396 bd->group = group; 1397 1397 bd->buffer = buffer; 1398 1398 1399 1399 rtems_chain_append (&bdbuf_cache.lru, &bd->link); 1400 1400 … … 1415 1415 group->bdbuf = bd; 1416 1416 } 1417 1417 1418 1418 /* 1419 1419 * Create and start swapout task. This task will create and manage the worker … … 1421 1421 */ 1422 1422 bdbuf_cache.swapout_enabled = true; 1423 1423 1424 1424 sc = rtems_task_create (rtems_build_name('B', 'S', 'W', 'P'), 1425 1425 bdbuf_config.swapout_priority ? … … 1473 1473 rtems_status_code sc = RTEMS_SUCCESSFUL; 1474 1474 rtems_event_set out = 0; 1475 1475 1476 1476 sc = rtems_event_receive (event, 1477 1477 RTEMS_EVENT_ALL | RTEMS_WAIT, … … 1596 1596 if (!rtems_chain_is_empty (&bdbuf_cache.modified)) 1597 1597 rtems_bdbuf_wake_swapper (); 1598 1598 1599 1599 rtems_bdbuf_anonymous_wait (&bdbuf_cache.buffer_waiters); 1600 1600 } … … 1606 1606 { 1607 1607 rtems_bdbuf_buffer *bd = NULL; 1608 1608 1609 1609 bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dev, block); 1610 1610 … … 1632 1632 { 1633 1633 rtems_bdbuf_buffer *bd = NULL; 1634 1634 1635 1635 do 1636 1636 { … … 1778 1778 break; 1779 1779 } 1780 1780 1781 1781 if (rtems_bdbuf_tracer) 1782 1782 { … … 1867 1867 if (bd == NULL) 1868 1868 break; 1869 1869 1870 1870 req->bufs [transfer_index].user = bd; 1871 1871 req->bufs [transfer_index].block = media_block; … … 1901 1901 bool wake_transfer = false; 1902 1902 bool wake_buffer = false; 1903 1903 1904 1904 rtems_bdbuf_unlock_cache (); 1905 1905 … … 1910 1910 req->status = RTEMS_RESOURCE_IN_USE; 1911 1911 req->error = 0; 1912 1912 1913 1913 result = dd->ioctl (dd, RTEMS_BLKIO_REQUEST, req); 1914 1914 … … 1920 1920 else 1921 1921 error = errno; 1922 1922 1923 1923 rtems_bdbuf_lock_cache (); 1924 1924 … … 1995 1995 sizeof ( rtems_blkdev_sg_buffer) * 1996 1996 (bdbuf_config.max_read_ahead_blocks + 1)); 1997 1997 1998 1998 if (rtems_bdbuf_tracer) 1999 1999 printf ("bdbuf:read: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n", … … 2023 2023 rtems_bdbuf_show_usage (); 2024 2024 } 2025 2025 2026 2026 rtems_bdbuf_unlock_cache (); 2027 2027 rtems_bdbuf_release_disk (dd); … … 2070 2070 break; 2071 2071 } 2072 2072 2073 2073 if (rtems_bdbuf_tracer) 2074 2074 rtems_bdbuf_show_usage (); 2075 2075 2076 2076 rtems_bdbuf_unlock_cache (); 2077 2077 … … 2098 2098 break; 2099 2099 } 2100 2100 2101 2101 if (rtems_bdbuf_tracer) 2102 2102 rtems_bdbuf_show_usage (); 2103 2103 2104 2104 rtems_bdbuf_unlock_cache (); 2105 2105 … … 2126 2126 break; 2127 2127 } 2128 2128 2129 2129 if (rtems_bdbuf_tracer) 2130 2130 rtems_bdbuf_show_usage (); … … 2141 2141 2142 2142 rtems_bdbuf_unlock_cache (); 2143 2143 2144 2144 return RTEMS_SUCCESSFUL; 2145 2145 } … … 2165 2165 */ 2166 2166 rtems_bdbuf_lock_sync (); 2167 rtems_bdbuf_lock_cache (); 2167 rtems_bdbuf_lock_cache (); 2168 2168 2169 2169 /* … … 2177 2177 bdbuf_cache.sync_requester = rtems_task_self (); 2178 2178 bdbuf_cache.sync_device = dev; 2179 2179 2180 2180 rtems_bdbuf_wake_swapper (); 2181 2181 rtems_bdbuf_unlock_cache (); … … 2219 2219 { 2220 2220 rtems_disk_device* dd; 2221 2221 2222 2222 if (rtems_bdbuf_tracer) 2223 2223 printf ("bdbuf:swapout transfer: %08x\n", (unsigned) transfer->dev); … … 2246 2246 */ 2247 2247 uint32_t bufs_per_bd = dd->block_size / bdbuf_config.buffer_min; 2248 2248 2249 2249 /* 2250 2250 * Take as many buffers as configured and pass to the driver. Note, the … … 2266 2266 2267 2267 bool write = false; 2268 2268 2269 2269 /* 2270 2270 * If the device only accepts sequential buffers and this is not the … … 2273 2273 * the committed buffers. 2274 2274 */ 2275 2275 2276 2276 if (rtems_bdbuf_tracer) 2277 2277 printf ("bdbuf:swapout write: bd:%" PRIu32 ", bufnum:%" PRIu32 " mode:%s\n", … … 2279 2279 dd->phys_dev->capabilities & 2280 2280 RTEMS_BLKDEV_CAP_MULTISECTOR_CONT ? "MULIT" : "SCAT"); 2281 2281 2282 2282 if ((dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) && 2283 2283 transfer->write_req->bufnum && … … 2321 2321 * device is being held. 2322 2322 */ 2323 result = dd->ioctl (dd, RTEMS_BLKIO_REQUEST, transfer->write_req); 2323 result = dd->ioctl (dd, RTEMS_BLKIO_REQUEST, transfer->write_req); 2324 2324 if (result < 0) 2325 2325 { 2326 2326 rtems_bdbuf_lock_cache (); 2327 2327 2328 2328 for (b = 0; b < transfer->write_req->bufnum; b++) 2329 2329 { … … 2359 2359 2360 2360 rtems_chain_append (&bdbuf_cache.lru, &bd->link); 2361 2361 2362 2362 if (bd->waiters) 2363 2363 rtems_bdbuf_wake (&bdbuf_cache.transfer_waiters); … … 2377 2377 } 2378 2378 } 2379 2379 2380 2380 rtems_disk_release (dd); 2381 2381 } … … 2420 2420 { 2421 2421 rtems_bdbuf_buffer* bd = (rtems_bdbuf_buffer*) node; 2422 2422 2423 2423 /* 2424 2424 * Check if the buffer's hold timer has reached 0. If a sync is active … … 2430 2430 if (sync_active || rtems_bdbuf_has_buffer_waiters ()) 2431 2431 bd->hold_timer = 0; 2432 2432 2433 2433 if (bd->hold_timer) 2434 2434 { … … 2460 2460 rtems_chain_node* next_node = node->next; 2461 2461 rtems_chain_node* tnode = rtems_chain_tail (transfer); 2462 2462 2463 2463 /* 2464 2464 * The blocks on the transfer list are sorted in block order. This … … 2473 2473 2474 2474 tnode = tnode->previous; 2475 2475 2476 2476 while (node && !rtems_chain_is_head (transfer, tnode)) 2477 2477 { … … 2486 2486 tnode = tnode->previous; 2487 2487 } 2488 2488 2489 2489 if (node) 2490 2490 rtems_chain_prepend (transfer, node); 2491 2491 2492 2492 node = next_node; 2493 2493 } … … 2544 2544 transfer = &worker->transfer; 2545 2545 } 2546 2546 2547 2547 rtems_chain_initialize_empty (&transfer->bds); 2548 2548 transfer->dev = BDBUF_INVALID_DEV; 2549 2549 2550 2550 /* 2551 2551 * When the sync is for a device limit the sync to that device. If the sync … … 2555 2555 if (bdbuf_cache.sync_active) 2556 2556 transfer->dev = bdbuf_cache.sync_device; 2557 2557 2558 2558 /* 2559 2559 * If we have any buffers in the sync queue move them to the modified … … 2599 2599 rtems_bdbuf_swapout_write (transfer); 2600 2600 } 2601 2601 2602 2602 transfered_buffers = true; 2603 2603 } 2604 2604 2605 2605 if (bdbuf_cache.sync_active && !transfered_buffers) 2606 2606 { … … 2614 2614 rtems_event_send (sync_requester, RTEMS_BDBUF_TRANSFER_SYNC); 2615 2615 } 2616 2616 2617 2617 return transfered_buffers; 2618 2618 } … … 2670 2670 2671 2671 rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link); 2672 2672 2673 2673 rtems_bdbuf_unlock_cache (); 2674 2674 } … … 2688 2688 rtems_status_code sc; 2689 2689 size_t w; 2690 2690 2691 2691 rtems_bdbuf_lock_cache (); 2692 2692 2693 2693 for (w = 0; w < bdbuf_config.swapout_workers; w++) 2694 2694 { … … 2702 2702 worker->enabled = true; 2703 2703 worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc (); 2704 2704 2705 2705 rtems_chain_initialize_empty (&worker->transfer.bds); 2706 2706 worker->transfer.dev = BDBUF_INVALID_DEV; … … 2723 2723 rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WK_START); 2724 2724 } 2725 2725 2726 2726 rtems_bdbuf_unlock_cache (); 2727 2727 } … … 2734 2734 { 2735 2735 rtems_chain_node* node; 2736 2736 2737 2737 rtems_bdbuf_lock_cache (); 2738 2738 2739 2739 node = rtems_chain_first (&bdbuf_cache.swapout_workers); 2740 2740 while (!rtems_chain_is_tail (&bdbuf_cache.swapout_workers, node)) … … 2745 2745 node = rtems_chain_next (node); 2746 2746 } 2747 2747 2748 2748 rtems_bdbuf_unlock_cache (); 2749 2749 } … … 2782 2782 */ 2783 2783 rtems_bdbuf_swapout_workers_open (); 2784 2784 2785 2785 while (bdbuf_cache.swapout_enabled) 2786 2786 { … … 2792 2792 */ 2793 2793 bool update_timers = true; 2794 2794 2795 2795 /* 2796 2796 * If we write buffers to any disk perform a check again. We only write a … … 2815 2815 transfered_buffers = true; 2816 2816 } 2817 2817 2818 2818 /* 2819 2819 * Only update the timers once. … … 2833 2833 2834 2834 rtems_bdbuf_swapout_workers_close (); 2835 2835 2836 2836 free (transfer.write_req); 2837 2837 -
cpukit/libblock/src/blkdev.c
r0a7278e r18daff9 6 6 * Block device management. 7 7 */ 8 8 9 9 /* 10 10 * Copyright (C) 2001 OKTET Ltd., St.-Petersburg, Russia … … 273 273 size_t *arg_size = argp; 274 274 int rc = 0; 275 275 276 276 switch (req) 277 277 { -
cpukit/libblock/src/diskdevs.c
r0a7278e r18daff9 6 6 * @brief Block device disk management implementation. 7 7 */ 8 8 9 9 /* 10 10 * Copyright (C) 2001 OKTET Ltd., St.-Petersburg, Russia … … 191 191 if (name != NULL) { 192 192 alloc_name = strdup(name); 193 193 194 194 if (alloc_name == NULL) { 195 195 free(dd); … … 267 267 dd->capabilities = 0; 268 268 } 269 269 270 270 disk_unlock(); 271 271 -
cpukit/libblock/src/flashdisk.c
r0a7278e r18daff9 247 247 uint32_t avail_compact_segs; /**< The number of segments when 248 248 compaction occurs when writing. */ 249 249 250 250 uint32_t block_size; /**< The block size for this disk. */ 251 251 rtems_fdisk_block_ctl* blocks; /**< The block to segment-page … … 253 253 uint32_t block_count; /**< The number of avail. blocks. */ 254 254 uint32_t unavail_blocks; /**< The number of unavail blocks. */ 255 255 256 256 rtems_fdisk_device_ctl* devices; /**< The flash devices for this 257 257 disk. */ … … 304 304 * @retval RTEMS_NO_MEMORY The table could not be allocated from the heap. 305 305 */ 306 rtems_status_code 306 rtems_status_code 307 307 rtems_fdisk_crc16_gen_factors (uint16_t pattern) 308 308 { … … 457 457 sc->next = queue->head; 458 458 queue->head = sc; 459 459 460 460 if (queue->tail == 0) 461 461 queue->tail = sc; … … 498 498 { 499 499 sc->next = 0; 500 500 501 501 if (queue->head) 502 502 { … … 762 762 if (rtems_fdisk_page_desc_erased (pd)) 763 763 break; 764 764 765 765 return page; 766 766 } … … 841 841 device, segment, offset, size); 842 842 #endif 843 return ops->read (sd, device, segment, offset, buffer, size); 843 return ops->read (sd, device, segment, offset, buffer, size); 844 844 } 845 845 … … 865 865 device, segment, offset, size); 866 866 #endif 867 return ops->write (sd, device, segment, offset, buffer, size); 867 return ops->write (sd, device, segment, offset, buffer, size); 868 868 } 869 869 … … 886 886 device, segment, offset, size); 887 887 #endif 888 return ops->blank (sd, device, segment, offset, size); 888 return ops->blank (sd, device, segment, offset, size); 889 889 } 890 890 /** … … 907 907 device, segment, offset, size); 908 908 #endif 909 return ops->verify (sd, device, segment, offset, buffer, size); 909 return ops->verify (sd, device, segment, offset, buffer, size); 910 910 } 911 911 … … 1016 1016 if (ret) 1017 1017 return ret; 1018 } 1018 } 1019 1019 return rtems_fdisk_seg_write (fd, device, segment, offset, 1020 1020 page_desc, sizeof (rtems_fdisk_page_desc)); … … 1096 1096 { 1097 1097 int ret; 1098 1098 1099 1099 #if RTEMS_FDISK_TRACE 1100 1100 rtems_fdisk_info (fd, " erase-flash:%02d", device); … … 1149 1149 sc->pages_used = 0; 1150 1150 sc->pages_bad = 0; 1151 1151 1152 1152 sc->failed = false; 1153 1153 … … 1213 1213 return; 1214 1214 } 1215 1215 1216 1216 /* 1217 1217 * Remove the queue from the available or used queue. … … 1237 1237 */ 1238 1238 rtems_fdisk_segment_ctl* seg = fd->used.head; 1239 1239 1240 1240 while (seg) 1241 1241 { … … 1325 1325 rtems_fdisk_printf (fd, " compacting"); 1326 1326 #endif 1327 1327 1328 1328 dsc = rtems_fdisk_seg_most_available (&fd->available); 1329 1329 … … 1333 1333 return EIO; 1334 1334 } 1335 1335 1336 1336 ssc = fd->used.head; 1337 1337 dst_pages = rtems_fdisk_seg_pages_available (dsc); 1338 1338 segments = 0; 1339 1339 pages = 0; 1340 1340 1341 1341 #if RTEMS_FDISK_TRACE 1342 1342 rtems_fdisk_printf (fd, " dsc:%02d-%03d: most available", 1343 1343 dsc->device, dsc->segment); 1344 1344 #endif 1345 1345 1346 1346 /* 1347 1347 * Count the number of segments that have active pages that fit into … … 1351 1351 * will fill. 1352 1352 */ 1353 1353 1354 1354 while (ssc && 1355 1355 ((pages + ssc->pages_active) < dst_pages) && … … 1366 1366 * to free at least one more segment. 1367 1367 */ 1368 1368 1369 1369 if (!ssc || (pages == 0) || ((compacted_segs + segments) == 1)) 1370 1370 break; … … 1375 1375 pages, segments); 1376 1376 #endif 1377 1377 1378 1378 rtems_fdisk_segment_queue_remove (&fd->available, dsc); 1379 1379 … … 1381 1381 * We now copy the pages to the new segment. 1382 1382 */ 1383 1383 1384 1384 while (pages) 1385 1385 { … … 1405 1405 dpage = rtems_fdisk_seg_next_available_page (dsc); 1406 1406 dpd = &dsc->page_descriptors[dpage]; 1407 1407 1408 1408 active++; 1409 1409 1410 1410 if (dpage >= dsc->pages) 1411 1411 { … … 1419 1419 return EIO; 1420 1420 } 1421 1421 1422 1422 #if RTEMS_FDISK_TRACE 1423 1423 rtems_fdisk_info (fd, "compacting: %02d-%03d-%03d=>%02d-%03d-%03d", … … 1470 1470 * be. 1471 1471 */ 1472 1472 1473 1473 ssc->pages_active--; 1474 1474 ssc->pages_used++; 1475 1475 1476 1476 fd->blocks[spd->block].segment = dsc; 1477 1477 fd->blocks[spd->block].page = dpage; … … 1481 1481 */ 1482 1482 rtems_fdisk_queue_segment (fd, dsc); 1483 1483 1484 1484 pages--; 1485 1485 } … … 1498 1498 ssc->pages_active); 1499 1499 } 1500 1500 1501 1501 ret = rtems_fdisk_erase_segment (fd, ssc); 1502 1502 … … 1519 1519 { 1520 1520 uint32_t device; 1521 1521 1522 1522 /* 1523 1523 * Clear the queues. … … 1546 1546 uint32_t page; 1547 1547 int ret; 1548 1548 1549 1549 #if RTEMS_FDISK_TRACE 1550 1550 rtems_fdisk_info (fd, "recover-block-mappings:%02d-%03d", device, segment); … … 1560 1560 1561 1561 sc->failed = false; 1562 1562 1563 1563 if (!sc->page_descriptors) 1564 1564 sc->page_descriptors = malloc (sc->pages_desc * fd->block_size); … … 1566 1566 if (!sc->page_descriptors) 1567 1567 rtems_fdisk_abort ("no memory for page descriptors"); 1568 1568 1569 1569 pd = sc->page_descriptors; 1570 1570 … … 1616 1616 ret = rtems_fdisk_seg_write_page_desc (fd, device, segment, 1617 1617 page, pd); 1618 1618 1619 1619 if (ret) 1620 1620 { … … 1623 1623 sc->failed = true; 1624 1624 } 1625 1625 1626 1626 sc->pages_used++; 1627 1627 } … … 1774 1774 1775 1775 cs = rtems_fdisk_page_checksum (buffer, fd->block_size); 1776 1776 1777 1777 if (cs == pd->crc) 1778 1778 return 0; 1779 1779 1780 1780 rtems_fdisk_error ("read-block: crc failure: %d: buffer:%04x page:%04x", 1781 1781 block, cs, pd->crc); … … 1831 1831 uint32_t page; 1832 1832 int ret; 1833 1833 1834 1834 #if RTEMS_FDISK_TRACE 1835 1835 rtems_fdisk_info (fd, "write-block:%d", block); … … 1873 1873 return 0; 1874 1874 } 1875 1875 1876 1876 /* 1877 1877 * The page exists in flash so we need to set the used flag … … 1882 1882 1883 1883 rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_USED); 1884 1884 1885 1885 ret = rtems_fdisk_seg_write_page_desc_flags (fd, sc->device, sc->segment, 1886 1886 bc->page, pd); … … 1901 1901 sc->pages_used++; 1902 1902 } 1903 1903 1904 1904 /* 1905 1905 * If possible reuse this segment. This will mean the segment … … 1926 1926 fd->avail_compact_segs) 1927 1927 rtems_fdisk_compact (fd); 1928 1928 1929 1929 /* 1930 1930 * Get the next avaliable segment. … … 1948 1948 */ 1949 1949 sc = rtems_fdisk_segment_queue_pop_head (&fd->available); 1950 1950 1951 1951 if (!sc) 1952 1952 { … … 1965 1965 } 1966 1966 #endif 1967 1967 1968 1968 /* 1969 1969 * Find the next avaliable page in the segment. … … 1981 1981 bc->segment = sc; 1982 1982 bc->page = page; 1983 1983 1984 1984 rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_ACTIVE); 1985 1985 … … 2027 2027 } 2028 2028 } 2029 2029 2030 2030 rtems_fdisk_queue_segment (fd, sc); 2031 2031 return ret; … … 2074 2074 req->req_done (req->done_arg, 2075 2075 ret ? RTEMS_SUCCESSFUL : RTEMS_IO_ERROR, ret); 2076 2076 2077 2077 return ret; 2078 2078 } … … 2110 2110 req->req_done (req->done_arg, 2111 2111 ret ? RTEMS_SUCCESSFUL : RTEMS_IO_ERROR, ret); 2112 2112 2113 2113 return 0; 2114 2114 } … … 2184 2184 { 2185 2185 data->segment_count += fd->devices[i].segment_count; 2186 2186 2187 2187 for (j = 0; j < fd->devices[i].segment_count; j++) 2188 2188 { 2189 2189 rtems_fdisk_segment_ctl* sc = &fd->devices[i].segments[j]; 2190 2190 2191 2191 data->page_count += sc->pages; 2192 2192 data->pages_desc += sc->pages_desc; … … 2215 2215 2216 2216 fd->info_level = 3; 2217 2217 2218 2218 rtems_fdisk_printf (fd, 2219 2219 "Flash Disk Driver Status : %d.%d", fd->major, fd->minor); … … 2251 2251 uint32_t block; 2252 2252 uint32_t seg; 2253 2253 2254 2254 rtems_fdisk_printf (fd, " Device\t\t%ld", device); 2255 2255 rtems_fdisk_printf (fd, " Segment count\t%ld", … … 2294 2294 } 2295 2295 } 2296 2296 2297 2297 count = 0; 2298 2298 for (block = 0; block < fd->block_count; block++) … … 2376 2376 errno = rtems_fdisk_write (&rtems_flashdisks[minor], r); 2377 2377 break; 2378 2378 2379 2379 default: 2380 2380 errno = EINVAL; … … 2463 2463 2464 2464 fd = &rtems_flashdisks[minor]; 2465 2465 2466 2466 name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor; 2467 2467 2468 2468 fd->major = major; 2469 2469 fd->minor = minor; … … 2474 2474 fd->unavail_blocks = c->unavail_blocks; 2475 2475 fd->info_level = c->info_level; 2476 2476 2477 2477 for (device = 0; device < c->device_count; device++) 2478 2478 blocks += rtems_fdisk_blocks_in_device (&c->devices[device], 2479 2479 c->block_size); 2480 2480 2481 2481 sc = rtems_disk_create_phys(dev, c->block_size, 2482 2482 blocks - fd->unavail_blocks, … … 2487 2487 return sc; 2488 2488 } 2489 2489 2490 2490 sc = rtems_semaphore_create (rtems_build_name ('F', 'D', 'S', 'K'), 1, 2491 2491 RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE | … … 2503 2503 if (!fd->copy_buffer) 2504 2504 return RTEMS_NO_MEMORY; 2505 2505 2506 2506 fd->blocks = calloc (blocks, sizeof (rtems_fdisk_block_ctl)); 2507 2507 if (!fd->blocks) … … 2521 2521 2522 2522 segment_count = rtems_fdisk_count_segments (&c->devices[device]); 2523 2523 2524 2524 fd->devices[device].segments = calloc (segment_count, 2525 2525 sizeof (rtems_fdisk_segment_ctl)); … … 2528 2528 2529 2529 sc = fd->devices[device].segments; 2530 2530 2531 2531 for (segment = 0; segment < c->devices[device].segment_count; segment++) 2532 2532 { … … 2544 2544 } 2545 2545 } 2546 2546 2547 2547 fd->devices[device].segment_count = segment_count; 2548 2548 fd->devices[device].descriptor = &c->devices[device]; 2549 2549 } 2550 2550 2551 2551 fd->device_count = c->device_count; 2552 2552 -
cpukit/libblock/src/nvdisk-sram.c
r0a7278e r18daff9 11 11 12 12 #if HAVE_CONFIG_H 13 #include "config.h" 13 #include "config.h" 14 14 #endif 15 15 … … 28 28 rtems_nvdisk_sram_read (uint32_t device __attribute__((unused)), 29 29 uint32_t flags __attribute__((unused)), 30 uint32_t base, 30 uint32_t base, 31 31 uint32_t offset, 32 32 void* buffer, … … 40 40 rtems_nvdisk_sram_write (uint32_t device __attribute__((unused)), 41 41 uint32_t flags __attribute__((unused)), 42 uint32_t base, 42 uint32_t base, 43 43 uint32_t offset, 44 44 const void* buffer, … … 52 52 rtems_nvdisk_sram_verify (uint32_t device __attribute__((unused)), 53 53 uint32_t flags __attribute__((unused)), 54 uint32_t base, 54 uint32_t base, 55 55 uint32_t offset, 56 56 const void* buffer, -
cpukit/libblock/src/nvdisk.c
r0a7278e r18daff9 64 64 */ 65 65 uint32_t device; 66 66 67 67 /** 68 68 * Total number of pages in the device. … … 135 135 * @retval RTEMS_NO_MEMORY The table could not be allocated from the heap. 136 136 */ 137 rtems_status_code 137 rtems_status_code 138 138 rtems_nvdisk_crc16_gen_factors (uint16_t pattern) 139 139 { … … 276 276 device, offset, size); 277 277 #endif 278 return ops->read (device, dd->flags, dd->base, offset, buffer, size); 278 return ops->read (device, dd->flags, dd->base, offset, buffer, size); 279 279 } 280 280 … … 297 297 device, offset, size); 298 298 #endif 299 return ops->write (device, dd->flags, dd->base, offset, buffer, size); 299 return ops->write (device, dd->flags, dd->base, offset, buffer, size); 300 300 } 301 301 … … 319 319 device, offset, size); 320 320 #endif 321 return ops->verify (device, dd->flags, dd->base, offset, buffer, size); 321 return ops->verify (device, dd->flags, dd->base, offset, buffer, size); 322 322 } 323 323 #endif … … 428 428 { 429 429 uint32_t device; 430 430 431 431 if (block >= nvd->block_count) 432 432 { … … 457 457 return block - dc->block_base; 458 458 } 459 459 460 460 /** 461 461 * Read a block. The block is checked to see if the page referenced … … 476 476 uint16_t cs; 477 477 int ret; 478 478 479 479 dc = rtems_nvdisk_get_device (nvd, block); 480 480 … … 483 483 484 484 page = rtems_nvdisk_get_page (dc, block); 485 485 486 486 #if RTEMS_NVDISK_TRACE 487 487 rtems_nvdisk_info (nvd, " read-block:%d=>%02d-%03d, cs:%04x", … … 502 502 return 0; 503 503 } 504 504 505 505 ret = rtems_nvdisk_read_page (nvd, dc->device, page + dc->pages_desc, buffer); 506 506 … … 509 509 510 510 cs = rtems_nvdisk_page_checksum (buffer, nvd->block_size); 511 511 512 512 if (cs != crc) 513 { 513 { 514 514 rtems_nvdisk_error ("read-block: crc failure: %d: buffer:%04x page:%04x", 515 515 block, cs, crc); … … 540 540 uint16_t cs; 541 541 int ret; 542 542 543 543 dc = rtems_nvdisk_get_device (nvd, block); 544 544 … … 547 547 548 548 page = rtems_nvdisk_get_page (dc, block); 549 549 550 550 cs = rtems_nvdisk_page_checksum (buffer, nvd->block_size); 551 551 … … 598 598 req->req_done (req->done_arg, 599 599 ret ? RTEMS_SUCCESSFUL : RTEMS_IO_ERROR, ret); 600 600 601 601 return ret; 602 602 } … … 638 638 req->req_done (req->done_arg, 639 639 ret ? RTEMS_SUCCESSFUL : RTEMS_IO_ERROR, ret); 640 640 641 641 return 0; 642 642 } … … 693 693 return -1; 694 694 } 695 695 696 696 if (rtems_nvdisks[minor].device_count == 0) 697 697 { … … 699 699 return -1; 700 700 } 701 701 702 702 errno = 0; 703 703 … … 716 716 errno = rtems_nvdisk_read (&rtems_nvdisks[minor], r); 717 717 break; 718 718 719 719 case RTEMS_BLKDEV_REQ_WRITE: 720 720 errno = rtems_nvdisk_write (&rtems_nvdisks[minor], r); 721 721 break; 722 722 723 723 default: 724 724 errno = EINVAL; … … 730 730 errno = rtems_nvdisk_erase_disk (&rtems_nvdisks[minor]); 731 731 break; 732 732 733 733 case RTEMS_NVDISK_IOCTL_INFO_LEVEL: 734 734 rtems_nvdisks[minor].info_level = (uint32_t) argp; 735 735 break; 736 736 737 737 default: 738 738 rtems_blkdev_ioctl (dd, req, argp); … … 788 788 789 789 nvd = &rtems_nvdisks[minor]; 790 790 791 791 name [sizeof(RTEMS_NVDISK_DEVICE_BASE_NAME)] += minor; 792 792 793 793 nvd->major = major; 794 794 nvd->minor = minor; … … 809 809 dc->pages_desc = rtems_nvdisk_page_desc_pages (nvd, &c->devices[device]); 810 810 dc->block_base = blocks; 811 811 812 812 blocks += dc->pages - dc->pages_desc; 813 813 … … 825 825 return sc; 826 826 } 827 827 828 828 sc = rtems_semaphore_create (rtems_build_name ('N', 'V', 'D', 'K'), 1, 829 829 RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE | -
cpukit/libblock/src/ramdisk-driver.c
r0a7278e r18daff9 118 118 break; 119 119 } 120 120 121 121 default: 122 122 return rtems_blkdev_ioctl (dd, req, argp); -
cpukit/libblock/src/show_bdbuf.c
r0a7278e r18daff9 84 84 bool modified; 85 85 bool in_progress; 86 bool actual; 86 bool actual; 87 87 int use_count; 88 88 const CORE_mutex_Control *sema; … … 129 129 if (rc == RTEMS_SUCCESSFUL) { 130 130 DISABLE_PREEMPTION(preempt_key); 131 } 131 } 132 132 /* 133 133 * follow node to its head 134 * XXX: this is highly dependent on the chain implementation 134 * XXX: this is highly dependent on the chain implementation 135 135 * in score/src/chain.c and friends 136 136 */ 137 137 while (the_node->previous != NULL) { 138 138 the_node = the_node->previous; 139 } 139 } 140 140 /* 141 141 * reenable preemption, if disabled … … 143 143 if (preempt_disabled) { 144 144 ENABLE_PREEMPTION(preempt_key); 145 } 146 /* 147 * XXX: this depends n the chain implementation in 148 * score/include/rtems/score/chain.h: 145 } 146 /* 147 * XXX: this depends n the chain implementation in 148 * score/include/rtems/score/chain.h: 149 149 * Chain_Control is overlayed by two Cohain_Nodes 150 150 */ … … 177 177 Chain_Control *the_chain_control; 178 178 179 179 180 180 *chn_ident = bdbuf_chain_ident_none; 181 181 if (rc == RTEMS_SUCCESSFUL) { … … 219 219 { 220 220 rtems_status_code sc = RTEMS_SUCCESSFUL; 221 int arg_error = 0; 221 int arg_error = 0; 222 222 int i; 223 223 char *tmp_ptr; … … 232 232 233 233 /* 234 * scan arguments 234 * scan arguments 235 235 */ 236 236 for (i = 1; … … 321 321 printf("%s: unknown argument %s\n",argv[0],argv[arg_error]); 322 322 sc = RTEMS_NOT_DEFINED; 323 } 323 } 324 324 return sc; 325 325 } … … 415 415 \*=========================================================================*/ 416 416 { 417 417 418 418 rtems_status_code rc = RTEMS_SUCCESSFUL; 419 419 … … 453 453 \*=========================================================================*/ 454 454 { 455 455 456 456 rtems_status_code rc = RTEMS_SUCCESSFUL; 457 457 458 /* 459 * determine the chain we are in 458 /* 459 * determine the chain we are in 460 460 */ 461 461 if (rc == RTEMS_SUCCESSFUL) { … … 477 477 bdbuf_info->in_progress = the_bdbuf->in_progress; 478 478 bdbuf_info->actual = the_bdbuf->actual; 479 bdbuf_info->use_count = the_bdbuf->use_count; 479 bdbuf_info->use_count = the_bdbuf->use_count; 480 480 bdbuf_info->sema = &(the_bdbuf->transfer_sema); 481 481 bdbuf_info->pool_id = the_bdbuf->pool; … … 504 504 \*=========================================================================*/ 505 505 { 506 506 507 507 rtems_status_code rc = RTEMS_SUCCESSFUL; 508 508 bool unmatch = false; 509 509 510 510 if (rc == RTEMS_SUCCESSFUL) { 511 511 if (filter->bdbuf_all) { … … 541 541 | rtems_status_code | 542 542 \*=========================================================================*/ 543 { 543 { 544 544 rtems_status_code rc = RTEMS_SUCCESSFUL; 545 545 Chain_Control *the_chain_head; … … 567 567 thread_id = the_thread->Object.id; 568 568 thread_name = the_thread->Object.name; 569 thread_name_nonstring = (uint32_t)thread_name.name_u32; 569 thread_name_nonstring = (uint32_t)thread_name.name_u32; 570 570 printf("%20s %3d (0x%08" PRIx32 ") %c%c%c%c\n", 571 571 ((thread_cnt == 1) ? "Threads waiting:" : ""), … … 578 578 the_chain_node = the_chain_node->next; 579 579 } 580 580 581 581 return rc; 582 582 } … … 602 602 \*=========================================================================*/ 603 603 { 604 604 605 605 rtems_status_code rc = RTEMS_SUCCESSFUL; 606 606 … … 659 659 else { 660 660 printf("%3" PRIu32 "%2" PRIu32, 661 ((bdbuf_info->dev == -1) 661 ((bdbuf_info->dev == -1) 662 662 ? 0 : rtems_filesystem_dev_major_t(bdbuf_info->dev)), 663 ((bdbuf_info->dev == -1) 663 ((bdbuf_info->dev == -1) 664 664 ? 0 : rtems_filesystem_dev_minor_t(bdbuf_info->dev))); 665 665 } … … 722 722 else { 723 723 printf("%20s:%-10s ", 724 ((bdbuf_info->status == RTEMS_SUCCESSFUL) 724 ((bdbuf_info->status == RTEMS_SUCCESSFUL) 725 725 ? "SUCCESSFUL" : rtems_status_text(bdbuf_info->status)), 726 ((bdbuf_info->status == RTEMS_SUCCESSFUL) 726 ((bdbuf_info->status == RTEMS_SUCCESSFUL) 727 727 ? "" : strerror(bdbuf_info->error))); 728 728 } … … 789 789 for (pool_idx = 0; 790 790 (rc == RTEMS_SUCCESSFUL) && (pool_idx < pool_cnt); 791 pool_idx++) { 792 if ((filter.pool_id < 0) || 791 pool_idx++) { 792 if ((filter.pool_id < 0) || 793 793 (filter.pool_id == pool_idx)) { 794 794 curr_pool = pool_base + pool_idx; … … 813 813 */ 814 814 for (bdbuf_idx = 0; 815 ((rc == RTEMS_SUCCESSFUL) && 815 ((rc == RTEMS_SUCCESSFUL) && 816 816 (bdbuf_idx < curr_pool->nblks)); 817 bdbuf_idx++) { 817 bdbuf_idx++) { 818 818 /* 819 819 * get infos about bdbuf … … 840 840 rc = rtems_show_bdbuf_print(&bdbuf_info,&selector, 841 841 false); 842 if ((rc == RTEMS_SUCCESSFUL) && 842 if ((rc == RTEMS_SUCCESSFUL) && 843 843 selector.show_sema) { 844 844 rc = rtems_show_bdbuf_print_wait_chain(&(curr_pool->bdbufs[bdbuf_idx])); … … 849 849 un_matched_cnt++; 850 850 } 851 } 851 } 852 852 } 853 853 /* … … 874 874 }; 875 875 876 #ifndef ARRAY_CNT 876 #ifndef ARRAY_CNT 877 877 #define ARRAY_CNT(arr) (sizeof((arr))/sizeof((arr)[0])) 878 878 #endif
Note: See TracChangeset
for help on using the changeset viewer.