159 }

   160 

   161 /*

   162  * Counted byte string compare routine, optimized for file ids.

   163  */

   164 int

   165 nfs_fhbcmp(char *d1, char *d2, int l)

   166 {

   167 	int k;

   168 

   169 	if (l > NFS_FHMAXDATA)

   170 		return (1);

   171 

   172 	/*

   173 	 * We are always passed pointers to the data portions of

   174 	 * two fids, where pointers are always 2 bytes from 32 bit

   175 	 * alignment. If the length is also 2 bytes off word alignment,

   176 	 * we can do word compares, because the two bytes before the fid

   177 	 * data are always the length packed into a 16 bit short, so we

   178 	 * can safely start our comparisons at d1-2 and d2-2.

   179 	 * If the length is 2 bytes off word alignment, that probably

   180 	 * means that first two bytes are zeroes. This means that

   181 	 * first word in each fid, including the length are going to be

   182 	 * equal (we wouldn't call fhbcmp if the lengths weren't the

   183 	 * same). Thus it makes the most sense to start comparing the

   184 	 * last words of each data portion.

   185 	 */

   186 

   187 	if ((l & 0x3) == 2) {

   188 		/*

   189 		 * We are going move the data pointers to the

   190 		 * last word. Adding just the length, puts us to the

   191 		 * word past end of the data. So reduce length by one

   192 		 * word length.

   193 		 */

   194 		k = l - 4;

   195 		/*

   196 		 * Both adjusted length and the data pointer are offset two

   197 		 * bytes from word alignment. Adding them together gives

   198 		 * us word alignment.

   199 		 */

   200 		d1 += k;

   201 		d2 += k;

   202 		l += 2;

   203 		while (l -= 4) {

   204 			if (*(int *)d1 != *(int *)d2)

   205 				return (1);

   206 			d1 -= 4;

   207 			d2 -= 4;

   208 		}

   209 	} else {

   210 		while (l--) {

   211 			if (*d1++ != *d2++)

   212 				return (1);

   213 		}

   214 	}

   215 	return (0);