Current Path : /sys/amd64/compile/hs32/modules/usr/src/sys/modules/iwnfw/iwn6000/@/dev/hptmv/ |
FreeBSD hs32.drive.ne.jp 9.1-RELEASE FreeBSD 9.1-RELEASE #1: Wed Jan 14 12:18:08 JST 2015 root@hs32.drive.ne.jp:/sys/amd64/compile/hs32 amd64 |
Current File : //sys/amd64/compile/hs32/modules/usr/src/sys/modules/iwnfw/iwn6000/@/dev/hptmv/ioctl.c |
/* * Copyright (c) 2004-2005 HighPoint Technologies, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD: release/9.1.0/sys/dev/hptmv/ioctl.c 190809 2009-04-07 16:38:25Z delphij $ */ /* * ioctl.c ioctl interface implementation */ #include <sys/param.h> #include <sys/systm.h> #include <sys/kernel.h> #include <sys/malloc.h> #if (__FreeBSD_version < 500000) #include <sys/proc.h> #include <sys/kthread.h> #include <sys/wait.h> #include <sys/sysproto.h> #endif #ifndef __KERNEL__ #define __KERNEL__ #endif #include <dev/hptmv/global.h> #include <dev/hptmv/hptintf.h> #include <dev/hptmv/osbsd.h> #include <dev/hptmv/access601.h> #pragma pack(1) typedef struct _HPT_REBUILD_PARAM { DEVICEID idMirror; DWORD Lba; UCHAR nSector; } HPT_REBUILD_PARAM, *PHPT_REBUILD_PARAM; #pragma pack() #define MAX_EVENTS 10 static HPT_EVENT hpt_event_queue[MAX_EVENTS]; static int event_queue_head=0, event_queue_tail=0; static int hpt_get_event(PHPT_EVENT pEvent); static int hpt_set_array_state(DEVICEID idArray, DWORD state); static intrmask_t lock_driver_idle(IAL_ADAPTER_T *pAdapter); static void HPTLIBAPI thread_io_done(_VBUS_ARG PCommand pCmd); static int HPTLIBAPI R1ControlSgl(_VBUS_ARG PCommand pCmd, FPSCAT_GATH pSgTable, int logical); static void get_disk_location(PDevice pDev, int *controller, int *channel) { IAL_ADAPTER_T *pAdapTemp; int i, j; *controller = *channel = 0; for (i=1, pAdapTemp = gIal_Adapter; pAdapTemp; pAdapTemp = pAdapTemp->next, i++) { for (j=0; j<MV_SATA_CHANNELS_NUM; j++) { if (pDev == &pAdapTemp->VDevices[j].u.disk) { *controller = i; *channel = j; return; } } } } static int event_queue_add(PHPT_EVENT pEvent) { int p; p = (event_queue_tail + 1) % MAX_EVENTS; if (p==event_queue_head) { return -1; } hpt_event_queue[event_queue_tail] = *pEvent; event_queue_tail = p; return 0; } static int event_queue_remove(PHPT_EVENT pEvent) { if (event_queue_head != event_queue_tail) { *pEvent = hpt_event_queue[event_queue_head]; event_queue_head++; event_queue_head %= MAX_EVENTS; return 0; } return -1; } void HPTLIBAPI ioctl_ReportEvent(UCHAR event, PVOID param) { HPT_EVENT e; ZeroMemory(&e, sizeof(e)); e.EventType = event; switch(event) { case ET_INITIALIZE_ABORTED: case ET_INITIALIZE_FAILED: memcpy(e.Data, ((PVDevice)param)->u.array.ArrayName, MAX_ARRAY_NAME); case ET_INITIALIZE_STARTED: case ET_INITIALIZE_FINISHED: case ET_REBUILD_STARTED: case ET_REBUILD_ABORTED: case ET_REBUILD_FAILED: case ET_REBUILD_FINISHED: case ET_VERIFY_STARTED: case ET_VERIFY_ABORTED: case ET_VERIFY_FAILED: case ET_VERIFY_FINISHED: case ET_VERIFY_DATA_ERROR: case ET_SPARE_TOOK_OVER: case ET_DEVICE_REMOVED: case ET_DEVICE_PLUGGED: case ET_DEVICE_ERROR: e.DeviceID = VDEV_TO_ID((PVDevice)param); break; default: break; } event_queue_add(&e); if (event==ET_DEVICE_REMOVED) { int controller, channel; get_disk_location(&((PVDevice)param)->u.disk, &controller, &channel); hpt_printk(("Device removed: controller %d channel %d\n", controller, channel)); } } static int hpt_delete_array(_VBUS_ARG DEVICEID id, DWORD options) { PVDevice pArray = ID_TO_VDEV(id); BOOLEAN del_block0 = (options & DAF_KEEP_DATA_IF_POSSIBLE)?0:1; int i; PVDevice pa; if ((id==0) || check_VDevice_valid(pArray)) return -1; if(!mIsArray(pArray)) return -1; if (pArray->u.array.rf_rebuilding || pArray->u.array.rf_verifying || pArray->u.array.rf_initializing) return -1; for(i=0; i<pArray->u.array.bArnMember; i++) { pa = pArray->u.array.pMember[i]; if (pa && mIsArray(pa)) { if (pa->u.array.rf_rebuilding || pa->u.array.rf_verifying || pa->u.array.rf_initializing) return -1; } } if (pArray->pVBus!=_vbus_p) { HPT_ASSERT(0); return -1;} fDeleteArray(_VBUS_P pArray, del_block0); return 0; } /* just to prevent driver from sending more commands */ static void HPTLIBAPI nothing(_VBUS_ARG void *notused){} intrmask_t lock_driver_idle(IAL_ADAPTER_T *pAdapter) { intrmask_t oldspl; _VBUS_INST(&pAdapter->VBus) oldspl = lock_driver(); while (pAdapter->outstandingCommands) { KdPrint(("outstandingCommands is %d, wait..\n", pAdapter->outstandingCommands)); if (!mWaitingForIdle(_VBUS_P0)) CallWhenIdle(_VBUS_P nothing, 0); unlock_driver(oldspl); /*Schedule out*/ #if (__FreeBSD_version < 500000) YIELD_THREAD; #else #if (__FreeBSD_version > 700033) pause("switch", 1); #else tsleep(lock_driver_idle, PPAUSE, "switch", 1); #endif #endif oldspl = lock_driver(); } CheckIdleCall(_VBUS_P0); return oldspl; } int Kernel_DeviceIoControl(_VBUS_ARG DWORD dwIoControlCode, /* operation control code */ PVOID lpInBuffer, /* input data buffer */ DWORD nInBufferSize, /* size of input data buffer */ PVOID lpOutBuffer, /* output data buffer */ DWORD nOutBufferSize, /* size of output data buffer */ PDWORD lpBytesReturned /* byte count */ ) { IAL_ADAPTER_T *pAdapter; switch(dwIoControlCode) { case HPT_IOCTL_DELETE_ARRAY: { DEVICEID idArray; int iSuccess; int i; PVDevice pArray; PVBus _vbus_p; struct cam_periph *periph = NULL; if (nInBufferSize!=sizeof(DEVICEID)+sizeof(DWORD)) return -1; if (nOutBufferSize!=sizeof(int)) return -1; idArray = *(DEVICEID *)lpInBuffer; pArray = ID_TO_VDEV(idArray); if((idArray == 0) || check_VDevice_valid(pArray)) return -1; if(!mIsArray(pArray)) return -1; _vbus_p=pArray->pVBus; pAdapter = (IAL_ADAPTER_T *)_vbus_p->OsExt; for(i = 0; i < MAX_VDEVICE_PER_VBUS; i++) { if(pArray == _vbus_p->pVDevice[i]) { periph = hpt_get_periph(pAdapter->mvSataAdapter.adapterId, i); if (periph != NULL && periph->refcount >= 1) { hpt_printk(("Can not delete a mounted device.\n")); return -1; } } /* the Mounted Disk isn't delete */ } iSuccess = hpt_delete_array(_VBUS_P idArray, *(DWORD*)((DEVICEID *)lpInBuffer+1)); *(int*)lpOutBuffer = iSuccess; if(iSuccess != 0) return -1; break; } case HPT_IOCTL_GET_EVENT: { PHPT_EVENT pInfo; if (nInBufferSize!=0) return -1; if (nOutBufferSize!=sizeof(HPT_EVENT)) return -1; pInfo = (PHPT_EVENT)lpOutBuffer; if (hpt_get_event(pInfo)!=0) return -1; } break; case HPT_IOCTL_SET_ARRAY_STATE: { DEVICEID idArray; DWORD state; if (nInBufferSize!=sizeof(HPT_SET_STATE_PARAM)) return -1; if (nOutBufferSize!=0) return -1; idArray = ((PHPT_SET_STATE_PARAM)lpInBuffer)->idArray; state = ((PHPT_SET_STATE_PARAM)lpInBuffer)->state; if(hpt_set_array_state(idArray, state)!=0) return -1; } break; case HPT_IOCTL_RESCAN_DEVICES: { if (nInBufferSize!=0) return -1; if (nOutBufferSize!=0) return -1; #ifndef FOR_DEMO /* stop buzzer if user perform rescan */ for (pAdapter=gIal_Adapter; pAdapter; pAdapter=pAdapter->next) { if (pAdapter->beeping) { pAdapter->beeping = 0; BeepOff(pAdapter->mvSataAdapter.adapterIoBaseAddress); } } #endif } break; default: { PVDevice pVDev; #ifdef SUPPORT_ARRAY intrmask_t oldspl; #endif switch(dwIoControlCode) { /* read-only ioctl functions can be called directly. */ case HPT_IOCTL_GET_VERSION: case HPT_IOCTL_GET_CONTROLLER_IDS: case HPT_IOCTL_GET_CONTROLLER_COUNT: case HPT_IOCTL_GET_CONTROLLER_INFO: case HPT_IOCTL_GET_CHANNEL_INFO: case HPT_IOCTL_GET_LOGICAL_DEVICES: case HPT_IOCTL_GET_DEVICE_INFO: case HPT_IOCTL_GET_DEVICE_INFO_V2: case HPT_IOCTL_GET_EVENT: case HPT_IOCTL_GET_DRIVER_CAPABILITIES: if(hpt_default_ioctl(_VBUS_P dwIoControlCode, lpInBuffer, nInBufferSize, lpOutBuffer, nOutBufferSize, lpBytesReturned) == -1) return -1; break; default: /* * GUI always use /proc/scsi/hptmv/0, so the _vbus_p param will be * wrong for second controller. */ switch(dwIoControlCode) { case HPT_IOCTL_CREATE_ARRAY: pVDev = ID_TO_VDEV(((PCREATE_ARRAY_PARAMS)lpInBuffer)->Members[0]); break; case HPT_IOCTL_CREATE_ARRAY_V2: pVDev = ID_TO_VDEV(((PCREATE_ARRAY_PARAMS_V2)lpInBuffer)->Members[0]); break; case HPT_IOCTL_SET_ARRAY_INFO: pVDev = ID_TO_VDEV(((PHPT_SET_ARRAY_INFO)lpInBuffer)->idArray); break; case HPT_IOCTL_SET_DEVICE_INFO: pVDev = ID_TO_VDEV(((PHPT_SET_DEVICE_INFO)lpInBuffer)->idDisk); break; case HPT_IOCTL_SET_DEVICE_INFO_V2: pVDev = ID_TO_VDEV(((PHPT_SET_DEVICE_INFO_V2)lpInBuffer)->idDisk); break; case HPT_IOCTL_SET_BOOT_MARK: case HPT_IOCTL_ADD_SPARE_DISK: case HPT_IOCTL_REMOVE_SPARE_DISK: pVDev = ID_TO_VDEV(*(DEVICEID *)lpInBuffer); break; case HPT_IOCTL_ADD_DISK_TO_ARRAY: pVDev = ID_TO_VDEV(((PHPT_ADD_DISK_TO_ARRAY)lpInBuffer)->idArray); break; default: pVDev = 0; } if (pVDev && !check_VDevice_valid(pVDev)){ _vbus_p = pVDev->pVBus; pAdapter = (IAL_ADAPTER_T *)_vbus_p->OsExt; /* * create_array, and other functions can't be executed while channel is * perform I/O commands. Wait until driver is idle. */ oldspl = lock_driver_idle(pAdapter); if (hpt_default_ioctl(_VBUS_P dwIoControlCode, lpInBuffer, nInBufferSize, lpOutBuffer, nOutBufferSize, lpBytesReturned) == -1) { unlock_driver(oldspl); return -1; } unlock_driver(oldspl); } else return -1; break; } #ifdef SUPPORT_ARRAY switch(dwIoControlCode) { case HPT_IOCTL_CREATE_ARRAY: { pAdapter=(IAL_ADAPTER_T *)(ID_TO_VDEV(*(DEVICEID *)lpOutBuffer))->pVBus->OsExt; oldspl = lock_driver(); if(((PCREATE_ARRAY_PARAMS)lpInBuffer)->CreateFlags & CAF_CREATE_AND_DUPLICATE) { (ID_TO_VDEV(*(DEVICEID *)lpOutBuffer))->u.array.rf_auto_rebuild = 0; hpt_queue_dpc((HPT_DPC)hpt_rebuild_data_block, pAdapter, ID_TO_VDEV(*(DEVICEID *)lpOutBuffer), DUPLICATE); } else if(((PCREATE_ARRAY_PARAMS)lpInBuffer)->CreateFlags & CAF_CREATE_R5_ZERO_INIT) { hpt_queue_dpc((HPT_DPC)hpt_rebuild_data_block, pAdapter, ID_TO_VDEV(*(DEVICEID *)lpOutBuffer), INITIALIZE); } else if(((PCREATE_ARRAY_PARAMS)lpInBuffer)->CreateFlags & CAF_CREATE_R5_BUILD_PARITY) { hpt_queue_dpc((HPT_DPC)hpt_rebuild_data_block, pAdapter, ID_TO_VDEV(*(DEVICEID *)lpOutBuffer), REBUILD_PARITY); } unlock_driver(oldspl); break; } case HPT_IOCTL_CREATE_ARRAY_V2: { pAdapter=(IAL_ADAPTER_T *)(ID_TO_VDEV(*(DEVICEID *)lpOutBuffer))->pVBus->OsExt; oldspl = lock_driver(); if(((PCREATE_ARRAY_PARAMS_V2)lpInBuffer)->CreateFlags & CAF_CREATE_AND_DUPLICATE) { (ID_TO_VDEV(*(DEVICEID *)lpOutBuffer))->u.array.rf_auto_rebuild = 0; hpt_queue_dpc((HPT_DPC)hpt_rebuild_data_block, pAdapter, ID_TO_VDEV(*(DEVICEID *)lpOutBuffer), DUPLICATE); } else if(((PCREATE_ARRAY_PARAMS_V2)lpInBuffer)->CreateFlags & CAF_CREATE_R5_ZERO_INIT) { hpt_queue_dpc((HPT_DPC)hpt_rebuild_data_block, pAdapter, ID_TO_VDEV(*(DEVICEID *)lpOutBuffer), INITIALIZE); } else if(((PCREATE_ARRAY_PARAMS_V2)lpInBuffer)->CreateFlags & CAF_CREATE_R5_BUILD_PARITY) { hpt_queue_dpc((HPT_DPC)hpt_rebuild_data_block, pAdapter, ID_TO_VDEV(*(DEVICEID *)lpOutBuffer), REBUILD_PARITY); } unlock_driver(oldspl); break; } case HPT_IOCTL_ADD_DISK_TO_ARRAY: { PVDevice pArray = ID_TO_VDEV(((PHPT_ADD_DISK_TO_ARRAY)lpInBuffer)->idArray); pAdapter=(IAL_ADAPTER_T *)pArray->pVBus->OsExt; if(pArray->u.array.rf_rebuilding == 0) { DWORD timeout = 0; oldspl = lock_driver(); pArray->u.array.rf_auto_rebuild = 0; pArray->u.array.rf_abort_rebuild = 0; hpt_queue_dpc((HPT_DPC)hpt_rebuild_data_block, pAdapter, pArray, DUPLICATE); unlock_driver(oldspl); while (!pArray->u.array.rf_rebuilding) { #if (__FreeBSD_version > 700033) pause("pause", 1); #else tsleep((caddr_t)Kernel_DeviceIoControl, PPAUSE, "pause", 1); #endif if ( timeout >= hz*3) break; timeout ++; } } break; } } #endif return 0; } } if (lpBytesReturned) *lpBytesReturned = nOutBufferSize; return 0; } static int hpt_get_event(PHPT_EVENT pEvent) { intrmask_t oldspl = lock_driver(); int ret = event_queue_remove(pEvent); unlock_driver(oldspl); return ret; } static int hpt_set_array_state(DEVICEID idArray, DWORD state) { IAL_ADAPTER_T *pAdapter; PVDevice pVDevice = ID_TO_VDEV(idArray); int i; DWORD timeout = 0; intrmask_t oldspl; if(idArray == 0 || check_VDevice_valid(pVDevice)) return -1; if(!mIsArray(pVDevice)) return -1; if(!pVDevice->vf_online || pVDevice->u.array.rf_broken) return -1; pAdapter=(IAL_ADAPTER_T *)pVDevice->pVBus->OsExt; switch(state) { case MIRROR_REBUILD_START: { if (pVDevice->u.array.rf_rebuilding || pVDevice->u.array.rf_verifying || pVDevice->u.array.rf_initializing) return -1; oldspl = lock_driver(); pVDevice->u.array.rf_auto_rebuild = 0; pVDevice->u.array.rf_abort_rebuild = 0; hpt_queue_dpc((HPT_DPC)hpt_rebuild_data_block, pAdapter, pVDevice, (UCHAR)((pVDevice->u.array.CriticalMembers || pVDevice->VDeviceType == VD_RAID_1)? DUPLICATE : REBUILD_PARITY)); unlock_driver(oldspl); while (!pVDevice->u.array.rf_rebuilding) { #if (__FreeBSD_version > 700033) pause("pause", 1); #else tsleep((caddr_t)hpt_set_array_state, PPAUSE, "pause", 1); #endif if ( timeout >= hz*20) break; timeout ++; } } break; case MIRROR_REBUILD_ABORT: { for(i = 0; i < pVDevice->u.array.bArnMember; i++) { if(pVDevice->u.array.pMember[i] != 0 && pVDevice->u.array.pMember[i]->VDeviceType == VD_RAID_1) hpt_set_array_state(VDEV_TO_ID(pVDevice->u.array.pMember[i]), state); } if(pVDevice->u.array.rf_rebuilding != 1) return -1; oldspl = lock_driver(); pVDevice->u.array.rf_abort_rebuild = 1; unlock_driver(oldspl); while (pVDevice->u.array.rf_abort_rebuild) { #if (__FreeBSD_version > 700033) pause("pause", 1); #else tsleep((caddr_t)hpt_set_array_state, PPAUSE, "pause", 1); #endif if ( timeout >= hz*20) break; timeout ++; } } break; case AS_VERIFY_START: { /*if(pVDevice->u.array.rf_verifying) return -1;*/ if (pVDevice->u.array.rf_rebuilding || pVDevice->u.array.rf_verifying || pVDevice->u.array.rf_initializing) return -1; oldspl = lock_driver(); pVDevice->u.array.RebuildSectors = 0; hpt_queue_dpc((HPT_DPC)hpt_rebuild_data_block, pAdapter, pVDevice, VERIFY); unlock_driver(oldspl); while (!pVDevice->u.array.rf_verifying) { #if (__FreeBSD_version > 700033) pause("pause", 1); #else tsleep((caddr_t)hpt_set_array_state, PPAUSE, "pause", 1); #endif if ( timeout >= hz*20) break; timeout ++; } } break; case AS_VERIFY_ABORT: { if(pVDevice->u.array.rf_verifying != 1) return -1; oldspl = lock_driver(); pVDevice->u.array.rf_abort_rebuild = 1; unlock_driver(oldspl); while (pVDevice->u.array.rf_abort_rebuild) { #if (__FreeBSD_version > 700033) pause("pause", 1); #else tsleep((caddr_t)hpt_set_array_state, PPAUSE, "pause", 1); #endif if ( timeout >= hz*80) break; timeout ++; } } break; case AS_INITIALIZE_START: { if (pVDevice->u.array.rf_rebuilding || pVDevice->u.array.rf_verifying || pVDevice->u.array.rf_initializing) return -1; oldspl = lock_driver(); hpt_queue_dpc((HPT_DPC)hpt_rebuild_data_block, pAdapter, pVDevice, VERIFY); unlock_driver(oldspl); while (!pVDevice->u.array.rf_initializing) { #if (__FreeBSD_version > 700033) pause("pause", 1); #else tsleep((caddr_t)hpt_set_array_state, PPAUSE, "pause", 1); #endif if ( timeout >= hz*80) break; timeout ++; } } break; case AS_INITIALIZE_ABORT: { if(pVDevice->u.array.rf_initializing != 1) return -1; oldspl = lock_driver(); pVDevice->u.array.rf_abort_rebuild = 1; unlock_driver(oldspl); while (pVDevice->u.array.rf_abort_rebuild) { #if (__FreeBSD_version > 700033) pause("pause", 1); #else tsleep((caddr_t)hpt_set_array_state, PPAUSE, "pause", 1); #endif if ( timeout >= hz*80) break; timeout ++; } } break; default: return -1; } return 0; } int HPTLIBAPI R1ControlSgl(_VBUS_ARG PCommand pCmd, FPSCAT_GATH pSgTable, int logical) { ULONG bufferSize = SECTOR_TO_BYTE(pCmd->uCmd.R1Control.nSectors); if (pCmd->uCmd.R1Control.Command==CTRL_CMD_VERIFY) bufferSize<<=1; if (logical) { pSgTable->dSgAddress = (ULONG_PTR)pCmd->uCmd.R1Control.Buffer; pSgTable->wSgSize = (USHORT)bufferSize; pSgTable->wSgFlag = SG_FLAG_EOT; } else { /* build physical SG table for pCmd->uCmd.R1Control.Buffer */ ADDRESS dataPointer, v, nextpage, currvaddr, nextvaddr, currphypage, nextphypage; ULONG length; int idx = 0; v = pCmd->uCmd.R1Control.Buffer; dataPointer = (ADDRESS)fOsPhysicalAddress(v); if ((ULONG_PTR)dataPointer & 0x1) return FALSE; #define ON64KBOUNDARY(x) (((ULONG_PTR)(x) & 0xFFFF) == 0) #define NOTNEIGHBORPAGE(highvaddr, lowvaddr) ((ULONG_PTR)(highvaddr) - (ULONG_PTR)(lowvaddr) != PAGE_SIZE) do { if (idx >= MAX_SG_DESCRIPTORS) return FALSE; pSgTable[idx].dSgAddress = fOsPhysicalAddress(v); currvaddr = v; currphypage = (ADDRESS)fOsPhysicalAddress((void*)trunc_page((ULONG_PTR)currvaddr)); do { nextpage = (ADDRESS)trunc_page(((ULONG_PTR)currvaddr + PAGE_SIZE)); nextvaddr = (ADDRESS)MIN(((ULONG_PTR)v + bufferSize), (ULONG_PTR)(nextpage)); if (nextvaddr == (ADDRESS)((ULONG_PTR)v + bufferSize)) break; nextphypage = (ADDRESS)fOsPhysicalAddress(nextpage); if (NOTNEIGHBORPAGE(nextphypage, currphypage) || ON64KBOUNDARY(nextphypage)) { nextvaddr = nextpage; break; } currvaddr = nextvaddr; currphypage = nextphypage; }while (1); length = (ULONG_PTR)nextvaddr - (ULONG_PTR)v; v = nextvaddr; bufferSize -= length; pSgTable[idx].wSgSize = (USHORT)length; pSgTable[idx].wSgFlag = (bufferSize)? 0 : SG_FLAG_EOT; idx++; }while (bufferSize); } return 1; } static int End_Job=0; void HPTLIBAPI thread_io_done(_VBUS_ARG PCommand pCmd) { End_Job = 1; wakeup((caddr_t)pCmd); } void hpt_rebuild_data_block(IAL_ADAPTER_T *pAdapter, PVDevice pArray, UCHAR flags) { DWORD timeout = 0; ULONG capacity = pArray->VDeviceCapacity / (pArray->u.array.bArnMember-1); PCommand pCmd; UINT result; int needsync=0, retry=0, needdelete=0; void *buffer = 0; intrmask_t oldspl; _VBUS_INST(&pAdapter->VBus) if (pArray->u.array.rf_broken==1 || pArray->u.array.RebuildSectors>=capacity) return; oldspl = lock_driver(); switch(flags) { case DUPLICATE: case REBUILD_PARITY: if(pArray->u.array.rf_rebuilding == 0) { pArray->u.array.rf_rebuilding = 1; hpt_printk(("Rebuilding started.\n")); ioctl_ReportEvent(ET_REBUILD_STARTED, pArray); } break; case INITIALIZE: if(pArray->u.array.rf_initializing == 0) { pArray->u.array.rf_initializing = 1; hpt_printk(("Initializing started.\n")); ioctl_ReportEvent(ET_INITIALIZE_STARTED, pArray); } break; case VERIFY: if(pArray->u.array.rf_verifying == 0) { pArray->u.array.rf_verifying = 1; hpt_printk(("Verifying started.\n")); ioctl_ReportEvent(ET_VERIFY_STARTED, pArray); } break; } retry_cmd: pCmd = AllocateCommand(_VBUS_P0); HPT_ASSERT(pCmd); pCmd->cf_control = 1; End_Job = 0; if (pArray->VDeviceType==VD_RAID_1) { #define MAX_REBUILD_SECTORS 0x40 /* take care for discontinuous buffer in R1ControlSgl */ unlock_driver(oldspl); buffer = malloc(SECTOR_TO_BYTE(MAX_REBUILD_SECTORS), M_DEVBUF, M_NOWAIT); oldspl = lock_driver(); if(!buffer) { FreeCommand(_VBUS_P pCmd); hpt_printk(("can't allocate rebuild buffer\n")); goto fail; } switch(flags) { case DUPLICATE: pCmd->uCmd.R1Control.Command = CTRL_CMD_REBUILD; pCmd->uCmd.R1Control.nSectors = MAX_REBUILD_SECTORS; break; case VERIFY: pCmd->uCmd.R1Control.Command = CTRL_CMD_VERIFY; pCmd->uCmd.R1Control.nSectors = MAX_REBUILD_SECTORS/2; break; case INITIALIZE: pCmd->uCmd.R1Control.Command = CTRL_CMD_REBUILD; pCmd->uCmd.R1Control.nSectors = MAX_REBUILD_SECTORS; break; } pCmd->uCmd.R1Control.Lba = pArray->u.array.RebuildSectors; if (capacity - pArray->u.array.RebuildSectors < pCmd->uCmd.R1Control.nSectors) pCmd->uCmd.R1Control.nSectors = capacity - pArray->u.array.RebuildSectors; pCmd->uCmd.R1Control.Buffer = buffer; pCmd->pfnBuildSgl = R1ControlSgl; } else if (pArray->VDeviceType==VD_RAID_5) { switch(flags) { case DUPLICATE: case REBUILD_PARITY: pCmd->uCmd.R5Control.Command = CTRL_CMD_REBUILD; break; case VERIFY: pCmd->uCmd.R5Control.Command = CTRL_CMD_VERIFY; break; case INITIALIZE: pCmd->uCmd.R5Control.Command = CTRL_CMD_INIT; break; } pCmd->uCmd.R5Control.StripeLine=pArray->u.array.RebuildSectors>>pArray->u.array.bArBlockSizeShift; } else HPT_ASSERT(0); pCmd->pVDevice = pArray; pCmd->pfnCompletion = thread_io_done; pArray->pfnSendCommand(_VBUS_P pCmd); CheckPendingCall(_VBUS_P0); if (!End_Job) { unlock_driver(oldspl); while (!End_Job) { tsleep((caddr_t)pCmd, PPAUSE, "pause", hz); if (timeout++>60) break; } oldspl = lock_driver(); if (!End_Job) { hpt_printk(("timeout, reset\n")); fResetVBus(_VBUS_P0); } } result = pCmd->Result; FreeCommand(_VBUS_P pCmd); unlock_driver(oldspl); if (buffer) free(buffer, M_DEVBUF); oldspl = lock_driver(); KdPrintI(("cmd finished %d", result)); switch(result) { case RETURN_SUCCESS: if (!pArray->u.array.rf_abort_rebuild) { if(pArray->u.array.RebuildSectors < capacity) { hpt_queue_dpc((HPT_DPC)hpt_rebuild_data_block, pAdapter, pArray, flags); } else { switch (flags) { case DUPLICATE: case REBUILD_PARITY: needsync = 1; pArray->u.array.rf_rebuilding = 0; pArray->u.array.rf_need_rebuild = 0; pArray->u.array.CriticalMembers = 0; pArray->u.array.RebuildSectors = MAX_LBA_T; pArray->u.array.rf_duplicate_and_create = 0; hpt_printk(("Rebuilding finished.\n")); ioctl_ReportEvent(ET_REBUILD_FINISHED, pArray); break; case INITIALIZE: needsync = 1; pArray->u.array.rf_initializing = 0; pArray->u.array.rf_need_rebuild = 0; pArray->u.array.RebuildSectors = MAX_LBA_T; hpt_printk(("Initializing finished.\n")); ioctl_ReportEvent(ET_INITIALIZE_FINISHED, pArray); break; case VERIFY: pArray->u.array.rf_verifying = 0; hpt_printk(("Verifying finished.\n")); ioctl_ReportEvent(ET_VERIFY_FINISHED, pArray); break; } } } else { pArray->u.array.rf_abort_rebuild = 0; if (pArray->u.array.rf_rebuilding) { hpt_printk(("Abort rebuilding.\n")); pArray->u.array.rf_rebuilding = 0; pArray->u.array.rf_duplicate_and_create = 0; ioctl_ReportEvent(ET_REBUILD_ABORTED, pArray); } else if (pArray->u.array.rf_verifying) { hpt_printk(("Abort verifying.\n")); pArray->u.array.rf_verifying = 0; ioctl_ReportEvent(ET_VERIFY_ABORTED, pArray); } else if (pArray->u.array.rf_initializing) { hpt_printk(("Abort initializing.\n")); pArray->u.array.rf_initializing = 0; ioctl_ReportEvent(ET_INITIALIZE_ABORTED, pArray); } needdelete=1; } break; case RETURN_DATA_ERROR: if (flags==VERIFY) { needsync = 1; pArray->u.array.rf_verifying = 0; pArray->u.array.rf_need_rebuild = 1; hpt_printk(("Verifying failed: found inconsistency\n")); ioctl_ReportEvent(ET_VERIFY_DATA_ERROR, pArray); ioctl_ReportEvent(ET_VERIFY_FAILED, pArray); if (!pArray->vf_online || pArray->u.array.rf_broken) break; pArray->u.array.rf_auto_rebuild = 0; pArray->u.array.rf_abort_rebuild = 0; hpt_queue_dpc((HPT_DPC)hpt_rebuild_data_block, pAdapter, pArray, (pArray->VDeviceType == VD_RAID_1) ? DUPLICATE : REBUILD_PARITY); } break; default: hpt_printk(("command failed with error %d\n", result)); if (++retry<3) { hpt_printk(("retry (%d)\n", retry)); goto retry_cmd; } fail: pArray->u.array.rf_abort_rebuild = 0; switch (flags) { case DUPLICATE: case REBUILD_PARITY: needsync = 1; pArray->u.array.rf_rebuilding = 0; pArray->u.array.rf_duplicate_and_create = 0; hpt_printk(((flags==DUPLICATE)? "Duplicating failed.\n":"Rebuilding failed.\n")); ioctl_ReportEvent(ET_REBUILD_FAILED, pArray); break; case INITIALIZE: needsync = 1; pArray->u.array.rf_initializing = 0; hpt_printk(("Initializing failed.\n")); ioctl_ReportEvent(ET_INITIALIZE_FAILED, pArray); break; case VERIFY: needsync = 1; pArray->u.array.rf_verifying = 0; hpt_printk(("Verifying failed.\n")); ioctl_ReportEvent(ET_VERIFY_FAILED, pArray); break; } needdelete=1; } while (pAdapter->outstandingCommands) { KdPrintI(("currcmds is %d, wait..\n", pAdapter->outstandingCommands)); /* put this to have driver stop processing system commands quickly */ if (!mWaitingForIdle(_VBUS_P0)) CallWhenIdle(_VBUS_P nothing, 0); unlock_driver(oldspl); /*Schedule out*/ #if (__FreeBSD_version < 500000) YIELD_THREAD; #else #if (__FreeBSD_version > 700033) pause("switch", 1); #else tsleep(hpt_rebuild_data_block, PPAUSE, "switch", 1); #endif #endif oldspl = lock_driver(); } if (needsync) SyncArrayInfo(pArray); if(needdelete && (pArray->u.array.rf_duplicate_must_done || (flags == INITIALIZE))) fDeleteArray(_VBUS_P pArray, TRUE); Check_Idle_Call(pAdapter); unlock_driver(oldspl); }