Whamcloud - gitweb
- fixes in GNS stuff - bug #9283
[fs/lustre-release.git] / lustre / llite / llite_capa.c
1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2  * vim:expandtab:shiftwidth=8:tabstop=8:
3  *
4  * Copyright (C) 2004, 2005 Cluster File Systems, Inc.
5  *
6  * Author: Lai Siyao <lsy@clusterfs.com>
7  *
8  *   This file is part of Lustre, http://www.lustre.org.
9  *
10  *   Lustre is free software; you can redistribute it and/or
11  *   modify it under the terms of version 2 of the GNU General Public
12  *   License as published by the Free Software Foundation.
13  *
14  *   Lustre is distributed in the hope that it will be useful,
15  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
16  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  *   GNU General Public License for more details.
18  *
19  *   You should have received a copy of the GNU General Public License
20  *   along with Lustre; if not, write to the Free Software
21  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22  */
23
24 #define DEBUG_SUBSYSTEM S_LLITE
25
26 #include <linux/fs.h>
27 #include <linux/version.h>
28 #include <asm/uaccess.h>
29 #include <linux/file.h>
30 #include <linux/kmod.h>
31
32 #include <linux/lustre_lite.h>
33 #include "llite_internal.h"
34
35 static struct list_head *ll_capa_list = &capa_list[CLIENT_CAPA];
36 static struct ptlrpc_thread capa_thread;
37
38 static struct thread_ctl {
39         struct completion ctl_starting;
40         struct completion ctl_finishing;
41 } ll_capa_ctl;
42
43 static inline int have_expired_capa(void)
44 {
45         struct obd_capa *ocapa;
46         struct lustre_capa *capa;
47         int expired = 0;
48         unsigned long expiry;
49         ENTRY;
50
51         spin_lock(&capa_lock);
52         if (!list_empty(ll_capa_list)) {
53                 ocapa = list_entry(ll_capa_list->next, struct obd_capa, c_list);
54                 expired = __capa_is_to_expire(ocapa);
55                 if (!expired) {
56                         capa = &ocapa->c_capa;
57                         expiry = expiry_to_jiffies(capa->lc_expiry -
58                                                    capa_pre_expiry(capa));
59                         if (time_before(expiry, ll_capa_timer.expires) ||
60                             !timer_pending(&ll_capa_timer)) {
61                                 mod_timer(&ll_capa_timer, expiry);
62                                 CDEBUG(D_INFO,"ll_capa_timer new expiry: %lu\n",
63                                        expiry);
64                         }
65                 }
66         }
67         spin_unlock(&capa_lock);
68
69         RETURN(expired);
70 }
71
72 static int inline ll_capa_check_stop(void)
73 {
74         return (capa_thread.t_flags & SVC_STOPPING) ? 1: 0;
75 }
76
77 static int ll_renew_capa(struct obd_capa *ocapa)
78 {
79         struct ptlrpc_request *req = NULL;
80         /* no need to lock, no one else will touch it */
81         struct inode *inode = ocapa->c_inode;
82         struct obd_export *md_exp = ll_i2mdexp(inode);
83         struct ll_inode_info *lli = ll_i2info(inode);
84         __u64 valid = OBD_MD_CAPA;
85         int rc;
86         ENTRY;
87
88         if (capa_expired(&ocapa->c_capa))
89                 RETURN(-ESTALE);
90
91         rc = md_getattr(md_exp, &lli->lli_id, valid, NULL, NULL, 0,
92                         0, ocapa, &req);
93         RETURN(rc);
94 }
95
96 static int ll_capa_thread(void *arg)
97 {
98         struct thread_ctl *ctl = arg;
99         unsigned long flags;
100         int rc;
101         ENTRY;
102
103         {
104                 char name[sizeof(current->comm)];
105                 snprintf(name, sizeof(name) - 1, "ll_capa");
106                 kportal_daemonize(name);
107         }
108
109         SIGNAL_MASK_LOCK(current, flags);
110         sigfillset(&current->blocked);
111         RECALC_SIGPENDING;
112         SIGNAL_MASK_UNLOCK(current, flags);
113
114         /*
115          * letting starting function know, that we are ready and control may be
116          * returned.
117          */
118         capa_thread.t_flags = SVC_RUNNING;
119         complete(&ctl->ctl_starting);
120
121         while (1) {
122                 struct l_wait_info lwi = { 0 };
123                 struct obd_capa *ocapa, *tmp, *next = NULL, tcapa;
124                 unsigned long expiry, sleep = CAPA_PRE_EXPIRY;
125
126                 l_wait_event(capa_thread.t_ctl_waitq,
127                              (have_expired_capa() || ll_capa_check_stop()),
128                              &lwi);
129
130                 if (ll_capa_check_stop())
131                         break;
132
133                 spin_lock(&capa_lock);
134                 list_for_each_entry_safe(ocapa, tmp, ll_capa_list, c_list) {
135                         if (ocapa->c_capa.lc_flags & CAPA_FL_SHORT)
136                                 sleep = CAPA_PRE_EXPIRY_SHORT;
137
138                         if (ocapa->c_capa.lc_op == CAPA_TRUNC)
139                                 continue;
140
141                         if (__capa_is_to_expire(ocapa)) {
142                                 /* copy capa in case it's deleted */
143                                 tcapa = *ocapa;
144                                 spin_unlock(&capa_lock);
145
146                                 rc = ll_renew_capa(&tcapa);
147                                 if (rc)
148                                         capa_put(ocapa);
149
150                                 spin_lock(&capa_lock);
151                         } else {
152                                 next = ocapa;
153                                 break;
154                         }
155                 }
156
157                 if (next) {
158                         struct lustre_capa *capa = &next->c_capa;
159
160                         expiry = expiry_to_jiffies(capa->lc_expiry -
161                                                    capa_pre_expiry(capa));
162                         if (time_before(expiry, ll_capa_timer.expires) ||
163                             !timer_pending(&ll_capa_timer)) {
164                                 mod_timer(&ll_capa_timer, expiry);
165                                 CDEBUG(D_INFO,"ll_capa_timer new expiry: %lu\n",
166                                        expiry);
167                         }
168                 }
169                 spin_unlock(&capa_lock);
170
171                 /* wait ll_renew_capa finish */
172                 set_current_state(TASK_INTERRUPTIBLE);
173                 schedule_timeout(sleep * HZ);
174         }
175
176         capa_thread.t_flags = SVC_STOPPED;
177
178         /* this is SMP-safe way to finish thread. */
179         complete_and_exit(&ctl->ctl_finishing, 0);
180         EXIT;
181 }
182
183 /* just wake up, others are handled by ll_capa_thread */
184 void ll_capa_timer_callback(unsigned long unused)
185 {
186         ENTRY;
187         wake_up(&capa_thread.t_ctl_waitq);
188         EXIT;
189 }
190
191 int ll_capa_thread_start(void)
192 {
193         int rc;
194         ENTRY;
195
196         LASSERT(capa_thread.t_flags == 0);
197         init_completion(&ll_capa_ctl.ctl_starting);
198         init_completion(&ll_capa_ctl.ctl_finishing);
199         init_waitqueue_head(&capa_thread.t_ctl_waitq);
200
201         rc = kernel_thread(ll_capa_thread, &ll_capa_ctl,
202                            (CLONE_VM | CLONE_FILES));
203         if (rc < 0) {
204                 CERROR("cannot start expired capa thread, "
205                        "err = %d\n", rc);
206                 RETURN(rc);
207         }
208         wait_for_completion(&ll_capa_ctl.ctl_starting);
209         LASSERT(capa_thread.t_flags == SVC_RUNNING);
210         RETURN(0);
211 }
212
213 void ll_capa_thread_stop(void)
214 {
215         ENTRY;
216
217         capa_thread.t_flags = SVC_STOPPING;
218         wake_up(&capa_thread.t_ctl_waitq);
219         wait_for_completion(&ll_capa_ctl.ctl_finishing);
220         LASSERT(capa_thread.t_flags == SVC_STOPPED);
221         capa_thread.t_flags = 0;
222
223         EXIT;
224 }
225
226 int ll_set_capa(struct inode *inode, struct lookup_intent *it,
227                 struct obd_client_handle *och)
228 {
229         struct ptlrpc_request *req = LUSTRE_IT(it)->it_data;
230         struct mds_body *body;
231         struct lustre_capa *capa;
232         struct obd_capa *ocapa;
233         struct ll_inode_info *lli = ll_i2info(inode);
234         unsigned long expiry;
235
236         if (!S_ISREG(inode->i_mode))
237                 return 0;
238
239         /* GNS code path will have no req */
240         if (!req)
241                 return 0;
242
243         body = lustre_msg_buf(req->rq_repmsg, 1, sizeof (*body));
244         LASSERT(body != NULL);          /* reply already checked out */
245         LASSERT_REPSWABBED(req, 1);     /* and swabbed down */
246
247         if (!(body->valid & OBD_MD_CAPA))
248                 return 0;
249
250         ENTRY;
251
252         capa = lustre_msg_buf(req->rq_repmsg, 7, sizeof (*capa));
253         LASSERT(capa != NULL);          /* reply already checked out */
254         LASSERT_REPSWABBED(req, 7);     /* and swabbed down */
255
256         ocapa = capa_renew(capa, CLIENT_CAPA);
257         if (!ocapa)
258                 RETURN(-ENOMEM);
259
260         spin_lock(&capa_lock);
261         ocapa->c_inode = inode;
262         ocapa->c_handle = och->och_fh;
263         spin_unlock(&capa_lock);
264
265         spin_lock(&lli->lli_lock);
266         /* in case it was linked to lli_capas already */
267         if (list_empty(&ocapa->c_lli_list))
268                 list_add(&ocapa->c_lli_list, &lli->lli_capas);
269         spin_unlock(&lli->lli_lock);
270
271         expiry = expiry_to_jiffies(capa->lc_expiry - capa_pre_expiry(capa));
272
273         spin_lock(&capa_lock);
274         if (time_before(expiry, ll_capa_timer.expires) ||
275             !timer_pending(&ll_capa_timer)) {
276                 mod_timer(&ll_capa_timer, expiry);
277                 CDEBUG(D_INFO, "ll_capa_timer new expiry: %lu\n", expiry);
278         }
279         spin_unlock(&capa_lock);
280
281         RETURN(0);
282 }
283
284 int ll_set_trunc_capa(struct ptlrpc_request *req, int offset, struct inode *inode)
285 {
286         struct mds_body *body;
287         struct obd_capa *ocapa;
288         struct lustre_capa *capa;
289         struct ll_inode_info *lli = ll_i2info(inode);
290
291         body = lustre_msg_buf(req->rq_repmsg, offset, sizeof(*body));
292         if (!body)
293                 return -ENOMEM;
294
295         if (!(body->valid & OBD_MD_CAPA))
296                 return 0;
297
298         ENTRY;
299         capa = (struct lustre_capa *)lustre_swab_repbuf(req, offset + 1,
300                                         sizeof(*capa), lustre_swab_lustre_capa);
301         if (!capa)
302                 RETURN(-ENOMEM);        
303
304         ocapa = capa_renew(capa, CLIENT_CAPA);
305         if (!ocapa)
306                 RETURN(-ENOMEM);
307
308         spin_lock(&lli->lli_lock);
309         /* in case it was linked to lli_capas already */
310         if (list_empty(&ocapa->c_lli_list))
311                 list_add(&ocapa->c_lli_list, &lli->lli_capas);
312         spin_unlock(&lli->lli_lock);
313
314         RETURN(0);
315 }
316
317 struct obd_capa *ll_get_capa(struct inode *inode, uid_t uid, int op)
318 {
319         struct ll_inode_info *lli = ll_i2info(inode);
320         struct obd_capa *ocapa, *tmp;
321         ENTRY;
322
323         list_for_each_entry_safe(ocapa, tmp, &lli->lli_capas, c_lli_list) {
324                 if (ocapa->c_capa.lc_ruid != uid)
325                         continue;
326                 if (ocapa->c_capa.lc_op != op)
327                         continue;
328
329                 RETURN(ocapa);
330         }
331         
332         RETURN(NULL);
333 }