hammer2 - add HAMMER2IOC_PFS_LOOKUP
[dragonfly.git] / sys / vfs / hammer2 / hammer2_ioctl.c
1 /*
2  * Copyright (c) 2011-2012 The DragonFly Project.  All rights reserved.
3  *
4  * This code is derived from software contributed to The DragonFly Project
5  * by Matthew Dillon <dillon@dragonflybsd.org>
6  * by Venkatesh Srinivas <vsrinivas@dragonflybsd.org>
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in
16  *    the documentation and/or other materials provided with the
17  *    distribution.
18  * 3. Neither the name of The DragonFly Project nor the names of its
19  *    contributors may be used to endorse or promote products derived
20  *    from this software without specific, prior written permission.
21  *
22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
25  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
26  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
27  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
28  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
29  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
30  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
31  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
32  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33  * SUCH DAMAGE.
34  */
35 /*
36  * Ioctl Functions.
37  *
38  * WARNING! The ioctl functions which manipulate the connection state need
39  *          to be able to run without deadlock on the volume's chain lock.
40  *          Most of these functions use a separate lock.
41  */
42
43 #include "hammer2.h"
44
45 static int hammer2_ioctl_version_get(hammer2_inode_t *ip, void *data);
46 static int hammer2_ioctl_remote_get(hammer2_inode_t *ip, void *data);
47 static int hammer2_ioctl_remote_add(hammer2_inode_t *ip, void *data);
48 static int hammer2_ioctl_remote_del(hammer2_inode_t *ip, void *data);
49 static int hammer2_ioctl_remote_rep(hammer2_inode_t *ip, void *data);
50 static int hammer2_ioctl_socket_get(hammer2_inode_t *ip, void *data);
51 static int hammer2_ioctl_socket_set(hammer2_inode_t *ip, void *data);
52 static int hammer2_ioctl_pfs_get(hammer2_inode_t *ip, void *data);
53 static int hammer2_ioctl_pfs_lookup(hammer2_inode_t *ip, void *data);
54 static int hammer2_ioctl_pfs_create(hammer2_inode_t *ip, void *data);
55 static int hammer2_ioctl_pfs_delete(hammer2_inode_t *ip, void *data);
56 static int hammer2_ioctl_inode_get(hammer2_inode_t *ip, void *data);
57 static int hammer2_ioctl_inode_set(hammer2_inode_t *ip, void *data);
58
59 int
60 hammer2_ioctl(hammer2_inode_t *ip, u_long com, void *data, int fflag,
61               struct ucred *cred)
62 {
63         int error;
64
65         /*
66          * Standard root cred checks, will be selectively ignored below
67          * for ioctls that do not require root creds.
68          */
69         error = priv_check_cred(cred, PRIV_HAMMER_IOCTL, 0);
70
71         switch(com) {
72         case HAMMER2IOC_VERSION_GET:
73                 error = hammer2_ioctl_version_get(ip, data);
74                 break;
75         case HAMMER2IOC_REMOTE_GET:
76                 if (error == 0)
77                         error = hammer2_ioctl_remote_get(ip, data);
78                 break;
79         case HAMMER2IOC_REMOTE_ADD:
80                 if (error == 0)
81                         error = hammer2_ioctl_remote_add(ip, data);
82                 break;
83         case HAMMER2IOC_REMOTE_DEL:
84                 if (error == 0)
85                         error = hammer2_ioctl_remote_del(ip, data);
86                 break;
87         case HAMMER2IOC_REMOTE_REP:
88                 if (error == 0)
89                         error = hammer2_ioctl_remote_rep(ip, data);
90                 break;
91         case HAMMER2IOC_SOCKET_GET:
92                 if (error == 0)
93                         error = hammer2_ioctl_socket_get(ip, data);
94                 break;
95         case HAMMER2IOC_SOCKET_SET:
96                 if (error == 0)
97                         error = hammer2_ioctl_socket_set(ip, data);
98                 break;
99         case HAMMER2IOC_PFS_GET:
100                 if (error == 0)
101                         error = hammer2_ioctl_pfs_get(ip, data);
102                 break;
103         case HAMMER2IOC_PFS_LOOKUP:
104                 if (error == 0)
105                         error = hammer2_ioctl_pfs_lookup(ip, data);
106                 break;
107         case HAMMER2IOC_PFS_CREATE:
108                 if (error == 0)
109                         error = hammer2_ioctl_pfs_create(ip, data);
110                 break;
111         case HAMMER2IOC_PFS_DELETE:
112                 if (error == 0)
113                         error = hammer2_ioctl_pfs_delete(ip, data);
114                 break;
115         case HAMMER2IOC_INODE_GET:
116                 error = hammer2_ioctl_inode_get(ip, data);
117                 break;
118         case HAMMER2IOC_INODE_SET:
119                 if (error == 0)
120                         error = hammer2_ioctl_inode_set(ip, data);
121                 break;
122         default:
123                 error = EOPNOTSUPP;
124                 break;
125         }
126         return (error);
127 }
128
129 /*
130  * Retrieve version and basic info
131  */
132 static int
133 hammer2_ioctl_version_get(hammer2_inode_t *ip, void *data)
134 {
135         hammer2_mount_t *hmp = ip->hmp;
136         hammer2_ioc_version_t *version = data;
137
138         version->version = hmp->voldata.version;
139         return 0;
140 }
141
142 /*
143  * Retrieve information about a remote
144  */
145 static int
146 hammer2_ioctl_remote_get(hammer2_inode_t *ip, void *data)
147 {
148         hammer2_mount_t *hmp = ip->hmp;
149         hammer2_ioc_remote_t *remote = data;
150         int copyid = remote->copyid;
151
152         if (copyid < 0 || copyid >= HAMMER2_COPYID_COUNT)
153                 return (EINVAL);
154
155         hammer2_voldata_lock(hmp);
156         remote->copy1 = hmp->voldata.copyinfo[copyid];
157         hammer2_voldata_unlock(hmp);
158
159         /*
160          * Adjust nextid (GET only)
161          */
162         while (++copyid < HAMMER2_COPYID_COUNT &&
163                hmp->voldata.copyinfo[copyid].copyid == 0) {
164                 ++copyid;
165         }
166         if (copyid == HAMMER2_COPYID_COUNT)
167                 remote->nextid = -1;
168         else
169                 remote->nextid = copyid;
170
171         return(0);
172 }
173
174 /*
175  * Add new remote entry
176  */
177 static int
178 hammer2_ioctl_remote_add(hammer2_inode_t *ip, void *data)
179 {
180         hammer2_mount_t *hmp = ip->hmp;
181         hammer2_ioc_remote_t *remote = data;
182         int copyid = remote->copyid;
183         int error = 0;
184
185         if (copyid >= HAMMER2_COPYID_COUNT)
186                 return (EINVAL);
187
188         hammer2_voldata_lock(hmp);
189         if (copyid < 0) {
190                 for (copyid = 1; copyid < HAMMER2_COPYID_COUNT; ++copyid) {
191                         if (hmp->voldata.copyinfo[copyid].copyid == 0)
192                                 break;
193                 }
194                 if (copyid == HAMMER2_COPYID_COUNT) {
195                         error = ENOSPC;
196                         goto failed;
197                 }
198         }
199         hammer2_modify_volume(hmp);
200         kprintf("copyid %d\n", copyid);
201         remote->copy1.copyid = copyid;
202         hmp->voldata.copyinfo[copyid] = remote->copy1;
203 failed:
204         hammer2_voldata_unlock(hmp);
205         return (error);
206 }
207
208 /*
209  * Delete existing remote entry
210  */
211 static int
212 hammer2_ioctl_remote_del(hammer2_inode_t *ip, void *data)
213 {
214         hammer2_mount_t *hmp = ip->hmp;
215         hammer2_ioc_remote_t *remote = data;
216         int copyid = remote->copyid;
217         int error = 0;
218
219         if (copyid >= HAMMER2_COPYID_COUNT)
220                 return (EINVAL);
221         remote->copy1.path[sizeof(remote->copy1.path) - 1] = 0;
222         hammer2_voldata_lock(hmp);
223         if (copyid < 0) {
224                 for (copyid = 1; copyid < HAMMER2_COPYID_COUNT; ++copyid) {
225                         if (hmp->voldata.copyinfo[copyid].copyid == 0)
226                                 continue;
227                         if (strcmp(remote->copy1.path,
228                             hmp->voldata.copyinfo[copyid].path) == 0) {
229                                 break;
230                         }
231                 }
232                 if (copyid == HAMMER2_COPYID_COUNT) {
233                         error = ENOENT;
234                         goto failed;
235                 }
236         }
237         hammer2_modify_volume(hmp);
238         hmp->voldata.copyinfo[copyid].copyid = 0;
239 failed:
240         hammer2_voldata_unlock(hmp);
241         return (error);
242 }
243
244 /*
245  * Replace existing remote entry
246  */
247 static int
248 hammer2_ioctl_remote_rep(hammer2_inode_t *ip, void *data)
249 {
250         hammer2_mount_t *hmp = ip->hmp;
251         hammer2_ioc_remote_t *remote = data;
252         int copyid = remote->copyid;
253
254         if (copyid < 0 || copyid >= HAMMER2_COPYID_COUNT)
255                 return (EINVAL);
256
257         hammer2_voldata_lock(hmp);
258         hammer2_voldata_unlock(hmp);
259
260         return(0);
261 }
262
263 /*
264  * Retrieve communications socket
265  */
266 static int
267 hammer2_ioctl_socket_get(hammer2_inode_t *ip, void *data)
268 {
269         return (EOPNOTSUPP);
270 }
271
272 /*
273  * Set communications socket for connection
274  */
275 static int
276 hammer2_ioctl_socket_set(hammer2_inode_t *ip, void *data)
277 {
278         hammer2_mount_t *hmp = ip->hmp;
279         hammer2_ioc_remote_t *remote = data;
280         int copyid = remote->copyid;
281
282         if (copyid < 0 || copyid >= HAMMER2_COPYID_COUNT)
283                 return (EINVAL);
284
285         hammer2_voldata_lock(hmp);
286         hammer2_voldata_unlock(hmp);
287
288         return(0);
289 }
290
291 /*
292  * Used to scan PFSs, which are directories under the super-root.
293  */
294 static int
295 hammer2_ioctl_pfs_get(hammer2_inode_t *ip, void *data)
296 {
297         hammer2_mount_t *hmp = ip->hmp;
298         hammer2_ioc_pfs_t *pfs = data;
299         hammer2_chain_t *parent;
300         hammer2_chain_t *chain;
301         hammer2_inode_t *xip;
302         int error = 0;
303
304         parent = hmp->schain;
305         error = hammer2_chain_lock(hmp, parent, HAMMER2_RESOLVE_ALWAYS);
306         if (error)
307                 goto done;
308
309         /*
310          * Search for the first key or specific key.  Remember that keys
311          * can be returned in any order.
312          */
313         if (pfs->name_key == 0) {
314                 chain = hammer2_chain_lookup(hmp, &parent,
315                                              0, (hammer2_key_t)-1, 0);
316         } else {
317                 chain = hammer2_chain_lookup(hmp, &parent,
318                                              pfs->name_key, pfs->name_key, 0);
319         }
320         while (chain && chain->bref.type != HAMMER2_BREF_TYPE_INODE) {
321                 chain = hammer2_chain_next(hmp, &parent, chain,
322                                      0, (hammer2_key_t)-1, 0);
323         }
324         if (chain) {
325                 /*
326                  * Load the data being returned by the ioctl.
327                  */
328                 xip = chain->u.ip;
329                 pfs->name_key = xip->ip_data.name_key;
330                 pfs->pfs_type = xip->ip_data.pfs_type;
331                 pfs->pfs_clid = xip->ip_data.pfs_clid;
332                 pfs->pfs_fsid = xip->ip_data.pfs_fsid;
333                 KKASSERT(xip->ip_data.name_len < sizeof(pfs->name));
334                 bcopy(xip->ip_data.filename, pfs->name,
335                       xip->ip_data.name_len);
336                 pfs->name[xip->ip_data.name_len] = 0;
337
338                 /*
339                  * Calculate the next field
340                  */
341                 do {
342                         chain = hammer2_chain_next(hmp, &parent, chain,
343                                              0, (hammer2_key_t)-1, 0);
344                 } while (chain && chain->bref.type != HAMMER2_BREF_TYPE_INODE);
345                 if (chain) {
346                         pfs->name_next = chain->u.ip->ip_data.name_key;
347                         hammer2_chain_unlock(hmp, chain);
348                 } else {
349                         pfs->name_next = (hammer2_key_t)-1;
350                 }
351         } else {
352                 pfs->name_next = (hammer2_key_t)-1;
353                 error = ENOENT;
354         }
355 done:
356         hammer2_chain_unlock(hmp, parent);
357         return (error);
358 }
359
360 /*
361  * Find a specific PFS by name
362  */
363 static int
364 hammer2_ioctl_pfs_lookup(hammer2_inode_t *ip, void *data)
365 {
366         hammer2_mount_t *hmp = ip->hmp;
367         hammer2_ioc_pfs_t *pfs = data;
368         hammer2_chain_t *parent;
369         hammer2_chain_t *chain;
370         hammer2_inode_t *xip;
371         hammer2_key_t lhc;
372         int error = 0;
373         size_t len;
374
375         parent = hmp->schain;
376         error = hammer2_chain_lock(hmp, parent, HAMMER2_RESOLVE_ALWAYS |
377                                                 HAMMER2_RESOLVE_SHARED);
378         if (error)
379                 goto done;
380
381         pfs->name[sizeof(pfs->name) - 1] = 0;
382         len = strlen(pfs->name);
383         lhc = hammer2_dirhash(pfs->name, len);
384
385         chain = hammer2_chain_lookup(hmp, &parent,
386                                      lhc, lhc + HAMMER2_DIRHASH_LOMASK,
387                                      HAMMER2_LOOKUP_SHARED);
388         while (chain) {
389                 if (chain->bref.type == HAMMER2_BREF_TYPE_INODE &&
390                     chain->u.ip &&
391                     len == chain->data->ipdata.name_len &&
392                     bcmp(pfs->name, chain->data->ipdata.filename, len) == 0) {
393                         break;
394                 }
395                 chain = hammer2_chain_next(hmp, &parent, chain,
396                                            lhc, lhc + HAMMER2_DIRHASH_LOMASK,
397                                            HAMMER2_LOOKUP_SHARED);
398         }
399
400         /*
401          * Load the data being returned by the ioctl.
402          */
403         if (chain) {
404                 xip = chain->u.ip;
405                 pfs->name_key = xip->ip_data.name_key;
406                 pfs->pfs_type = xip->ip_data.pfs_type;
407                 pfs->pfs_clid = xip->ip_data.pfs_clid;
408                 pfs->pfs_fsid = xip->ip_data.pfs_fsid;
409
410                 hammer2_chain_unlock(hmp, chain);
411         } else {
412                 error = ENOENT;
413         }
414 done:
415         hammer2_chain_unlock(hmp, parent);
416         return (error);
417 }
418
419 /*
420  * Create a new PFS under the super-root
421  */
422 static int
423 hammer2_ioctl_pfs_create(hammer2_inode_t *ip, void *data)
424 {
425         hammer2_mount_t *hmp = ip->hmp;
426         hammer2_ioc_pfs_t *pfs = data;
427         hammer2_inode_t *nip = NULL;
428         int error;
429
430         pfs->name[sizeof(pfs->name) - 1] = 0;   /* ensure 0-termination */
431         error = hammer2_inode_create(hmp->schain->u.ip, NULL, NULL,
432                                      pfs->name, strlen(pfs->name),
433                                      &nip);
434         if (error == 0) {
435                 hammer2_chain_modify(hmp, &nip->chain, 0);
436                 nip->ip_data.pfs_type = pfs->pfs_type;
437                 nip->ip_data.pfs_clid = pfs->pfs_clid;
438                 nip->ip_data.pfs_fsid = pfs->pfs_fsid;
439                 hammer2_chain_unlock(hmp, &nip->chain);
440         }
441         return (error);
442 }
443
444 /*
445  * Destroy an existing PFS under the super-root
446  */
447 static int
448 hammer2_ioctl_pfs_delete(hammer2_inode_t *ip, void *data)
449 {
450         hammer2_mount_t *hmp = ip->hmp;
451         hammer2_ioc_pfs_t *pfs = data;
452         int error;
453
454         error = hammer2_unlink_file(hmp->schain->u.ip,
455                                     pfs->name, strlen(pfs->name),
456                                     0, NULL);
457         return (error);
458 }
459
460 /*
461  * Retrieve the raw inode structure
462  */
463 static int
464 hammer2_ioctl_inode_get(hammer2_inode_t *ip, void *data)
465 {
466         hammer2_ioc_inode_t *ino = data;
467
468         hammer2_inode_lock_sh(ip);
469         ino->ip_data = ip->ip_data;
470         ino->kdata = ip;
471         hammer2_inode_unlock_sh(ip);
472         return (0);
473 }
474
475 static int
476 hammer2_ioctl_inode_set(hammer2_inode_t *ip, void *data)
477 {
478         hammer2_ioc_inode_t *ino = data;
479         int error = EINVAL;
480
481         hammer2_inode_lock_ex(ip);
482         if (ino->flags & HAMMER2IOC_INODE_FLAG_IQUOTA) {
483         }
484         if (ino->flags & HAMMER2IOC_INODE_FLAG_DQUOTA) {
485         }
486         if (ino->flags & HAMMER2IOC_INODE_FLAG_COPIES) {
487         }
488         hammer2_inode_unlock_ex(ip);
489         return (error);
490 }