xref: /freebsd/sys/dev/hptmv/hptproc.c (revision e4e9813eb92cd7c4d4b819a8fbed5cbd3d92f5d8)
1 /*
2  * Copyright (c) 2004-2005 HighPoint Technologies, Inc.
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  *
26  * $FreeBSD$
27  */
28 /*
29  * hptproc.c  sysctl support
30  */
31 #include <sys/param.h>
32 #include <sys/systm.h>
33 #include <sys/kernel.h>
34 #include <sys/malloc.h>
35 #include <sys/sysctl.h>
36 #include <machine/stdarg.h>
37 
38 #ifndef __KERNEL__
39 #define __KERNEL__
40 #endif
41 
42 #include <dev/hptmv/global.h>
43 #include <dev/hptmv/hptintf.h>
44 #include <dev/hptmv/osbsd.h>
45 #include <dev/hptmv/access601.h>
46 
47 int hpt_rescan_all(void);
48 
49 /***************************************************************************/
50 
51 static char hptproc_buffer[256];
52 extern char DRIVER_VERSION[];
53 
54 #define FORMAL_HANDLER_ARGS struct sysctl_oid *oidp, void *arg1, int arg2, \
55 	struct sysctl_req *req
56 #define REAL_HANDLER_ARGS oidp, arg1, arg2, req
57 typedef struct sysctl_req HPT_GET_INFO;
58 
59 static int
60 hpt_set_asc_info(IAL_ADAPTER_T *pAdapter, char *buffer,int length)
61 {
62 	int orig_length = length+4;
63 	PVBus _vbus_p = &pAdapter->VBus;
64 	PVDevice	 pArray;
65 	PVDevice pSubArray, pVDev;
66 	UINT	i, iarray, ichan;
67 	struct cam_periph *periph = NULL;
68 	intrmask_t oldspl;
69 
70 #ifdef SUPPORT_ARRAY
71 	if (length>=8 && strncmp(buffer, "rebuild ", 8)==0)
72 	{
73 		buffer+=8;
74 		length-=8;
75 		if (length>=5 && strncmp(buffer, "start", 5)==0)
76 		{
77 			oldspl = lock_driver();
78 			for(i = 0; i < MAX_ARRAY_PER_VBUS; i++)
79 				if ((pArray=ArrayTables(i))->u.array.dArStamp==0)
80 					continue;
81 				else{
82 					if (pArray->u.array.rf_need_rebuild && !pArray->u.array.rf_rebuilding)
83 	                    hpt_queue_dpc((HPT_DPC)hpt_rebuild_data_block, pAdapter, pArray,
84 							(UCHAR)((pArray->u.array.CriticalMembers || pArray->VDeviceType == VD_RAID_1)? DUPLICATE : REBUILD_PARITY));
85 				}
86 			unlock_driver(oldspl);
87 			return orig_length;
88 		}
89 		else if (length>=4 && strncmp(buffer, "stop", 4)==0)
90 		{
91 			oldspl = lock_driver();
92 			for(i = 0; i < MAX_ARRAY_PER_VBUS; i++)
93 				if ((pArray=ArrayTables(i))->u.array.dArStamp==0)
94 					continue;
95 				else{
96 					if (pArray->u.array.rf_rebuilding)
97 					    pArray->u.array.rf_abort_rebuild = 1;
98 				}
99 			unlock_driver(oldspl);
100 			return orig_length;
101 		}
102 		else if (length>=3 && buffer[1]==','&& buffer[0]>='1'&& buffer[2]>='1')
103 		{
104 			iarray = buffer[0]-'1';
105 	        ichan = buffer[2]-'1';
106 
107             if(iarray >= MAX_VDEVICE_PER_VBUS || ichan >= MV_SATA_CHANNELS_NUM) return -EINVAL;
108 
109 			pArray = _vbus_p->pVDevice[iarray];
110 	        if (!pArray || (pArray->vf_online == 0)) return -EINVAL;
111 
112             for (i=0;i<MV_SATA_CHANNELS_NUM;i++)
113 				if(i == ichan)
114 				    goto rebuild;
115 
116 	        return -EINVAL;
117 
118 rebuild:
119 	        pVDev = &pAdapter->VDevices[ichan];
120 	        if(!pVDev->u.disk.df_on_line || pVDev->pParent) return -EINVAL;
121 
122 	        /* Not allow to use a mounted disk ??? test*/
123 			for(i = 0; i < MAX_VDEVICE_PER_VBUS; i++)
124 			    if(pVDev == _vbus_p->pVDevice[i])
125 			    {
126 					periph = hpt_get_periph(pAdapter->mvSataAdapter.adapterId,i);
127 					if (periph != NULL && periph->refcount >= 1)
128 					{
129 						hpt_printk(("Can not use disk used by OS!\n"));
130 	                    return -EINVAL;
131 					}
132 					/* the Mounted Disk isn't delete */
133 				}
134 
135 			switch(pArray->VDeviceType)
136 			{
137 				case VD_RAID_1:
138 				case VD_RAID_5:
139 				{
140 					pSubArray = pArray;
141 loop:
142 					oldspl = lock_driver();
143 					if(hpt_add_disk_to_array(_VBUS_P VDEV_TO_ID(pSubArray), VDEV_TO_ID(pVDev)) == -1) {
144 						unlock_driver(oldspl);
145 						return -EINVAL;
146 					}
147 					pSubArray->u.array.rf_auto_rebuild = 0;
148 					pSubArray->u.array.rf_abort_rebuild = 0;
149 					hpt_queue_dpc((HPT_DPC)hpt_rebuild_data_block, pAdapter, pSubArray, DUPLICATE);
150 					unlock_driver(oldspl);
151 					break;
152 				}
153 				case VD_RAID_0:
154 					for (i = 0; (UCHAR)i < pArray->u.array.bArnMember; i++)
155 						if(pArray->u.array.pMember[i] && mIsArray(pArray->u.array.pMember[i]) &&
156 						   (pArray->u.array.pMember[i]->u.array.rf_broken == 1))
157 						{
158 							  pSubArray = pArray->u.array.pMember[i];
159 							  goto loop;
160 						}
161 				default:
162 					return -EINVAL;
163 			}
164 			return orig_length;
165 		}
166 	}
167 	else if (length>=7 && strncmp(buffer, "verify ", 7)==0)
168 	{
169 		buffer+=7;
170 		length-=7;
171         if (length>=6 && strncmp(buffer, "start ", 6)==0)
172 		{
173             buffer+=6;
174 		    length-=6;
175             if (length>=1 && *buffer>='1')
176 			{
177 				iarray = *buffer-'1';
178 				if(iarray >= MAX_VDEVICE_PER_VBUS) return -EINVAL;
179 
180 				pArray = _vbus_p->pVDevice[iarray];
181 				if (!pArray || (pArray->vf_online == 0)) return -EINVAL;
182 
183 				if(pArray->VDeviceType != VD_RAID_1 && pArray->VDeviceType != VD_RAID_5)
184 					return -EINVAL;
185 
186 				if (!(pArray->u.array.rf_need_rebuild ||
187 					pArray->u.array.rf_rebuilding ||
188 					pArray->u.array.rf_verifying ||
189 					pArray->u.array.rf_initializing))
190 				{
191 					oldspl = lock_driver();
192 					pArray->u.array.RebuildSectors = 0;
193 					hpt_queue_dpc((HPT_DPC)hpt_rebuild_data_block, pAdapter, pArray, VERIFY);
194 					unlock_driver(oldspl);
195 				}
196                 return orig_length;
197 			}
198 		}
199 		else if (length>=5 && strncmp(buffer, "stop ", 5)==0)
200 		{
201 			buffer+=5;
202 		    length-=5;
203             if (length>=1 && *buffer>='1')
204 			{
205 				iarray = *buffer-'1';
206 				if(iarray >= MAX_VDEVICE_PER_VBUS) return -EINVAL;
207 
208 				pArray = _vbus_p->pVDevice[iarray];
209 				if (!pArray || (pArray->vf_online == 0)) return -EINVAL;
210 				if(pArray->u.array.rf_verifying)
211 				{
212 					oldspl = lock_driver();
213 				    pArray->u.array.rf_abort_rebuild = 1;
214 				    unlock_driver(oldspl);
215 				}
216 			    return orig_length;
217 			}
218 		}
219 	}
220 	else
221 #ifdef _RAID5N_
222 	if (length>=10 && strncmp(buffer, "writeback ", 10)==0) {
223 	    	buffer+=10;
224 		length-=10;
225 		if (length>=1 && *buffer>='0' && *buffer<='1') {
226 			_vbus_(r5.enable_write_back) = *buffer-'0';
227 			if (_vbus_(r5.enable_write_back))
228 				hpt_printk(("RAID5 write back enabled"));
229 			return orig_length;
230 		}
231 	}
232 	else
233 #endif
234 #endif
235 	if (0) {} /* just to compile */
236 #ifdef DEBUG
237 	else if (length>=9 && strncmp(buffer, "dbglevel ", 9)==0) {
238 	    	buffer+=9;
239 		length-=9;
240 		if (length>=1 && *buffer>='0' && *buffer<='3') {
241 			hpt_dbg_level = *buffer-'0';
242 			return orig_length;
243 		}
244 	}
245 	else if (length>=8 && strncmp(buffer, "disable ", 8)==0) {
246 		/* TO DO */
247 	}
248 #endif
249 
250 	return -EINVAL;
251 }
252 
253 /*
254  * Since we have only one sysctl node, add adapter ID in the command
255  * line string: e.g. "hpt 0 rebuild start"
256  */
257 static int
258 hpt_set_info(int length)
259 {
260 	int retval;
261 
262 #ifdef SUPPORT_IOCTL
263 	PUCHAR ke_area;
264 	int err;
265 	DWORD dwRet;
266 	PHPT_IOCTL_PARAM piop;
267 #endif
268 	char *buffer = hptproc_buffer;
269 	if (length >= 6) {
270 		if (strncmp(buffer,"hpt ",4) == 0) {
271 			IAL_ADAPTER_T *pAdapter;
272 			retval = buffer[4]-'0';
273 			for (pAdapter=gIal_Adapter; pAdapter; pAdapter=pAdapter->next) {
274 				if (pAdapter->mvSataAdapter.adapterId==retval)
275 					return (retval = hpt_set_asc_info(pAdapter, buffer+6, length-6)) >= 0? retval : -EINVAL;
276 			}
277 			return -EINVAL;
278 		}
279 #ifdef SUPPORT_IOCTL
280 		piop = (PHPT_IOCTL_PARAM)buffer;
281 		if (piop->Magic == HPT_IOCTL_MAGIC) 	{
282 			KdPrintE(("ioctl=%d in=%p len=%d out=%p len=%d\n",
283 				piop->dwIoControlCode,
284         			piop->lpInBuffer,
285         			piop->nInBufferSize,
286         			piop->lpOutBuffer,
287 	        		piop->nOutBufferSize));
288 
289 			/*
290         	 	 * map buffer to kernel.
291         	 	 */
292         		if (piop->nInBufferSize+piop->nOutBufferSize > PAGE_SIZE) {
293         			KdPrintE(("User buffer too large\n"));
294         			return -EINVAL;
295         		}
296 
297         		ke_area = malloc(piop->nInBufferSize+piop->nOutBufferSize, M_DEVBUF, M_NOWAIT);
298 				if (ke_area == NULL) {
299 					KdPrintE(("Couldn't allocate kernel mem.\n"));
300 					return -EINVAL;
301 				}
302 
303 			if (piop->nInBufferSize)
304 				copyin((void*)(ULONG_PTR)piop->lpInBuffer, ke_area, piop->nInBufferSize);
305 
306 			/*
307 			  * call kernel handler.
308 			  */
309 			err = Kernel_DeviceIoControl(&gIal_Adapter->VBus,
310 				piop->dwIoControlCode, ke_area, piop->nInBufferSize,
311 				ke_area + piop->nInBufferSize, piop->nOutBufferSize, &dwRet);
312 
313 			if (err==0) {
314 				if (piop->nOutBufferSize)
315 					copyout(ke_area + piop->nInBufferSize, (void*)(ULONG_PTR)piop->lpOutBuffer, piop->nOutBufferSize);
316 
317 				if (piop->lpBytesReturned)
318 					copyout(&dwRet, (void*)(ULONG_PTR)piop->lpBytesReturned, sizeof(DWORD));
319 
320 				free(ke_area, M_DEVBUF);
321 				return length;
322 			}
323 			else  KdPrintW(("Kernel_ioctl(): return %d\n", err));
324 
325 			free(ke_area, M_DEVBUF);
326             		return -EINVAL;
327 		} else 	{
328     		KdPrintW(("Wrong signature: %x\n", piop->Magic));
329     		return -EINVAL;
330 		}
331 #endif
332 	}
333 
334 	return -EINVAL;
335 }
336 
337 #define shortswap(w) ((WORD)((w)>>8 | ((w) & 0xFF)<<8))
338 
339 static void
340 get_disk_name(char *name, PDevice pDev)
341 {
342 	int i;
343 	MV_SATA_CHANNEL *pMvSataChannel = pDev->mv;
344 	IDENTIFY_DATA2 *pIdentifyData = (IDENTIFY_DATA2 *)pMvSataChannel->identifyDevice;
345 
346 	for (i = 0; i < 10; i++)
347 		((WORD*)name)[i] = shortswap(pIdentifyData->ModelNumber[i]);
348 	name[20] = '\0';
349 }
350 
351 static int
352 hpt_copy_info(HPT_GET_INFO *pinfo, char *fmt, ...)
353 {
354 	int printfretval;
355 	va_list ap;
356 
357 	if(fmt == NULL) {
358 		*hptproc_buffer = 0;
359 		return (SYSCTL_OUT(pinfo, hptproc_buffer, 1));
360 	}
361 	else
362 	{
363 		va_start(ap, fmt);
364 		printfretval = vsnprintf(hptproc_buffer, sizeof(hptproc_buffer), fmt, ap);
365 		va_end(ap);
366 		return(SYSCTL_OUT(pinfo, hptproc_buffer, strlen(hptproc_buffer)));
367 	}
368 }
369 
370 static void
371 hpt_copy_disk_info(HPT_GET_INFO *pinfo, PVDevice pVDev, UINT iChan)
372 {
373 	char name[32], arrayname[16], *status;
374 
375 	get_disk_name(name, &pVDev->u.disk);
376 
377 	if (!pVDev->u.disk.df_on_line)
378 		status = "Disabled";
379 	else if (pVDev->VDeviceType==VD_SPARE)
380 		status = "Spare   ";
381 	else
382 		status = "Normal  ";
383 
384 #ifdef SUPPORT_ARRAY
385 	if(pVDev->pParent) {
386 		memcpy(arrayname, pVDev->pParent->u.array.ArrayName, MAX_ARRAY_NAME);
387 		if (pVDev->pParent->u.array.CriticalMembers & (1<<pVDev->bSerialNumber))
388 			status = "Degraded";
389 	}
390 	else
391 #endif
392 		arrayname[0]=0;
393 
394 	hpt_copy_info(pinfo, "Channel %d  %s  %5dMB  %s %s\n",
395 		iChan+1,
396 		name, pVDev->VDeviceCapacity>>11, status, arrayname);
397 }
398 
399 #ifdef SUPPORT_ARRAY
400 static void
401 hpt_copy_array_info(HPT_GET_INFO *pinfo, int nld, PVDevice pArray)
402 {
403 	int i;
404 	char *sType=0, *sStatus=0;
405 	char buf[32];
406     PVDevice pTmpArray;
407 
408 	switch (pArray->VDeviceType) {
409 		case VD_RAID_0:
410 			for (i = 0; (UCHAR)i < pArray->u.array.bArnMember; i++)
411 		  		if(pArray->u.array.pMember[i])	{
412 			  		if(mIsArray(pArray->u.array.pMember[i]))
413 				 		sType = "RAID 1/0   ";
414 			  			/* TO DO */
415 			  		else
416 				 		sType = "RAID 0     ";
417 			  		break;
418 		  		}
419 			break;
420 
421 		case VD_RAID_1:
422 			sType = "RAID 1     ";
423 			break;
424 
425 		case VD_JBOD:
426 			sType = "JBOD       ";
427 			break;
428 
429 		case VD_RAID_5:
430        		sType = "RAID 5     ";
431 			break;
432 
433 		default:
434 			sType = "N/A        ";
435 			break;
436 	}
437 
438 	if (pArray->vf_online == 0)
439 		sStatus = "Disabled";
440 	else if (pArray->u.array.rf_broken)
441 		sStatus = "Critical";
442 	for (i = 0; (UCHAR)i < pArray->u.array.bArnMember; i++)
443 	{
444 		if (!sStatus)
445 		{
446 			if(mIsArray(pArray->u.array.pMember[i]))
447                 		pTmpArray = pArray->u.array.pMember[i];
448 			else
449 			   	pTmpArray = pArray;
450 
451 			if (pTmpArray->u.array.rf_rebuilding) {
452 #ifdef DEBUG
453 				sprintf(buf, "Rebuilding %dMB", (pTmpArray->u.array.RebuildSectors>>11));
454 #else
455 				sprintf(buf, "Rebuilding %d%%", (pTmpArray->u.array.RebuildSectors>>11)*100/((pTmpArray->VDeviceCapacity/(pTmpArray->u.array.bArnMember-1))>>11));
456 #endif
457 				sStatus = buf;
458 			}
459 			else if (pTmpArray->u.array.rf_verifying) {
460 				sprintf(buf, "Verifying %d%%", (pTmpArray->u.array.RebuildSectors>>11)*100/((pTmpArray->VDeviceCapacity/(pTmpArray->u.array.bArnMember-1))>>11));
461 				sStatus = buf;
462 			}
463 			else if (pTmpArray->u.array.rf_need_rebuild)
464 				sStatus = "Critical";
465 			else if (pTmpArray->u.array.rf_broken)
466 				sStatus = "Critical";
467 
468 			if(pTmpArray == pArray) goto out;
469 		}
470 		else
471 			goto out;
472 	}
473 out:
474 	if (!sStatus) sStatus = "Normal";
475 	hpt_copy_info(pinfo, "%2d  %11s  %-20s  %5dMB  %-16s", nld, sType, pArray->u.array.ArrayName, pArray->VDeviceCapacity>>11, sStatus);
476 }
477 #endif
478 
479 static int
480 hpt_get_info(IAL_ADAPTER_T *pAdapter, HPT_GET_INFO *pinfo)
481 {
482 	PVBus _vbus_p = &pAdapter->VBus;
483 	struct cam_periph *periph = NULL;
484 	UINT channel,j,i;
485 	PVDevice pVDev;
486 
487 #ifndef FOR_DEMO
488 	if (pAdapter->beeping) {
489 		intrmask_t oldspl = lock_driver();
490 		pAdapter->beeping = 0;
491 		BeepOff(pAdapter->mvSataAdapter.adapterIoBaseAddress);
492 		unlock_driver(oldspl);
493 	}
494 #endif
495 
496 	hpt_copy_info(pinfo, "Controller #%d:\n\n", pAdapter->mvSataAdapter.adapterId);
497 
498 	hpt_copy_info(pinfo, "Physical device list\n");
499 	hpt_copy_info(pinfo, "Channel    Model                Capacity  Status   Array\n");
500 	hpt_copy_info(pinfo, "-------------------------------------------------------------------\n");
501 
502     for (channel = 0; channel < MV_SATA_CHANNELS_NUM; channel++)
503 	{
504 		pVDev = &(pAdapter->VDevices[channel]);
505 		if(pVDev->u.disk.df_on_line)
506 			 hpt_copy_disk_info(pinfo, pVDev, channel);
507 	}
508 
509 	hpt_copy_info(pinfo, "\nLogical device list\n");
510 	hpt_copy_info(pinfo, "No. Type         Name                 Capacity  Status            OsDisk\n");
511 	hpt_copy_info(pinfo, "--------------------------------------------------------------------------\n");
512 
513 	j=1;
514 	for(i = 0; i < MAX_VDEVICE_PER_VBUS; i++){
515         pVDev = _vbus_p->pVDevice[i];
516 		if(pVDev){
517 			j=i+1;
518 #ifdef SUPPORT_ARRAY
519 			if (mIsArray(pVDev))
520 			{
521 		is_array:
522 				hpt_copy_array_info(pinfo, j, pVDev);
523 			}
524 			else
525 #endif
526 			{
527 				char name[32];
528 				/* it may be add to an array after driver loaded, check it */
529 #ifdef SUPPORT_ARRAY
530 				if (pVDev->pParent)
531 					/* in this case, pVDev can only be a RAID 1 source disk. */
532 					if (pVDev->pParent->VDeviceType==VD_RAID_1 && pVDev==pVDev->pParent->u.array.pMember[0])
533 						goto is_array;
534 #endif
535 				get_disk_name(name, &pVDev->u.disk);
536 
537 				hpt_copy_info(pinfo, "%2d  %s  %s  %5dMB  %-16s",
538 					j, "Single disk", name, pVDev->VDeviceCapacity>>11,
539 					/* gmm 2001-6-19: Check if pDev has been added to an array. */
540 					((pVDev->pParent) ? "Unavailable" : "Normal"));
541 			}
542 			periph = hpt_get_periph(pAdapter->mvSataAdapter.adapterId, i);
543 			if (periph == NULL)
544 				hpt_copy_info(pinfo,"  %s\n","not registered");
545 			else
546 				hpt_copy_info(pinfo,"  %s%d\n", periph->periph_name, periph->unit_number);
547 		 }
548 	}
549 	return 0;
550 }
551 
552 static __inline int
553 hpt_proc_in(FORMAL_HANDLER_ARGS, int *len)
554 {
555 	int i, error=0;
556 
557 	*len = 0;
558 	if ((req->newlen - req->newidx) >= sizeof(hptproc_buffer)) {
559 		error = EINVAL;
560 	} else {
561 		i = (req->newlen - req->newidx);
562 		error = SYSCTL_IN(req, hptproc_buffer, i);
563 		if (!error)
564 			*len = i;
565 		(hptproc_buffer)[i] = '\0';
566 	}
567 	return (error);
568 }
569 
570 static int
571 hpt_status(FORMAL_HANDLER_ARGS)
572 {
573 	int length, error=0, retval=0;
574 	IAL_ADAPTER_T *pAdapter;
575 
576 	error = hpt_proc_in(REAL_HANDLER_ARGS, &length);
577 
578     if (req->newptr != NULL)
579 	{
580 		if (error || length == 0)
581 		{
582     		KdPrint(("error!\n"));
583     		retval = EINVAL;
584     		goto out;
585 		}
586 
587 		if (hpt_set_info(length) >= 0)
588 			retval = 0;
589 		else
590 			retval = EINVAL;
591 		goto out;
592     }
593 
594 	hpt_copy_info(req, "%s Version %s\n", DRIVER_NAME, DRIVER_VERSION);
595 	for (pAdapter=gIal_Adapter; pAdapter; pAdapter=pAdapter->next) {
596 		if (hpt_get_info(pAdapter, req) < 0) {
597 			retval = EINVAL;
598 			break;
599 		}
600 	}
601 
602 	hpt_copy_info(req, NULL);
603 	goto out;
604 
605 out:
606 	return (retval);
607 }
608 
609 
610 #define xhptregister_node(name) hptregister_node(name)
611 
612 #if (__FreeBSD_version < 500043)
613 #define hptregister_node(name) \
614 	SYSCTL_NODE(, OID_AUTO,	name, CTLFLAG_RW, 0, "Get/Set " #name " state root node") \
615 	SYSCTL_OID(_ ## name, OID_AUTO, status, CTLTYPE_STRING|CTLFLAG_RW, \
616 	NULL, 0, hpt_status, "A", "Get/Set " #name " state")
617 #else
618 #define hptregister_node(name) \
619 	SYSCTL_NODE(, OID_AUTO,	name, CTLFLAG_RW, 0, "Get/Set " #name " state root node"); \
620 	SYSCTL_OID(_ ## name, OID_AUTO, status, CTLTYPE_STRING|CTLFLAG_RW, \
621 	NULL, 0, hpt_status, "A", "Get/Set " #name " state");
622 #endif
623 
624 xhptregister_node(PROC_DIR_NAME);
625