db06b514fe765c476f3eccc3355a8f7ce47df482
[openafs.git] / src / butc / tcstatus.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  *
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 #include <afsconfig.h>
11 #include <afs/param.h>
12
13 #include <roken.h>
14
15 #include <afs/com_err.h>
16 #include <lock.h>
17 #include <afs/bubasics.h>
18 #include <afs/tcdata.h>
19 #include <afs/butc.h>
20 #include <afs/budb_client.h>
21 #include <afs/bucoord_prototypes.h>
22
23 #include "butc_internal.h"
24 #include "error_macros.h"
25 #include "butc_xbsa.h"
26
27 /* tape coordinator - task status management */
28 extern afs_int32 xbsaType;
29
30 dlqlinkT statusHead;
31 struct Lock statusQueueLock;
32 struct Lock cmdLineLock;
33
34 /* STC_GetStatus
35  *      get the status of a task
36  * entry:
37  *      taskId - task for which status required
38  * exit:
39  *      statusPtr - filled in with task status
40  */
41
42 afs_int32
43 STC_GetStatus(struct rx_call *call, afs_uint32 taskId,
44               struct tciStatusS *statusPtr)
45 {
46     statusP ptr;
47     int retval = 0;
48
49     memset(statusPtr, 0, sizeof(*statusPtr));
50     if (callPermitted(call) == 0)
51         return (TC_NOTPERMITTED);
52
53     lock_Status();
54     ptr = findStatus(taskId);
55     if (ptr) {
56         strcpy(statusPtr->taskName, ptr->taskName);
57         strcpy(statusPtr->volumeName, ptr->volumeName);
58         statusPtr->taskId = ptr->taskId;
59         statusPtr->flags = ptr->flags;
60         statusPtr->nKBytes = ptr->nKBytes;
61         statusPtr->dbDumpId = ptr->dbDumpId;
62         statusPtr->lastPolled = ptr->lastPolled;
63         statusPtr->volsFailed = ptr->volsFailed;
64         ptr->lastPolled = time(0);
65     } else
66         retval = TC_NODENOTFOUND;
67     unlock_Status();
68
69     return (retval);
70 }
71
72 afs_int32
73 STC_EndStatus(struct rx_call *call, afs_uint32 taskId)
74 {
75     statusP ptr;
76     int retval = 0;
77
78     if (callPermitted(call) == 0)
79         return (TC_NOTPERMITTED);
80
81     lock_Status();
82     ptr = findStatus(taskId);
83     unlock_Status();
84
85     if (ptr)
86         deleteStatusNode(ptr);
87     else
88         retval = TC_NODENOTFOUND;
89
90     return (retval);
91 }
92
93 afs_int32
94 STC_RequestAbort(struct rx_call *call, afs_uint32 taskId)
95 {
96     statusP ptr;
97     int retval = 0;
98
99     if (callPermitted(call) == 0)
100         return (TC_NOTPERMITTED);
101
102     lock_Status();
103     ptr = findStatus(taskId);
104     if (ptr)
105         ptr->flags |= ABORT_REQUEST;
106     else
107         retval = TC_NODENOTFOUND;
108     unlock_Status();
109     return (retval);
110 }
111
112 /* STC_ScanStatus
113  *      Get status of all tasks on the butc, successively. Initial call
114  *      should come in with TSK_STAT_FIRST flag set to initialize the
115  *      scan.
116  * entry:
117  *      taskId - specifies the task whose status is to be returned
118  *              (unless TSK_STAT_FIRST set in which case it is ignored)
119  * exit:
120  *      taskId - id of next task in the list
121  *      flags - TSK_STAT_END will be set when one reaches the end of
122  *              the task list. taskId is not updated in this case.
123  * return values:
124  *      0 - normal
125  *      TC_NOTASKS - no tasks active
126  */
127
128 afs_int32
129 STC_ScanStatus(struct rx_call *call, afs_uint32 *taskId,
130                struct tciStatusS *statusPtr, afs_uint32 *flags)
131 {
132     statusP ptr = 0;
133     dlqlinkP dlqPtr;
134
135     memset(statusPtr, 0, sizeof(*statusPtr));
136     if (callPermitted(call) == 0)
137         return (TC_NOTPERMITTED);
138
139     lock_Status();
140
141     if (CONF_XBSA)
142         *flags |= TSK_STAT_XBSA;
143     if (xbsaType == XBSA_SERVER_TYPE_ADSM)
144         *flags |= TSK_STAT_ADSM;
145
146     if (*flags & TSK_STAT_FIRST) {
147         /* find first status node */
148         dlqPtr = statusHead.dlq_next;
149         if (dlqPtr == &statusHead) {
150             /* no status nodes */
151             *flags |= (TSK_STAT_NOTFOUND | TSK_STAT_END);
152             unlock_Status();
153             return (0);
154         }
155         ptr = (statusP) dlqPtr;
156     } else {
157         ptr = findStatus(*taskId);
158         if (ptr == 0) {
159             /* in the event that the set of tasks has changed, just
160              * finish, letting the caller retry
161              */
162
163             *flags |= (TSK_STAT_NOTFOUND | TSK_STAT_END);
164             unlock_Status();
165             return (0);
166         }
167     }
168
169     /* ptr is now set to the status node we wish to return. Determine
170      * what the next node will be
171      */
172
173     if (ptr->link.dlq_next == &statusHead)
174         *flags |= TSK_STAT_END;
175     else
176         *taskId = ((statusP) ptr->link.dlq_next)->taskId;
177
178     strcpy(statusPtr->taskName, ptr->taskName);
179     strcpy(statusPtr->volumeName, ptr->volumeName);
180     statusPtr->taskId = ptr->taskId;
181     statusPtr->flags = ptr->flags;
182     statusPtr->nKBytes = ptr->nKBytes;
183     statusPtr->lastPolled = ptr->lastPolled;
184
185     unlock_Status();
186     return (0);
187 }
188
189
190 /* ---------------------------------
191  * misc. status management routines
192  * ---------------------------------
193  */
194
195 /* checkAbortByTaskId
196  * exit:
197  *      0 - continue
198  *      n - abort requested
199  */
200
201 int
202 checkAbortByTaskId(afs_uint32 taskId)
203 {
204     statusP statusPtr;
205     int retval = 0;
206
207     lock_Status();
208     statusPtr = findStatus(taskId);
209     if (statusPtr) {
210         retval = statusPtr->flags & ABORT_REQUEST;
211     }
212     unlock_Status();
213     return (retval);
214 }
215
216 /* getStatusFlag
217  *      For backwards compatibility. Queries flag status
218  * exit:
219  *      0 - flag clear
220  *      n - flag set
221  */
222
223 afs_uint32
224 getStatusFlag(afs_uint32 taskId, afs_uint32 flag)
225 {
226     statusP statusPtr;
227     int retval = 0;
228
229     lock_Status();
230     statusPtr = findStatus(taskId);
231     if (statusPtr) {
232         retval = statusPtr->flags & flag;
233     }
234     unlock_Status();
235     return (retval);
236 }