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