Changeset b5b07cad in rtems for cpukit/libblock
- Timestamp:
- 10/29/09 12:50:01 (14 years ago)
- Branches:
- 4.10, 4.11, 5, master
- Children:
- 90d24022
- Parents:
- 982ca110
- Location:
- cpukit/libblock
- Files:
-
- 4 edited
Legend:
- Unmodified
- Added
- Removed
-
cpukit/libblock/include/rtems/bdbuf.h
r982ca110 rb5b07cad 32 32 extern "C" { 33 33 #endif 34 34 35 35 /** 36 36 * @defgroup rtems_libblock Block Device Library … … 184 184 struct rtems_bdbuf_avl_node 185 185 { 186 signed char cache; /**< Cache */187 186 struct rtems_bdbuf_buffer* left; /**< Left Child */ 188 187 struct rtems_bdbuf_buffer* right; /**< Right Child */ 188 signed char cache; /**< Cache */ 189 189 signed char bal; /**< The balance of the sub-tree */ 190 190 } avl; -
cpukit/libblock/src/bdbuf.c
r982ca110 rb5b07cad 31 31 #include "config.h" 32 32 #endif 33 34 #include <inttypes.h>35 36 #include <rtems.h>37 #include <rtems/error.h>38 #include <rtems/malloc.h>39 33 #include <limits.h> 40 34 #include <errno.h> 41 35 #include <assert.h> 42 36 #include <stdio.h> 37 #include <string.h> 38 #include <inttypes.h> 39 40 #include <rtems.h> 41 #include <rtems/error.h> 42 #include <rtems/malloc.h> 43 43 44 44 #include "rtems/bdbuf.h" 45 46 #define BDBUF_INVALID_DEV ((dev_t) -1) 45 47 46 48 /* … … 77 79 78 80 /** 81 * Buffer waiters synchronization. 82 */ 83 typedef struct rtems_bdbuf_waiters { 84 volatile unsigned count; 85 rtems_id sema; 86 } rtems_bdbuf_waiters; 87 88 /** 79 89 * The BD buffer cache. 80 90 */ … … 102 112 volatile bool sync_active; /**< True if a sync is active. */ 103 113 volatile rtems_id sync_requester; /**< The sync requester. */ 104 volatile dev_t sync_device; /**< The device to sync and -1 not a 105 * device sync. */ 114 volatile dev_t sync_device; /**< The device to sync and 115 * BDBUF_INVALID_DEV not a device 116 * sync. */ 106 117 107 118 rtems_bdbuf_buffer* tree; /**< Buffer descriptor lookup AVL tree … … 113 124 rtems_chain_control sync; /**< Buffers to sync list */ 114 125 115 rtems_id access; /**< Obtain if waiting for a buffer in 116 * the ACCESS state. */ 117 volatile uint32_t access_waiters; /**< Count of access blockers. */ 118 rtems_id transfer; /**< Obtain if waiting for a buffer in 119 * the TRANSFER state. */ 120 volatile uint32_t transfer_waiters; /**< Count of transfer blockers. */ 121 rtems_id waiting; /**< Obtain if waiting for a buffer 122 * and the none are available. */ 123 volatile uint32_t wait_waiters; /**< Count of waiting blockers. */ 126 rtems_bdbuf_waiters access_waiters; /**< Wait for a buffer in ACCESS 127 * state. */ 128 rtems_bdbuf_waiters transfer_waiters; /**< Wait for a buffer in TRANSFER 129 * state. */ 130 rtems_bdbuf_waiters buffer_waiters; /**< Wait for a buffer and no one is 131 * available. */ 124 132 125 133 size_t group_count; /**< The number of groups. */ … … 149 157 #define RTEMS_BLKDEV_FATAL_BDBUF_CACHE_LOCK RTEMS_BLKDEV_FATAL_ERROR(13) 150 158 #define RTEMS_BLKDEV_FATAL_BDBUF_CACHE_UNLOCK RTEMS_BLKDEV_FATAL_ERROR(14) 151 #define RTEMS_BLKDEV_FATAL_BDBUF_ CACHE_WAIT_1RTEMS_BLKDEV_FATAL_ERROR(15)159 #define RTEMS_BLKDEV_FATAL_BDBUF_PREEMPT_DIS RTEMS_BLKDEV_FATAL_ERROR(15) 152 160 #define RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAIT_2 RTEMS_BLKDEV_FATAL_ERROR(16) 153 #define RTEMS_BLKDEV_FATAL_BDBUF_ CACHE_WAIT_3RTEMS_BLKDEV_FATAL_ERROR(17)161 #define RTEMS_BLKDEV_FATAL_BDBUF_PREEMPT_RST RTEMS_BLKDEV_FATAL_ERROR(17) 154 162 #define RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAIT_TO RTEMS_BLKDEV_FATAL_ERROR(18) 155 163 #define RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAKE RTEMS_BLKDEV_FATAL_ERROR(19) … … 249 257 uint32_t total = 0; 250 258 uint32_t val; 259 251 260 for (group = 0; group < bdbuf_cache.group_count; group++) 252 261 total += bdbuf_cache.groups[group].users; … … 278 287 const char* states[] = 279 288 { "EM", "RA", "CH", "AC", "MD", "AM", "SY", "TR" }; 280 printf ("bdbuf:users: %15s: [%ld (%s)] %ld:%ld = %lu %s\n", 289 290 printf ("bdbuf:users: %15s: [%" PRIu32 " (%s)] %td:%td = %" PRIu32 " %s\n", 281 291 where, 282 292 bd->block, states[bd->state], … … 871 881 } 872 882 883 static rtems_mode 884 rtems_bdbuf_disable_preemption (void) 885 { 886 rtems_status_code sc = RTEMS_SUCCESSFUL; 887 rtems_mode prev_mode = 0; 888 889 sc = rtems_task_mode (RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &prev_mode); 890 if (sc != RTEMS_SUCCESSFUL) 891 rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_PREEMPT_DIS); 892 893 return prev_mode; 894 } 895 896 static void 897 rtems_bdbuf_restore_preemption (rtems_mode prev_mode) 898 { 899 rtems_status_code sc = RTEMS_SUCCESSFUL; 900 901 sc = rtems_task_mode (prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode); 902 if (sc != RTEMS_SUCCESSFUL) 903 rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_PREEMPT_RST); 904 } 905 873 906 /** 874 907 * Wait until woken. Semaphores are used so a number of tasks can wait and can … … 890 923 */ 891 924 static void 892 rtems_bdbuf_wait (rtems_ id* sema, volatile uint32_t* waiters)925 rtems_bdbuf_wait (rtems_bdbuf_waiters* waiters) 893 926 { 894 927 rtems_status_code sc; … … 898 931 * Indicate we are waiting. 899 932 */ 900 *waiters += 1;933 ++waiters->count; 901 934 902 935 /* … … 910 943 * semaphore. 911 944 */ 912 sc = rtems_task_mode (RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &prev_mode); 913 914 if (sc != RTEMS_SUCCESSFUL) 915 rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAIT_1); 945 prev_mode = rtems_bdbuf_disable_preemption (); 916 946 917 947 /* … … 920 950 rtems_bdbuf_unlock_cache (); 921 951 922 sc = rtems_semaphore_obtain ( *sema, RTEMS_WAIT, RTEMS_BDBUF_WAIT_TIMEOUT);952 sc = rtems_semaphore_obtain (waiters->sema, RTEMS_WAIT, RTEMS_BDBUF_WAIT_TIMEOUT); 923 953 924 954 if (sc == RTEMS_TIMEOUT) … … 930 960 rtems_bdbuf_lock_cache (); 931 961 932 sc = rtems_task_mode (prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode); 933 934 if (sc != RTEMS_SUCCESSFUL) 935 rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAIT_3); 936 937 *waiters -= 1; 962 rtems_bdbuf_restore_preemption (prev_mode); 963 964 --waiters->count; 938 965 } 939 966 … … 941 968 * Wake a blocked resource. The resource has a counter that lets us know if 942 969 * there are any waiters. 943 *944 * @param sema The semaphore to release.945 * @param waiters The wait counter for this semaphore.946 970 */ 947 971 static void 948 rtems_bdbuf_wake (rtems_id sema, volatile uint32_t* waiters) 949 { 950 if (*waiters) 951 { 952 rtems_status_code sc; 953 954 sc = rtems_semaphore_flush (sema); 955 972 rtems_bdbuf_wake (const rtems_bdbuf_waiters *waiters) 973 { 974 rtems_status_code sc = RTEMS_SUCCESSFUL; 975 976 if (waiters->count > 0) 977 { 978 sc = rtems_semaphore_flush (waiters->sema); 956 979 if (sc != RTEMS_SUCCESSFUL) 957 980 rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAKE); … … 1150 1173 uint8_t* buffer; 1151 1174 size_t b; 1152 intcache_aligment;1175 size_t cache_aligment; 1153 1176 rtems_status_code sc; 1177 rtems_mode prev_mode; 1154 1178 1155 1179 if (rtems_bdbuf_tracer) 1156 1180 printf ("bdbuf:init\n"); 1181 1182 if (rtems_interrupt_is_in_progress()) 1183 return RTEMS_CALLED_FROM_ISR; 1157 1184 1158 1185 /* … … 1167 1194 * makes a call and we have not finished initialisation. 1168 1195 */ 1196 prev_mode = rtems_bdbuf_disable_preemption (); 1169 1197 if (bdbuf_cache.initialised) 1198 { 1199 rtems_bdbuf_restore_preemption (prev_mode); 1200 1170 1201 return RTEMS_RESOURCE_IN_USE; 1171 1202 } 1203 memset(&bdbuf_cache, 0, sizeof(bdbuf_cache)); 1172 1204 bdbuf_cache.initialised = true; 1205 rtems_bdbuf_restore_preemption (prev_mode); 1173 1206 1174 1207 /* … … 1179 1212 cache_aligment = CPU_ALIGNMENT; 1180 1213 1181 bdbuf_cache.sync_active = false; 1182 bdbuf_cache.sync_device = -1; 1183 bdbuf_cache.sync_requester = 0; 1184 bdbuf_cache.tree = NULL; 1214 bdbuf_cache.sync_device = BDBUF_INVALID_DEV; 1185 1215 1186 1216 rtems_chain_initialize_empty (&bdbuf_cache.swapout_workers); … … 1190 1220 rtems_chain_initialize_empty (&bdbuf_cache.sync); 1191 1221 1192 bdbuf_cache.access = 0;1193 bdbuf_cache.access_waiters = 0;1194 bdbuf_cache.transfer = 0;1195 bdbuf_cache.transfer_waiters = 0;1196 bdbuf_cache.waiting = 0;1197 bdbuf_cache.wait_waiters = 0;1198 1199 1222 /* 1200 1223 * Create the locks for the cache. … … 1204 1227 &bdbuf_cache.lock); 1205 1228 if (sc != RTEMS_SUCCESSFUL) 1206 { 1207 bdbuf_cache.initialised = false; 1208 return sc; 1209 } 1229 goto error; 1210 1230 1211 1231 rtems_bdbuf_lock_cache (); … … 1215 1235 &bdbuf_cache.sync_lock); 1216 1236 if (sc != RTEMS_SUCCESSFUL) 1217 { 1218 rtems_bdbuf_unlock_cache (); 1219 rtems_semaphore_delete (bdbuf_cache.lock); 1220 bdbuf_cache.initialised = false; 1221 return sc; 1222 } 1237 goto error; 1223 1238 1224 1239 sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'a'), 1225 1240 0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0, 1226 &bdbuf_cache.access );1241 &bdbuf_cache.access_waiters.sema); 1227 1242 if (sc != RTEMS_SUCCESSFUL) 1228 { 1229 rtems_semaphore_delete (bdbuf_cache.sync_lock); 1230 rtems_bdbuf_unlock_cache (); 1231 rtems_semaphore_delete (bdbuf_cache.lock); 1232 bdbuf_cache.initialised = false; 1233 return sc; 1234 } 1243 goto error; 1235 1244 1236 1245 sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 't'), 1237 1246 0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0, 1238 &bdbuf_cache.transfer );1247 &bdbuf_cache.transfer_waiters.sema); 1239 1248 if (sc != RTEMS_SUCCESSFUL) 1240 { 1241 rtems_semaphore_delete (bdbuf_cache.access); 1242 rtems_semaphore_delete (bdbuf_cache.sync_lock); 1243 rtems_bdbuf_unlock_cache (); 1244 rtems_semaphore_delete (bdbuf_cache.lock); 1245 bdbuf_cache.initialised = false; 1246 return sc; 1247 } 1249 goto error; 1248 1250 1249 1251 sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'w'), 1250 1252 0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0, 1251 &bdbuf_cache. waiting);1253 &bdbuf_cache.buffer_waiters.sema); 1252 1254 if (sc != RTEMS_SUCCESSFUL) 1253 { 1254 rtems_semaphore_delete (bdbuf_cache.transfer); 1255 rtems_semaphore_delete (bdbuf_cache.access); 1256 rtems_semaphore_delete (bdbuf_cache.sync_lock); 1257 rtems_bdbuf_unlock_cache (); 1258 rtems_semaphore_delete (bdbuf_cache.lock); 1259 bdbuf_cache.initialised = false; 1260 return sc; 1261 } 1255 goto error; 1262 1256 1263 1257 /* … … 1277 1271 bdbuf_cache.buffer_min_count); 1278 1272 if (!bdbuf_cache.bds) 1279 { 1280 rtems_semaphore_delete (bdbuf_cache.transfer); 1281 rtems_semaphore_delete (bdbuf_cache.access); 1282 rtems_semaphore_delete (bdbuf_cache.sync_lock); 1283 rtems_bdbuf_unlock_cache (); 1284 rtems_semaphore_delete (bdbuf_cache.lock); 1285 bdbuf_cache.initialised = false; 1286 return RTEMS_NO_MEMORY; 1287 } 1273 goto error; 1288 1274 1289 1275 /* … … 1293 1279 bdbuf_cache.group_count); 1294 1280 if (!bdbuf_cache.groups) 1295 { 1296 free (bdbuf_cache.bds); 1297 rtems_semaphore_delete (bdbuf_cache.transfer); 1298 rtems_semaphore_delete (bdbuf_cache.access); 1299 rtems_semaphore_delete (bdbuf_cache.sync_lock); 1300 rtems_bdbuf_unlock_cache (); 1301 rtems_semaphore_delete (bdbuf_cache.lock); 1302 bdbuf_cache.initialised = false; 1303 return RTEMS_NO_MEMORY; 1304 } 1281 goto error; 1305 1282 1306 1283 /* … … 1314 1291 cache_aligment, 1315 1292 bdbuf_cache.buffer_min_count * bdbuf_config.buffer_min) != 0) 1316 { 1317 free (bdbuf_cache.groups); 1318 free (bdbuf_cache.bds); 1319 rtems_semaphore_delete (bdbuf_cache.transfer); 1320 rtems_semaphore_delete (bdbuf_cache.access); 1321 rtems_semaphore_delete (bdbuf_cache.sync_lock); 1322 rtems_bdbuf_unlock_cache (); 1323 rtems_semaphore_delete (bdbuf_cache.lock); 1324 bdbuf_cache.initialised = false; 1325 return RTEMS_NO_MEMORY; 1326 } 1293 goto error; 1327 1294 1328 1295 /* … … 1335 1302 b++, bd++, buffer += bdbuf_config.buffer_min) 1336 1303 { 1337 bd->dev = -1;1304 bd->dev = BDBUF_INVALID_DEV; 1338 1305 bd->group = group; 1339 1306 bd->buffer = buffer; … … 1382 1349 &bdbuf_cache.swapout); 1383 1350 if (sc != RTEMS_SUCCESSFUL) 1384 { 1385 free (bdbuf_cache.buffers); 1386 free (bdbuf_cache.groups); 1387 free (bdbuf_cache.bds); 1388 rtems_semaphore_delete (bdbuf_cache.transfer); 1389 rtems_semaphore_delete (bdbuf_cache.access); 1390 rtems_semaphore_delete (bdbuf_cache.sync_lock); 1391 rtems_bdbuf_unlock_cache (); 1392 rtems_semaphore_delete (bdbuf_cache.lock); 1393 bdbuf_cache.initialised = false; 1394 return sc; 1395 } 1351 goto error; 1396 1352 1397 1353 sc = rtems_task_start (bdbuf_cache.swapout, … … 1399 1355 (rtems_task_argument) &bdbuf_cache); 1400 1356 if (sc != RTEMS_SUCCESSFUL) 1401 { 1357 goto error; 1358 1359 rtems_bdbuf_unlock_cache (); 1360 1361 return RTEMS_SUCCESSFUL; 1362 1363 error: 1364 1365 if (bdbuf_cache.swapout != 0) 1402 1366 rtems_task_delete (bdbuf_cache.swapout); 1403 free (bdbuf_cache.buffers); 1404 free (bdbuf_cache.groups); 1405 free (bdbuf_cache.bds); 1406 rtems_semaphore_delete (bdbuf_cache.transfer); 1407 rtems_semaphore_delete (bdbuf_cache.access); 1408 rtems_semaphore_delete (bdbuf_cache.sync_lock); 1367 1368 free (bdbuf_cache.buffers); 1369 free (bdbuf_cache.groups); 1370 free (bdbuf_cache.bds); 1371 1372 rtems_semaphore_delete (bdbuf_cache.buffer_waiters.sema); 1373 rtems_semaphore_delete (bdbuf_cache.access_waiters.sema); 1374 rtems_semaphore_delete (bdbuf_cache.transfer_waiters.sema); 1375 rtems_semaphore_delete (bdbuf_cache.sync_lock); 1376 1377 if (bdbuf_cache.lock != 0) 1378 { 1409 1379 rtems_bdbuf_unlock_cache (); 1410 1380 rtems_semaphore_delete (bdbuf_cache.lock); 1411 bdbuf_cache.initialised = false; 1412 return sc; 1413 } 1414 1415 rtems_bdbuf_unlock_cache (); 1416 1417 return RTEMS_SUCCESSFUL; 1381 } 1382 1383 bdbuf_cache.initialised = false; 1384 1385 return RTEMS_UNSATISFIED; 1418 1386 } 1419 1387 … … 1588 1556 * placed on the LRU list. 1589 1557 */ 1590 rtems_bdbuf_wait (&bdbuf_cache. waiting, &bdbuf_cache.wait_waiters);1558 rtems_bdbuf_wait (&bdbuf_cache.buffer_waiters); 1591 1559 } 1592 1560 } … … 1671 1639 case RTEMS_BDBUF_STATE_ACCESS_MODIFIED: 1672 1640 bd->waiters++; 1673 rtems_bdbuf_wait (&bdbuf_cache.access , &bdbuf_cache.access_waiters);1641 rtems_bdbuf_wait (&bdbuf_cache.access_waiters); 1674 1642 bd->waiters--; 1675 1643 break; … … 1678 1646 case RTEMS_BDBUF_STATE_TRANSFER: 1679 1647 bd->waiters++; 1680 rtems_bdbuf_wait (&bdbuf_cache.transfer , &bdbuf_cache.transfer_waiters);1648 rtems_bdbuf_wait (&bdbuf_cache.transfer_waiters); 1681 1649 bd->waiters--; 1682 1650 break; … … 1744 1712 */ 1745 1713 if (rtems_bdbuf_tracer) 1746 printf ("bdbuf:get: % lu (%lu) (dev = %08x)\n",1747 media_block, block, (unsigned int) device);1714 printf ("bdbuf:get: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n", 1715 media_block, block, (unsigned) device); 1748 1716 1749 1717 bd = rtems_bdbuf_get_buffer (dd, bds_per_group, media_block, false); … … 1860 1828 */ 1861 1829 if (rtems_bdbuf_tracer) 1862 printf ("bdbuf:read: % lu (%lu) (dev = %08x)\n",1863 media_block + dd->start, block, (unsigned int) device);1830 printf ("bdbuf:read: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n", 1831 media_block + dd->start, block, (unsigned) device); 1864 1832 1865 1833 /* … … 2035 2003 2036 2004 if (wake_transfer) 2037 rtems_bdbuf_wake ( bdbuf_cache.transfer,&bdbuf_cache.transfer_waiters);2005 rtems_bdbuf_wake (&bdbuf_cache.transfer_waiters); 2038 2006 else 2039 rtems_bdbuf_wake ( bdbuf_cache.waiting, &bdbuf_cache.wait_waiters);2007 rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters); 2040 2008 2041 2009 bd = req->bufs[0].user; … … 2093 2061 2094 2062 if (rtems_bdbuf_tracer) 2095 printf ("bdbuf:release: % lu\n", bd->block);2063 printf ("bdbuf:release: %" PRIu32 "\n", bd->block); 2096 2064 2097 2065 if (bd->state == RTEMS_BDBUF_STATE_ACCESS_MODIFIED) … … 2118 2086 */ 2119 2087 if (bd->waiters) 2120 rtems_bdbuf_wake ( bdbuf_cache.access,&bdbuf_cache.access_waiters);2088 rtems_bdbuf_wake (&bdbuf_cache.access_waiters); 2121 2089 else 2122 rtems_bdbuf_wake ( bdbuf_cache.waiting, &bdbuf_cache.wait_waiters);2090 rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters); 2123 2091 2124 2092 if (rtems_bdbuf_tracer) … … 2142 2110 2143 2111 if (rtems_bdbuf_tracer) 2144 printf ("bdbuf:release modified: % lu\n", bd->block);2112 printf ("bdbuf:release modified: %" PRIu32 "\n", bd->block); 2145 2113 2146 2114 bd->hold_timer = rtems_bdbuf_configuration.swap_block_hold; … … 2152 2120 2153 2121 if (bd->waiters) 2154 rtems_bdbuf_wake ( bdbuf_cache.access,&bdbuf_cache.access_waiters);2122 rtems_bdbuf_wake (&bdbuf_cache.access_waiters); 2155 2123 2156 2124 if (rtems_bdbuf_tracer) … … 2168 2136 2169 2137 if (rtems_bdbuf_tracer) 2170 printf ("bdbuf:sync: % lu\n", bd->block);2138 printf ("bdbuf:sync: %" PRIu32 "\n", bd->block); 2171 2139 2172 2140 if (!bdbuf_cache.initialised) … … 2200 2168 case RTEMS_BDBUF_STATE_TRANSFER: 2201 2169 bd->waiters++; 2202 rtems_bdbuf_wait (&bdbuf_cache.transfer , &bdbuf_cache.transfer_waiters);2170 rtems_bdbuf_wait (&bdbuf_cache.transfer_waiters); 2203 2171 bd->waiters--; 2204 2172 break; … … 2222 2190 2223 2191 if (rtems_bdbuf_tracer) 2224 printf ("bdbuf:syncdev: %08x\n", (unsigned int) dev);2192 printf ("bdbuf:syncdev: %08x\n", (unsigned) dev); 2225 2193 2226 2194 if (!bdbuf_cache.initialised) … … 2304 2272 2305 2273 if (rtems_bdbuf_tracer) 2306 printf ("bdbuf:swapout transfer: %08x\n", (unsigned int) transfer->dev);2274 printf ("bdbuf:swapout transfer: %08x\n", (unsigned) transfer->dev); 2307 2275 2308 2276 /* … … 2358 2326 2359 2327 if (rtems_bdbuf_tracer) 2360 printf ("bdbuf:swapout write: bd:% lu, bufnum:%lumode:%s\n",2328 printf ("bdbuf:swapout write: bd:%" PRIu32 ", bufnum:%" PRIu32 " mode:%s\n", 2361 2329 bd->block, transfer->write_req->bufnum, 2362 2330 dd->phys_dev->capabilities & … … 2397 2365 2398 2366 if (rtems_bdbuf_tracer) 2399 printf ("bdbuf:swapout write: writing bufnum:% lu\n",2367 printf ("bdbuf:swapout write: writing bufnum:%" PRIu32 "\n", 2400 2368 transfer->write_req->bufnum); 2401 2369 … … 2455 2423 2456 2424 if (bd->waiters) 2457 rtems_bdbuf_wake ( bdbuf_cache.transfer,&bdbuf_cache.transfer_waiters);2425 rtems_bdbuf_wake (&bdbuf_cache.transfer_waiters); 2458 2426 else 2459 rtems_bdbuf_wake ( bdbuf_cache.waiting, &bdbuf_cache.wait_waiters);2427 rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters); 2460 2428 } 2461 2429 } … … 2489 2457 * needs to be handled so we have a common function to do the work. 2490 2458 * 2491 * @param dev The device to handle. If -1 no device is selected so select the2492 * 2459 * @param dev The device to handle. If BDBUF_INVALID_DEV no device is selected 2460 * so select the device of the first buffer to be written to disk. 2493 2461 * @param chain The modified chain to process. 2494 2462 * @param transfer The chain to append buffers to be written too. … … 2543 2511 2544 2512 /* 2545 * This assumes we can set dev_t to -1which is just an2513 * This assumes we can set dev_t to BDBUF_INVALID_DEV which is just an 2546 2514 * assumption. Cannot use the transfer list being empty the sync dev 2547 2515 * calls sets the dev to use. 2548 2516 */ 2549 if (*dev == (dev_t)-1)2517 if (*dev == BDBUF_INVALID_DEV) 2550 2518 *dev = bd->dev; 2551 2519 … … 2640 2608 2641 2609 rtems_chain_initialize_empty (&transfer->bds); 2642 transfer->dev = -1;2610 transfer->dev = BDBUF_INVALID_DEV; 2643 2611 2644 2612 /* 2645 2613 * When the sync is for a device limit the sync to that device. If the sync 2646 2614 * is for a buffer handle process the devices in the order on the sync 2647 * list. This means the dev is -1.2615 * list. This means the dev is BDBUF_INVALID_DEV. 2648 2616 */ 2649 2617 if (bdbuf_cache.sync_active) … … 2771 2739 2772 2740 rtems_chain_initialize_empty (&worker->transfer.bds); 2773 worker->transfer.dev = -1;2741 worker->transfer.dev = BDBUF_INVALID_DEV; 2774 2742 2775 2743 rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link); … … 2808 2776 2809 2777 rtems_chain_initialize_empty (&worker->transfer.bds); 2810 worker->transfer.dev = -1;2778 worker->transfer.dev = BDBUF_INVALID_DEV; 2811 2779 2812 2780 sc = rtems_task_create (rtems_build_name('B', 'D', 'o', 'a' + w), … … 2870 2838 transfer.write_req = rtems_bdbuf_swapout_writereq_alloc (); 2871 2839 rtems_chain_initialize_empty (&transfer.bds); 2872 transfer.dev = -1;2840 transfer.dev = BDBUF_INVALID_DEV; 2873 2841 2874 2842 /* … … 2942 2910 rtems_task_delete (RTEMS_SELF); 2943 2911 } 2944 -
cpukit/libblock/src/bdpart.c
r982ca110 rb5b07cad 350 350 sc = rtems_bdpart_read_record( disk, 0, &block); 351 351 if (sc != RTEMS_SUCCESSFUL) { 352 return sc; 352 esc = sc; 353 goto cleanup; 353 354 } 354 355 … … 393 394 sc = rtems_bdpart_read_record( disk, ebr, &block); 394 395 if (sc != RTEMS_SUCCESSFUL) { 395 return sc; 396 esc = sc; 397 goto cleanup; 396 398 } 397 399 -
cpukit/libblock/src/blkdev.c
r982ca110 rb5b07cad 38 38 void * arg) 39 39 { 40 rtems_status_code rc = RTEMS_SUCCESSFUL; 40 41 rtems_libio_rw_args_t *args = arg; 41 int block_size;42 char 43 u nsigned int count;44 unsigned intblock;45 u nsigned int blkofs;42 uint32_t block_size; 43 char *buf; 44 uint32_t count; 45 rtems_blkdev_bnum block; 46 uint32_t blkofs; 46 47 dev_t dev; 47 48 rtems_disk_device *dd; … … 58 59 args->bytes_moved = 0; 59 60 60 block = args->offset / block_size;61 blkofs = args->offset % block_size;61 block = (rtems_blkdev_bnum) (args->offset / block_size); 62 blkofs = (uint32_t) (args->offset % block_size); 62 63 63 64 while (count > 0) … … 65 66 rtems_bdbuf_buffer *diskbuf; 66 67 uint32_t copy; 67 rtems_status_code rc;68 68 69 69 rc = rtems_bdbuf_read(dev, block, &diskbuf); 70 70 if (rc != RTEMS_SUCCESSFUL) 71 return rc;71 break; 72 72 copy = block_size - blkofs; 73 73 if (copy > count) … … 77 77 args->bytes_moved += copy; 78 78 if (rc != RTEMS_SUCCESSFUL) 79 return rc;79 break; 80 80 count -= copy; 81 81 buf += copy; … … 83 83 block++; 84 84 } 85 return RTEMS_SUCCESSFUL; 85 86 rtems_disk_release(dd); 87 88 return rc; 86 89 } 87 90 … … 96 99 void * arg) 97 100 { 101 rtems_status_code rc = RTEMS_SUCCESSFUL; 98 102 rtems_libio_rw_args_t *args = arg; 99 uint32_t block_size; 100 char *buf; 101 uint32_t count; 102 uint32_t block; 103 uint32_t blkofs; 104 dev_t dev; 105 rtems_status_code rc; 103 uint32_t block_size; 104 char *buf; 105 uint32_t count; 106 rtems_blkdev_bnum block; 107 uint32_t blkofs; 108 dev_t dev; 106 109 rtems_disk_device *dd; 107 110 … … 117 120 args->bytes_moved = 0; 118 121 119 block = args->offset / block_size;120 blkofs = args->offset % block_size;122 block = (rtems_blkdev_bnum) (args->offset / block_size); 123 blkofs = (uint32_t) (args->offset % block_size); 121 124 122 125 while (count > 0) … … 130 133 rc = rtems_bdbuf_read(dev, block, &diskbuf); 131 134 if (rc != RTEMS_SUCCESSFUL) 132 return rc;135 break; 133 136 134 137 copy = block_size - blkofs; … … 140 143 rc = rtems_bdbuf_release_modified(diskbuf); 141 144 if (rc != RTEMS_SUCCESSFUL) 142 return rc;145 break; 143 146 144 147 count -= copy; … … 147 150 block++; 148 151 } 149 return RTEMS_SUCCESSFUL; 152 153 rtems_disk_release(dd); 154 155 return rc; 150 156 } 151 157
Note: See TracChangeset
for help on using the changeset viewer.