sun4u/cpumem-diagnosis/cmd_Lxcacheerr.c

333 	int8_t way = -1;
337 			way = L2TAG_bit_to_way_map[bit & BIT_MASK];
340 			way = L3TAG_bit_to_way_map[bit & BIT_MASK];
343 	return (way);
507 			data_for_ecc_gen[1] = state[0];	/* way 0 state */
509 			    (state[1] << 3); /* way 1 state */
511 			    (state[2] << 6); /* way 2 state */
513 			    (state[3] << 9); /* way 3 state */
514 			data_for_ecc_gen[1] |= (ptag[0] << 12); /* way 0 ptag */
515 			data_for_ecc_gen[1] |= (ptag[2] << 36); /* way 2 ptag */
522 			data_for_ecc_gen[0] |= (ptag[1] << 12); /* way 1 ptag */
523 			data_for_ecc_gen[0] |= (ptag[3] << 36); /* way 3 ptag */
528 			 * Swizzle state bits for way 1 and way 3
539 			 * Swizzle physical tag bits for way 1 and way 3
554 			 * Swizzle state bits for way 0 and way 2
565 			 * Swizzle physical tag bits for way 0 and way 2
594 find_bit_stickiness(uint64_t *tag_data, int8_t way, int16_t bit)
599 	if ((tag_data[way] & ((uint64_t)1 << bit)) != 0)
625 		    " index %d way %d bit %d\n",
692 	 * a new Lxcache if we were successful in determining a way to retire.
711 	 * Before retiring a way check if we have already
736 	 * We need to retire the lowest unretired way as suspect.
740 	    " way at index %d\n",
746 		    "\n%s: cpu_id %d lowest retirable way is %d\n",
764 		    " way is faulty at cache index %d."
795 	    "\n%s:cpu_id %d found index %d way %d"
801 	 * Save the way because we will destroy the
816 		    "\n%s:cpu_id %d index %d way %d"
830 	 * retire the next retirable way
837 		 * There is no retirable way that is next to the
840 		 * way is reporting the errors.
844 		    " which way is faulty at cache index %d."
858 		    "\n%s:cpu_id %d found way %d at index %d to"
863 		 * The existing Lxcache is for anonymous way.
963 	int8_t		way;
1016 		 * We will create a Lxcache structure for this index with way
1021 		way = -1;
1024 		    index, way, bit);
1037 				    " index = %d way %d bit %d\n",
1038 				    fltnm, cpu->cpu_cpuid, index, way, bit);
1080 		 * with anonymous way and bit created.
1084 			    cpu->cpu_asru_nvl, pstype, index, way, bit);
1156 			    way, bit);
1182 		 * determine way and bit
1202 			way = 0;
1208 			way = bit_to_way(pstype, tag_bit);
1209 			if (way < 0) {
1223 	    index, way,
1236 		    pstype, index, way, bit);
1240 		    " way %d bit %d\n",
1241 		    fltnm, cpu->cpu_cpuid, index, way, bit);
1252 		    way, bit);
1268 	if (way >= 0) {
1284 	if (way == -1) {
1288 		 * identifed a way to retire. If we cannot detrmine a way to
1294 		 * Anonymous TAG way retirement.
1295 		 * - if a way at this index has already been retired as
1296 		 *   "suspect-1", unretire that way, and retire the next
1297 		 *   unretired way as "suspect-0", using a pattern of all zeros
1299 		 * - if a way at this index has already been retired as
1300 		 *   "suspect-0", re-retire that way as "suspect-1", using a
1303 		 *   retire the lowest unretired way as "suspect-0" for this
1305 		 * - if there is no next retirable way, fault the CPU.
1320 			    "\n%s:cpu_id %d found index %d way %d"
1353 		 * We need to retire the lowest unretired way as suspect.
1361 	 * Identified bit and way has fired.
1364 	 * - If the way was already convicted due to tag errors, fault the CPU.
1367 	 *   retire the containing way as "convicted".
1372 	sticky_bit = find_bit_stickiness(tag_data, way, bit);
1376 		    "\n%s:cpu_id %d Bad ECC bit %d at cache index %d way %d"
1378 		    fltnm, cpu->cpu_cpuid, bit, index, way);
1385 	 * make the way NA, else fault the CPU.
1393 		 * retire the containing way Else fault the cpu.
1395 		state = tag_data[way] & CH_ECSTATE_MASK;
1403 			    " cache index %d way %d. STATE = 0x%x\n"
1407 			    fltnm, cpu->cpu_cpuid, bit, index, way, state);
1413 	 * Check if we are getting fault on a way that is already retired.
1414 	 * if the way was already convicted due to tag errors, fault the CPU.
1415 	 * Note that the way could have previously been retired due to
1419 	if ((tag_data[way] & CH_ECSTATE_MASK) == PN_ECSTATE_NA) {
1425 		    cpu, pstype, index, way, CMD_LXCONVICTED);
1428 			    "\n%s: cpu %d: The cache index %d way %d previously"
1431 			    fltnm, cpu->cpu_cpuid, index, way,
1441 	 * If any way(Including the current way) at this index is retired as
1442 	 * "suspect" due to tag errors, unretire it.  (If that suspect way
1451 		    "\n%s:cpu_id %d found index %d way %d"
1464 			    "\n%s:cpu_id %d index %d way %d"
1473 			 * SUSPECT way at the fault index.
1474 			 * If the previously retired way is same as the way
1486 	 * Before retiring a way check if we have already
1488 	 * If the way was already retired due to DATA error or
1518 	int8_t	way;
1526 	for (way = 0; way < xr->xr_num_ways; way++, ecp++) {
1559 			" 0x%x index = %d way = %d\n",
1566 					    " 0x%x index = %d way = %d\n",
1568 					    way);
1569 					xr->xr_error_way = way;
1610  *	line fault if the way is not anonomyous.
1611  *	If the way is anonomyous, it will attempt to choose a way for the
1613  *	reached, it will attempt to unretire a different way previously retired
1615  *	the selected way.
1705 	 * will be 4. If a matching way is found only that entry is logged
1708 	 * xr_error_way is set to the matching way.
1719 			 * overwrites the problematic way.  Any match is due to
1721 			 * way. So these are treated as "anonymous".
1730 			 * a snoop, the problematic way could become invalid,
1732 			 * AFAR accessed and pulled into a different way,
1734 			 * look for a matching way and just ascribe these to
1735 			 *  the "anonymous" way.
1750 			 * that identifies the way.
1756 			    "\n%s:cpu_id %d: error way = %d\n",
1764 			 * valid way is found, it is likely to be the correct
1765 			 * way.
1771 			    "\n%s:cpu_id %d: error way = %d\n",
1789 		    "\n%s: cpu %d: creating a case for index %d way %d"
1800 			    " index %d way %d bit %d\n",
1851 	 * Find out if there is a way at the fault index/bit that was retired
1852 	 * as suspect. We need this information for both anonymous way and
1853 	 * identified way handling. We store this info in suspect_Lxcache.
1856 	    "\n%s:cpu_id %d checking if there is a way at"
1867 		 * If there is a way at that index retired as suspect due
1869 		 * retire the identified way, and mark the way as "convicted"
1875 			    "\n%s:cpu_id %d found index %d way %d"
1892 			 * We proceed to retire the identified way even if
1893 			 * we are unable to unretire the suspect way.
1902 		 * Before retiring a way check if we have already
1912 			    " way %d\n",
1935 		 * but way as -1.
1945 	 * - if a way at this index has already been retired as "suspect"
1946 	 * for this bit, unretire that way, and retire the next retirable
1947 	 * way as "suspect" for this bit.
1949 	 * retire the lowest unretired way as "suspect" for this bit.
1950 	 * - if there is no next retirable way, fault the CPU.
1955 	 * identifed a way to retire. If we cannot detrmine a way to
2039 	 * Our error handler checks for a matching valid way
2041 	 * associated with the cache-line/way that was "valid"
2047 	/* If there is more than 1 way structure, set way to Anonymous */