4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 only,
8 * as published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License version 2 for more details (a copy is included
14 * in the LICENSE file that accompanied this code).
16 * You should have received a copy of the GNU General Public License
17 * version 2 along with this program; If not, see
18 * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
20 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
21 * CA 95054 USA or visit www.sun.com if you need additional information or
27 * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
28 * Use is subject to license terms.
30 * Copyright (c) 2011, 2015, Intel Corporation.
33 * This file is part of Lustre, http://www.lustre.org/
34 * Lustre is a trademark of Sun Microsystems, Inc.
36 * lustre/lov/lov_obd.c
38 * Author: Phil Schwan <phil@clusterfs.com>
39 * Author: Peter Braam <braam@clusterfs.com>
40 * Author: Mike Shaver <shaver@clusterfs.com>
41 * Author: Nathan Rutman <nathan@clusterfs.com>
44 #define DEBUG_SUBSYSTEM S_LOV
45 #include "../../include/linux/libcfs/libcfs.h"
47 #include "../include/obd_support.h"
48 #include "../include/lustre_lib.h"
49 #include "../include/lustre_net.h"
50 #include "../include/lustre/lustre_idl.h"
51 #include "../include/lustre_dlm.h"
52 #include "../include/lustre_mds.h"
53 #include "../include/obd_class.h"
54 #include "../include/lprocfs_status.h"
55 #include "../include/lustre_param.h"
56 #include "../include/cl_object.h"
57 #include "../include/lclient.h" /* for cl_client_lru */
58 #include "../include/lustre/ll_fiemap.h"
59 #include "../include/lustre_fid.h"
61 #include "lov_internal.h"
63 /* Keep a refcount of lov->tgt usage to prevent racing with addition/deletion.
64 * Any function that expects lov_tgts to remain stationary must take a ref.
66 static void lov_getref(struct obd_device
*obd
)
68 struct lov_obd
*lov
= &obd
->u
.lov
;
70 /* nobody gets through here until lov_putref is done */
71 mutex_lock(&lov
->lov_lock
);
72 atomic_inc(&lov
->lov_refcount
);
73 mutex_unlock(&lov
->lov_lock
);
77 static void __lov_del_obd(struct obd_device
*obd
, struct lov_tgt_desc
*tgt
);
79 static void lov_putref(struct obd_device
*obd
)
81 struct lov_obd
*lov
= &obd
->u
.lov
;
83 mutex_lock(&lov
->lov_lock
);
84 /* ok to dec to 0 more than once -- ltd_exp's will be null */
85 if (atomic_dec_and_test(&lov
->lov_refcount
) && lov
->lov_death_row
) {
88 struct lov_tgt_desc
*tgt
, *n
;
90 CDEBUG(D_CONFIG
, "destroying %d lov targets\n",
92 for (i
= 0; i
< lov
->desc
.ld_tgt_count
; i
++) {
93 tgt
= lov
->lov_tgts
[i
];
95 if (!tgt
|| !tgt
->ltd_reap
)
97 list_add(&tgt
->ltd_kill
, &kill
);
98 /* XXX - right now there is a dependency on ld_tgt_count
99 * being the maximum tgt index for computing the
100 * mds_max_easize. So we can't shrink it.
102 lov_ost_pool_remove(&lov
->lov_packed
, i
);
103 lov
->lov_tgts
[i
] = NULL
;
104 lov
->lov_death_row
--;
106 mutex_unlock(&lov
->lov_lock
);
108 list_for_each_entry_safe(tgt
, n
, &kill
, ltd_kill
) {
109 list_del(&tgt
->ltd_kill
);
111 __lov_del_obd(obd
, tgt
);
114 if (lov
->lov_tgts_kobj
)
115 kobject_put(lov
->lov_tgts_kobj
);
118 mutex_unlock(&lov
->lov_lock
);
122 static int lov_set_osc_active(struct obd_device
*obd
, struct obd_uuid
*uuid
,
123 enum obd_notify_event ev
);
124 static int lov_notify(struct obd_device
*obd
, struct obd_device
*watched
,
125 enum obd_notify_event ev
, void *data
);
127 #define MAX_STRING_SIZE 128
128 int lov_connect_obd(struct obd_device
*obd
, __u32 index
, int activate
,
129 struct obd_connect_data
*data
)
131 struct lov_obd
*lov
= &obd
->u
.lov
;
132 struct obd_uuid
*tgt_uuid
;
133 struct obd_device
*tgt_obd
;
134 static struct obd_uuid lov_osc_uuid
= { "LOV_OSC_UUID" };
135 struct obd_import
*imp
;
138 if (!lov
->lov_tgts
[index
])
141 tgt_uuid
= &lov
->lov_tgts
[index
]->ltd_uuid
;
142 tgt_obd
= lov
->lov_tgts
[index
]->ltd_obd
;
144 if (!tgt_obd
->obd_set_up
) {
145 CERROR("Target %s not set up\n", obd_uuid2str(tgt_uuid
));
149 /* override the sp_me from lov */
150 tgt_obd
->u
.cli
.cl_sp_me
= lov
->lov_sp_me
;
152 if (data
&& (data
->ocd_connect_flags
& OBD_CONNECT_INDEX
))
153 data
->ocd_index
= index
;
156 * Divine LOV knows that OBDs under it are OSCs.
158 imp
= tgt_obd
->u
.cli
.cl_import
;
161 tgt_obd
->obd_no_recov
= 0;
162 /* FIXME this is probably supposed to be
163 * ptlrpc_set_import_active. Horrible naming.
165 ptlrpc_activate_import(imp
);
168 rc
= obd_register_observer(tgt_obd
, obd
);
170 CERROR("Target %s register_observer error %d\n",
171 obd_uuid2str(tgt_uuid
), rc
);
175 if (imp
->imp_invalid
) {
176 CDEBUG(D_CONFIG
, "not connecting OSC %s; administratively disabled\n",
177 obd_uuid2str(tgt_uuid
));
181 rc
= obd_connect(NULL
, &lov
->lov_tgts
[index
]->ltd_exp
, tgt_obd
,
182 &lov_osc_uuid
, data
, NULL
);
183 if (rc
|| !lov
->lov_tgts
[index
]->ltd_exp
) {
184 CERROR("Target %s connect error %d\n",
185 obd_uuid2str(tgt_uuid
), rc
);
189 lov
->lov_tgts
[index
]->ltd_reap
= 0;
191 CDEBUG(D_CONFIG
, "Connected tgt idx %d %s (%s) %sactive\n", index
,
192 obd_uuid2str(tgt_uuid
), tgt_obd
->obd_name
, activate
? "":"in");
194 if (lov
->lov_tgts_kobj
)
195 /* Even if we failed, that's ok */
196 rc
= sysfs_create_link(lov
->lov_tgts_kobj
, &tgt_obd
->obd_kobj
,
202 static int lov_connect(const struct lu_env
*env
,
203 struct obd_export
**exp
, struct obd_device
*obd
,
204 struct obd_uuid
*cluuid
, struct obd_connect_data
*data
,
207 struct lov_obd
*lov
= &obd
->u
.lov
;
208 struct lov_tgt_desc
*tgt
;
209 struct lustre_handle conn
;
212 CDEBUG(D_CONFIG
, "connect #%d\n", lov
->lov_connects
);
214 rc
= class_connect(&conn
, obd
, cluuid
);
218 *exp
= class_conn2export(&conn
);
220 /* Why should there ever be more than 1 connect? */
222 LASSERT(lov
->lov_connects
== 1);
224 memset(&lov
->lov_ocd
, 0, sizeof(lov
->lov_ocd
));
226 lov
->lov_ocd
= *data
;
230 lov
->lov_tgts_kobj
= kobject_create_and_add("target_obds",
233 for (i
= 0; i
< lov
->desc
.ld_tgt_count
; i
++) {
234 tgt
= lov
->lov_tgts
[i
];
235 if (!tgt
|| obd_uuid_empty(&tgt
->ltd_uuid
))
237 /* Flags will be lowest common denominator */
238 rc
= lov_connect_obd(obd
, i
, tgt
->ltd_activate
, &lov
->lov_ocd
);
240 CERROR("%s: lov connect tgt %d failed: %d\n",
241 obd
->obd_name
, i
, rc
);
244 /* connect to administrative disabled ost */
245 if (!lov
->lov_tgts
[i
]->ltd_exp
)
248 rc
= lov_notify(obd
, lov
->lov_tgts
[i
]->ltd_exp
->exp_obd
,
249 OBD_NOTIFY_CONNECT
, (void *)&i
);
251 CERROR("%s error sending notify %d\n",
260 static int lov_disconnect_obd(struct obd_device
*obd
, struct lov_tgt_desc
*tgt
)
262 struct lov_obd
*lov
= &obd
->u
.lov
;
263 struct obd_device
*osc_obd
;
266 osc_obd
= class_exp2obd(tgt
->ltd_exp
);
267 CDEBUG(D_CONFIG
, "%s: disconnecting target %s\n",
268 obd
->obd_name
, osc_obd
? osc_obd
->obd_name
: "NULL");
270 if (tgt
->ltd_active
) {
272 lov
->desc
.ld_active_tgt_count
--;
273 tgt
->ltd_exp
->exp_obd
->obd_inactive
= 1;
277 if (lov
->lov_tgts_kobj
)
278 sysfs_remove_link(lov
->lov_tgts_kobj
,
281 /* Pass it on to our clients.
282 * XXX This should be an argument to disconnect,
283 * XXX not a back-door flag on the OBD. Ah well.
285 osc_obd
->obd_force
= obd
->obd_force
;
286 osc_obd
->obd_fail
= obd
->obd_fail
;
287 osc_obd
->obd_no_recov
= obd
->obd_no_recov
;
290 obd_register_observer(osc_obd
, NULL
);
292 rc
= obd_disconnect(tgt
->ltd_exp
);
294 CERROR("Target %s disconnect error %d\n",
295 tgt
->ltd_uuid
.uuid
, rc
);
303 static int lov_disconnect(struct obd_export
*exp
)
305 struct obd_device
*obd
= class_exp2obd(exp
);
306 struct lov_obd
*lov
= &obd
->u
.lov
;
312 /* Only disconnect the underlying layers on the final disconnect. */
314 if (lov
->lov_connects
!= 0) {
315 /* why should there be more than 1 connect? */
316 CERROR("disconnect #%d\n", lov
->lov_connects
);
320 /* Let's hold another reference so lov_del_obd doesn't spin through
325 for (i
= 0; i
< lov
->desc
.ld_tgt_count
; i
++) {
326 if (lov
->lov_tgts
[i
] && lov
->lov_tgts
[i
]->ltd_exp
) {
327 /* Disconnection is the last we know about an obd */
328 lov_del_target(obd
, i
, NULL
, lov
->lov_tgts
[i
]->ltd_gen
);
335 rc
= class_disconnect(exp
); /* bz 9811 */
341 * -EINVAL : UUID can't be found in the LOV's target list
342 * -ENOTCONN: The UUID is found, but the target connection is bad (!)
343 * -EBADF : The UUID is found, but the OBD is the wrong type (!)
344 * any >= 0 : is log target index
346 static int lov_set_osc_active(struct obd_device
*obd
, struct obd_uuid
*uuid
,
347 enum obd_notify_event ev
)
349 struct lov_obd
*lov
= &obd
->u
.lov
;
350 struct lov_tgt_desc
*tgt
;
351 int index
, activate
, active
;
353 CDEBUG(D_INFO
, "Searching in lov %p for uuid %s event(%d)\n",
354 lov
, uuid
->uuid
, ev
);
357 for (index
= 0; index
< lov
->desc
.ld_tgt_count
; index
++) {
358 tgt
= lov
->lov_tgts
[index
];
362 * LU-642, initially inactive OSC could miss the obd_connect,
363 * we make up for it here.
365 if (ev
== OBD_NOTIFY_ACTIVATE
&& !tgt
->ltd_exp
&&
366 obd_uuid_equals(uuid
, &tgt
->ltd_uuid
)) {
367 struct obd_uuid lov_osc_uuid
= {"LOV_OSC_UUID"};
369 obd_connect(NULL
, &tgt
->ltd_exp
, tgt
->ltd_obd
,
370 &lov_osc_uuid
, &lov
->lov_ocd
, NULL
);
375 CDEBUG(D_INFO
, "lov idx %d is %s conn %#llx\n",
376 index
, obd_uuid2str(&tgt
->ltd_uuid
),
377 tgt
->ltd_exp
->exp_handle
.h_cookie
);
378 if (obd_uuid_equals(uuid
, &tgt
->ltd_uuid
))
382 if (index
== lov
->desc
.ld_tgt_count
) {
387 if (ev
== OBD_NOTIFY_DEACTIVATE
|| ev
== OBD_NOTIFY_ACTIVATE
) {
388 activate
= (ev
== OBD_NOTIFY_ACTIVATE
) ? 1 : 0;
390 if (lov
->lov_tgts
[index
]->ltd_activate
== activate
) {
391 CDEBUG(D_INFO
, "OSC %s already %sactivate!\n",
392 uuid
->uuid
, activate
? "" : "de");
394 lov
->lov_tgts
[index
]->ltd_activate
= activate
;
395 CDEBUG(D_CONFIG
, "%sactivate OSC %s\n",
396 activate
? "" : "de", obd_uuid2str(uuid
));
399 } else if (ev
== OBD_NOTIFY_INACTIVE
|| ev
== OBD_NOTIFY_ACTIVE
) {
400 active
= (ev
== OBD_NOTIFY_ACTIVE
) ? 1 : 0;
402 if (lov
->lov_tgts
[index
]->ltd_active
== active
) {
403 CDEBUG(D_INFO
, "OSC %s already %sactive!\n",
404 uuid
->uuid
, active
? "" : "in");
407 CDEBUG(D_CONFIG
, "Marking OSC %s %sactive\n",
408 obd_uuid2str(uuid
), active
? "" : "in");
410 lov
->lov_tgts
[index
]->ltd_active
= active
;
412 lov
->desc
.ld_active_tgt_count
++;
413 lov
->lov_tgts
[index
]->ltd_exp
->exp_obd
->obd_inactive
= 0;
415 lov
->desc
.ld_active_tgt_count
--;
416 lov
->lov_tgts
[index
]->ltd_exp
->exp_obd
->obd_inactive
= 1;
419 CERROR("Unknown event(%d) for uuid %s", ev
, uuid
->uuid
);
427 static int lov_notify(struct obd_device
*obd
, struct obd_device
*watched
,
428 enum obd_notify_event ev
, void *data
)
431 struct lov_obd
*lov
= &obd
->u
.lov
;
433 down_read(&lov
->lov_notify_lock
);
434 if (!lov
->lov_connects
) {
435 up_read(&lov
->lov_notify_lock
);
439 if (ev
== OBD_NOTIFY_ACTIVE
|| ev
== OBD_NOTIFY_INACTIVE
||
440 ev
== OBD_NOTIFY_ACTIVATE
|| ev
== OBD_NOTIFY_DEACTIVATE
) {
441 struct obd_uuid
*uuid
;
445 if (strcmp(watched
->obd_type
->typ_name
, LUSTRE_OSC_NAME
)) {
446 up_read(&lov
->lov_notify_lock
);
447 CERROR("unexpected notification of %s %s!\n",
448 watched
->obd_type
->typ_name
,
452 uuid
= &watched
->u
.cli
.cl_target_uuid
;
454 /* Set OSC as active before notifying the observer, so the
455 * observer can use the OSC normally.
457 rc
= lov_set_osc_active(obd
, uuid
, ev
);
459 up_read(&lov
->lov_notify_lock
);
460 CERROR("event(%d) of %s failed: %d\n", ev
,
461 obd_uuid2str(uuid
), rc
);
464 /* active event should be pass lov target index as data */
468 /* Pass the notification up the chain. */
470 rc
= obd_notify_observer(obd
, watched
, ev
, data
);
472 /* NULL watched means all osc's in the lov (only for syncs) */
473 /* sync event should be send lov idx as data */
474 struct lov_obd
*lov
= &obd
->u
.lov
;
478 is_sync
= (ev
== OBD_NOTIFY_SYNC
) ||
479 (ev
== OBD_NOTIFY_SYNC_NONBLOCK
);
482 for (i
= 0; i
< lov
->desc
.ld_tgt_count
; i
++) {
483 if (!lov
->lov_tgts
[i
])
486 /* don't send sync event if target not
487 * connected/activated
489 if (is_sync
&& !lov
->lov_tgts
[i
]->ltd_active
)
492 rc
= obd_notify_observer(obd
, lov
->lov_tgts
[i
]->ltd_obd
,
495 CERROR("%s: notify %s of %s failed %d\n",
497 obd
->obd_observer
->obd_name
,
498 lov
->lov_tgts
[i
]->ltd_obd
->obd_name
,
505 up_read(&lov
->lov_notify_lock
);
509 static int lov_add_target(struct obd_device
*obd
, struct obd_uuid
*uuidp
,
510 __u32 index
, int gen
, int active
)
512 struct lov_obd
*lov
= &obd
->u
.lov
;
513 struct lov_tgt_desc
*tgt
;
514 struct obd_device
*tgt_obd
;
517 CDEBUG(D_CONFIG
, "uuid:%s idx:%d gen:%d active:%d\n",
518 uuidp
->uuid
, index
, gen
, active
);
521 CERROR("request to add OBD %s with invalid generation: %d\n",
526 tgt_obd
= class_find_client_obd(uuidp
, LUSTRE_OSC_NAME
,
531 mutex_lock(&lov
->lov_lock
);
533 if ((index
< lov
->lov_tgt_size
) && lov
->lov_tgts
[index
]) {
534 tgt
= lov
->lov_tgts
[index
];
535 CERROR("UUID %s already assigned at LOV target index %d\n",
536 obd_uuid2str(&tgt
->ltd_uuid
), index
);
537 mutex_unlock(&lov
->lov_lock
);
541 if (index
>= lov
->lov_tgt_size
) {
542 /* We need to reallocate the lov target array. */
543 struct lov_tgt_desc
**newtgts
, **old
= NULL
;
544 __u32 newsize
, oldsize
= 0;
546 newsize
= max_t(__u32
, lov
->lov_tgt_size
, 2);
547 while (newsize
< index
+ 1)
549 newtgts
= kcalloc(newsize
, sizeof(*newtgts
), GFP_NOFS
);
551 mutex_unlock(&lov
->lov_lock
);
555 if (lov
->lov_tgt_size
) {
556 memcpy(newtgts
, lov
->lov_tgts
, sizeof(*newtgts
) *
559 oldsize
= lov
->lov_tgt_size
;
562 lov
->lov_tgts
= newtgts
;
563 lov
->lov_tgt_size
= newsize
;
567 CDEBUG(D_CONFIG
, "tgts: %p size: %d\n",
568 lov
->lov_tgts
, lov
->lov_tgt_size
);
571 tgt
= kzalloc(sizeof(*tgt
), GFP_NOFS
);
573 mutex_unlock(&lov
->lov_lock
);
577 rc
= lov_ost_pool_add(&lov
->lov_packed
, index
, lov
->lov_tgt_size
);
579 mutex_unlock(&lov
->lov_lock
);
584 tgt
->ltd_uuid
= *uuidp
;
585 tgt
->ltd_obd
= tgt_obd
;
586 /* XXX - add a sanity check on the generation number. */
588 tgt
->ltd_index
= index
;
589 tgt
->ltd_activate
= active
;
590 lov
->lov_tgts
[index
] = tgt
;
591 if (index
>= lov
->desc
.ld_tgt_count
)
592 lov
->desc
.ld_tgt_count
= index
+ 1;
594 mutex_unlock(&lov
->lov_lock
);
596 CDEBUG(D_CONFIG
, "idx=%d ltd_gen=%d ld_tgt_count=%d\n",
597 index
, tgt
->ltd_gen
, lov
->desc
.ld_tgt_count
);
599 rc
= obd_notify(obd
, tgt_obd
, OBD_NOTIFY_CREATE
, &index
);
601 if (lov
->lov_connects
== 0) {
602 /* lov_connect hasn't been called yet. We'll do the
603 * lov_connect_obd on this target when that fn first runs,
604 * because we don't know the connect flags yet.
611 rc
= lov_connect_obd(obd
, index
, active
, &lov
->lov_ocd
);
615 /* connect to administrative disabled ost */
621 if (lov
->lov_cache
) {
622 rc
= obd_set_info_async(NULL
, tgt
->ltd_exp
,
623 sizeof(KEY_CACHE_SET
), KEY_CACHE_SET
,
624 sizeof(struct cl_client_cache
),
625 lov
->lov_cache
, NULL
);
630 rc
= lov_notify(obd
, tgt
->ltd_exp
->exp_obd
,
631 active
? OBD_NOTIFY_CONNECT
: OBD_NOTIFY_INACTIVE
,
636 CERROR("add failed (%d), deleting %s\n", rc
,
637 obd_uuid2str(&tgt
->ltd_uuid
));
638 lov_del_target(obd
, index
, NULL
, 0);
644 /* Schedule a target for deletion */
645 int lov_del_target(struct obd_device
*obd
, __u32 index
,
646 struct obd_uuid
*uuidp
, int gen
)
648 struct lov_obd
*lov
= &obd
->u
.lov
;
649 int count
= lov
->desc
.ld_tgt_count
;
652 if (index
>= count
) {
653 CERROR("LOV target index %d >= number of LOV OBDs %d.\n",
658 /* to make sure there's no ongoing lov_notify() now */
659 down_write(&lov
->lov_notify_lock
);
662 if (!lov
->lov_tgts
[index
]) {
663 CERROR("LOV target at index %d is not setup.\n", index
);
668 if (uuidp
&& !obd_uuid_equals(uuidp
, &lov
->lov_tgts
[index
]->ltd_uuid
)) {
669 CERROR("LOV target UUID %s at index %d doesn't match %s.\n",
670 lov_uuid2str(lov
, index
), index
,
671 obd_uuid2str(uuidp
));
676 CDEBUG(D_CONFIG
, "uuid: %s idx: %d gen: %d exp: %p active: %d\n",
677 lov_uuid2str(lov
, index
), index
,
678 lov
->lov_tgts
[index
]->ltd_gen
, lov
->lov_tgts
[index
]->ltd_exp
,
679 lov
->lov_tgts
[index
]->ltd_active
);
681 lov
->lov_tgts
[index
]->ltd_reap
= 1;
682 lov
->lov_death_row
++;
683 /* we really delete it from obd_putref */
686 up_write(&lov
->lov_notify_lock
);
691 static void __lov_del_obd(struct obd_device
*obd
, struct lov_tgt_desc
*tgt
)
693 struct obd_device
*osc_obd
;
696 LASSERT(tgt
->ltd_reap
);
698 osc_obd
= class_exp2obd(tgt
->ltd_exp
);
700 CDEBUG(D_CONFIG
, "Removing tgt %s : %s\n",
702 osc_obd
? osc_obd
->obd_name
: "<no obd>");
705 lov_disconnect_obd(obd
, tgt
);
709 /* Manual cleanup - no cleanup logs to clean up the osc's. We must
710 * do it ourselves. And we can't do it from lov_cleanup,
711 * because we just lost our only reference to it.
714 class_manual_cleanup(osc_obd
);
717 void lov_fix_desc_stripe_size(__u64
*val
)
719 if (*val
< LOV_MIN_STRIPE_SIZE
) {
721 LCONSOLE_INFO("Increasing default stripe size to minimum %u\n",
722 LOV_DESC_STRIPE_SIZE_DEFAULT
);
723 *val
= LOV_DESC_STRIPE_SIZE_DEFAULT
;
724 } else if (*val
& (LOV_MIN_STRIPE_SIZE
- 1)) {
725 *val
&= ~(LOV_MIN_STRIPE_SIZE
- 1);
726 LCONSOLE_WARN("Changing default stripe size to %llu (a multiple of %u)\n",
727 *val
, LOV_MIN_STRIPE_SIZE
);
731 void lov_fix_desc_stripe_count(__u32
*val
)
737 void lov_fix_desc_pattern(__u32
*val
)
739 /* from lov_setstripe */
740 if ((*val
!= 0) && (*val
!= LOV_PATTERN_RAID0
)) {
741 LCONSOLE_WARN("Unknown stripe pattern: %#x\n", *val
);
746 void lov_fix_desc_qos_maxage(__u32
*val
)
749 *val
= LOV_DESC_QOS_MAXAGE_DEFAULT
;
752 void lov_fix_desc(struct lov_desc
*desc
)
754 lov_fix_desc_stripe_size(&desc
->ld_default_stripe_size
);
755 lov_fix_desc_stripe_count(&desc
->ld_default_stripe_count
);
756 lov_fix_desc_pattern(&desc
->ld_pattern
);
757 lov_fix_desc_qos_maxage(&desc
->ld_qos_maxage
);
760 int lov_setup(struct obd_device
*obd
, struct lustre_cfg
*lcfg
)
762 struct lprocfs_static_vars lvars
= { NULL
};
763 struct lov_desc
*desc
;
764 struct lov_obd
*lov
= &obd
->u
.lov
;
767 if (LUSTRE_CFG_BUFLEN(lcfg
, 1) < 1) {
768 CERROR("LOV setup requires a descriptor\n");
772 desc
= (struct lov_desc
*)lustre_cfg_buf(lcfg
, 1);
774 if (sizeof(*desc
) > LUSTRE_CFG_BUFLEN(lcfg
, 1)) {
775 CERROR("descriptor size wrong: %d > %d\n",
776 (int)sizeof(*desc
), LUSTRE_CFG_BUFLEN(lcfg
, 1));
780 if (desc
->ld_magic
!= LOV_DESC_MAGIC
) {
781 if (desc
->ld_magic
== __swab32(LOV_DESC_MAGIC
)) {
782 CDEBUG(D_OTHER
, "%s: Swabbing lov desc %p\n",
783 obd
->obd_name
, desc
);
784 lustre_swab_lov_desc(desc
);
786 CERROR("%s: Bad lov desc magic: %#x\n",
787 obd
->obd_name
, desc
->ld_magic
);
794 desc
->ld_active_tgt_count
= 0;
796 lov
->lov_tgt_size
= 0;
798 mutex_init(&lov
->lov_lock
);
799 atomic_set(&lov
->lov_refcount
, 0);
800 lov
->lov_sp_me
= LUSTRE_SP_CLI
;
802 init_rwsem(&lov
->lov_notify_lock
);
804 lov
->lov_pools_hash_body
= cfs_hash_create("POOLS", HASH_POOLS_CUR_BITS
,
806 HASH_POOLS_BKT_BITS
, 0,
809 &pool_hash_operations
,
811 INIT_LIST_HEAD(&lov
->lov_pool_list
);
812 lov
->lov_pool_count
= 0;
813 rc
= lov_ost_pool_init(&lov
->lov_packed
, 0);
817 lprocfs_lov_init_vars(&lvars
);
818 lprocfs_obd_setup(obd
, lvars
.obd_vars
, lvars
.sysfs_vars
);
820 rc
= ldebugfs_seq_create(obd
->obd_debugfs_entry
, "target_obd",
821 0444, &lov_proc_target_fops
, obd
);
823 CWARN("Error adding the target_obd file\n");
825 lov
->lov_pool_debugfs_entry
= ldebugfs_register("pools",
826 obd
->obd_debugfs_entry
,
834 static int lov_precleanup(struct obd_device
*obd
, enum obd_cleanup_stage stage
)
836 struct lov_obd
*lov
= &obd
->u
.lov
;
839 case OBD_CLEANUP_EARLY
: {
842 for (i
= 0; i
< lov
->desc
.ld_tgt_count
; i
++) {
843 if (!lov
->lov_tgts
[i
] || !lov
->lov_tgts
[i
]->ltd_active
)
845 obd_precleanup(class_exp2obd(lov
->lov_tgts
[i
]->ltd_exp
),
857 static int lov_cleanup(struct obd_device
*obd
)
859 struct lov_obd
*lov
= &obd
->u
.lov
;
860 struct list_head
*pos
, *tmp
;
861 struct pool_desc
*pool
;
863 list_for_each_safe(pos
, tmp
, &lov
->lov_pool_list
) {
864 pool
= list_entry(pos
, struct pool_desc
, pool_list
);
865 /* free pool structs */
866 CDEBUG(D_INFO
, "delete pool %p\n", pool
);
867 /* In the function below, .hs_keycmp resolves to
868 * pool_hashkey_keycmp()
870 /* coverity[overrun-buffer-val] */
871 lov_pool_del(obd
, pool
->pool_name
);
873 cfs_hash_putref(lov
->lov_pools_hash_body
);
874 lov_ost_pool_free(&lov
->lov_packed
);
876 lprocfs_obd_cleanup(obd
);
881 for (i
= 0; i
< lov
->desc
.ld_tgt_count
; i
++) {
882 if (!lov
->lov_tgts
[i
])
885 /* Inactive targets may never have connected */
886 if (lov
->lov_tgts
[i
]->ltd_active
||
887 atomic_read(&lov
->lov_refcount
))
888 /* We should never get here - these
889 * should have been removed in the
892 CERROR("lov tgt %d not cleaned! deathrow=%d, lovrc=%d\n",
893 i
, lov
->lov_death_row
,
894 atomic_read(&lov
->lov_refcount
));
895 lov_del_target(obd
, i
, NULL
, 0);
898 kfree(lov
->lov_tgts
);
899 lov
->lov_tgt_size
= 0;
904 int lov_process_config_base(struct obd_device
*obd
, struct lustre_cfg
*lcfg
,
905 __u32
*indexp
, int *genp
)
907 struct obd_uuid obd_uuid
;
911 switch (cmd
= lcfg
->lcfg_command
) {
912 case LCFG_LOV_ADD_OBD
:
913 case LCFG_LOV_ADD_INA
:
914 case LCFG_LOV_DEL_OBD
: {
917 /* lov_modify_tgts add 0:lov_mdsA 1:ost1_UUID 2:0 3:1 */
918 if (LUSTRE_CFG_BUFLEN(lcfg
, 1) > sizeof(obd_uuid
.uuid
)) {
923 obd_str2uuid(&obd_uuid
, lustre_cfg_buf(lcfg
, 1));
925 rc
= kstrtoint(lustre_cfg_buf(lcfg
, 2), 10, indexp
);
928 rc
= kstrtoint(lustre_cfg_buf(lcfg
, 3), 10, genp
);
933 if (cmd
== LCFG_LOV_ADD_OBD
)
934 rc
= lov_add_target(obd
, &obd_uuid
, index
, gen
, 1);
935 else if (cmd
== LCFG_LOV_ADD_INA
)
936 rc
= lov_add_target(obd
, &obd_uuid
, index
, gen
, 0);
938 rc
= lov_del_target(obd
, index
, &obd_uuid
, gen
);
942 struct lprocfs_static_vars lvars
= { NULL
};
943 struct lov_desc
*desc
= &(obd
->u
.lov
.desc
);
950 lprocfs_lov_init_vars(&lvars
);
952 rc
= class_process_proc_param(PARAM_LOV
, lvars
.obd_vars
,
965 CERROR("Unknown command: %d\n", lcfg
->lcfg_command
);
975 static int lov_recreate(struct obd_export
*exp
, struct obdo
*src_oa
,
976 struct lov_stripe_md
**ea
, struct obd_trans_info
*oti
)
978 struct lov_stripe_md
*obj_mdp
, *lsm
;
979 struct lov_obd
*lov
= &exp
->exp_obd
->u
.lov
;
983 LASSERT(src_oa
->o_valid
& OBD_MD_FLFLAGS
&&
984 src_oa
->o_flags
& OBD_FL_RECREATE_OBJS
);
986 obj_mdp
= kzalloc(sizeof(*obj_mdp
), GFP_NOFS
);
990 ost_idx
= src_oa
->o_nlink
;
996 if (ost_idx
>= lov
->desc
.ld_tgt_count
||
997 !lov
->lov_tgts
[ost_idx
]) {
1002 for (i
= 0; i
< lsm
->lsm_stripe_count
; i
++) {
1003 struct lov_oinfo
*loi
= lsm
->lsm_oinfo
[i
];
1005 if (lov_oinfo_is_dummy(loi
))
1008 if (loi
->loi_ost_idx
== ost_idx
) {
1009 if (ostid_id(&loi
->loi_oi
) != ostid_id(&src_oa
->o_oi
)) {
1016 if (i
== lsm
->lsm_stripe_count
) {
1021 rc
= obd_create(NULL
, lov
->lov_tgts
[ost_idx
]->ltd_exp
,
1022 src_oa
, &obj_mdp
, oti
);
1028 /* the LOV expects oa->o_id to be set to the LOV object id */
1029 static int lov_create(const struct lu_env
*env
, struct obd_export
*exp
,
1030 struct obdo
*src_oa
, struct lov_stripe_md
**ea
,
1031 struct obd_trans_info
*oti
)
1033 struct lov_obd
*lov
;
1040 if ((src_oa
->o_valid
& OBD_MD_FLFLAGS
) &&
1041 src_oa
->o_flags
== OBD_FL_DELORPHAN
) {
1042 /* should be used with LOV anymore */
1046 lov
= &exp
->exp_obd
->u
.lov
;
1047 if (!lov
->desc
.ld_active_tgt_count
)
1050 obd_getref(exp
->exp_obd
);
1051 /* Recreate a specific object id at the given OST index */
1052 if ((src_oa
->o_valid
& OBD_MD_FLFLAGS
) &&
1053 (src_oa
->o_flags
& OBD_FL_RECREATE_OBJS
)) {
1054 rc
= lov_recreate(exp
, src_oa
, ea
, oti
);
1057 obd_putref(exp
->exp_obd
);
1061 #define ASSERT_LSM_MAGIC(lsmp) \
1064 LASSERTF(((lsmp)->lsm_magic == LOV_MAGIC_V1 || \
1065 (lsmp)->lsm_magic == LOV_MAGIC_V3), \
1066 "%p->lsm_magic=%x\n", (lsmp), (lsmp)->lsm_magic); \
1069 static int lov_destroy(const struct lu_env
*env
, struct obd_export
*exp
,
1070 struct obdo
*oa
, struct lov_stripe_md
*lsm
,
1071 struct obd_trans_info
*oti
, struct obd_export
*md_exp
)
1073 struct lov_request_set
*set
;
1074 struct obd_info oinfo
;
1075 struct lov_request
*req
;
1076 struct lov_obd
*lov
;
1077 int rc
= 0, err
= 0;
1079 ASSERT_LSM_MAGIC(lsm
);
1081 if (!exp
|| !exp
->exp_obd
)
1084 if (oa
->o_valid
& OBD_MD_FLCOOKIE
) {
1086 LASSERT(oti
->oti_logcookies
);
1089 lov
= &exp
->exp_obd
->u
.lov
;
1090 obd_getref(exp
->exp_obd
);
1091 rc
= lov_prep_destroy_set(exp
, &oinfo
, oa
, lsm
, oti
, &set
);
1095 list_for_each_entry(req
, &set
->set_list
, rq_link
) {
1096 if (oa
->o_valid
& OBD_MD_FLCOOKIE
)
1097 oti
->oti_logcookies
= set
->set_cookies
+ req
->rq_stripe
;
1099 err
= obd_destroy(env
, lov
->lov_tgts
[req
->rq_idx
]->ltd_exp
,
1100 req
->rq_oi
.oi_oa
, NULL
, oti
, NULL
);
1101 err
= lov_update_common_set(set
, req
, err
);
1103 CERROR("%s: destroying objid "DOSTID
" subobj "
1104 DOSTID
" on OST idx %d: rc = %d\n",
1105 exp
->exp_obd
->obd_name
, POSTID(&oa
->o_oi
),
1106 POSTID(&req
->rq_oi
.oi_oa
->o_oi
),
1114 rc
= lsm_op_find(lsm
->lsm_magic
)->lsm_destroy(lsm
, oa
, md_exp
);
1116 err
= lov_fini_destroy_set(set
);
1118 obd_putref(exp
->exp_obd
);
1119 return rc
? rc
: err
;
1122 static int lov_getattr_interpret(struct ptlrpc_request_set
*rqset
,
1125 struct lov_request_set
*lovset
= (struct lov_request_set
*)data
;
1128 /* don't do attribute merge if this async op failed */
1130 atomic_set(&lovset
->set_completes
, 0);
1131 err
= lov_fini_getattr_set(lovset
);
1132 return rc
? rc
: err
;
1135 static int lov_getattr_async(struct obd_export
*exp
, struct obd_info
*oinfo
,
1136 struct ptlrpc_request_set
*rqset
)
1138 struct lov_request_set
*lovset
;
1139 struct lov_obd
*lov
;
1140 struct lov_request
*req
;
1144 ASSERT_LSM_MAGIC(oinfo
->oi_md
);
1146 if (!exp
|| !exp
->exp_obd
)
1149 lov
= &exp
->exp_obd
->u
.lov
;
1151 rc
= lov_prep_getattr_set(exp
, oinfo
, &lovset
);
1155 CDEBUG(D_INFO
, "objid "DOSTID
": %ux%u byte stripes\n",
1156 POSTID(&oinfo
->oi_md
->lsm_oi
), oinfo
->oi_md
->lsm_stripe_count
,
1157 oinfo
->oi_md
->lsm_stripe_size
);
1159 list_for_each_entry(req
, &lovset
->set_list
, rq_link
) {
1160 CDEBUG(D_INFO
, "objid " DOSTID
"[%d] has subobj " DOSTID
" at idx%u\n",
1161 POSTID(&oinfo
->oi_oa
->o_oi
), req
->rq_stripe
,
1162 POSTID(&req
->rq_oi
.oi_oa
->o_oi
), req
->rq_idx
);
1163 rc
= obd_getattr_async(lov
->lov_tgts
[req
->rq_idx
]->ltd_exp
,
1164 &req
->rq_oi
, rqset
);
1166 CERROR("%s: getattr objid "DOSTID
" subobj"
1167 DOSTID
" on OST idx %d: rc = %d\n",
1168 exp
->exp_obd
->obd_name
,
1169 POSTID(&oinfo
->oi_oa
->o_oi
),
1170 POSTID(&req
->rq_oi
.oi_oa
->o_oi
),
1176 if (!list_empty(&rqset
->set_requests
)) {
1178 LASSERT(!rqset
->set_interpret
);
1179 rqset
->set_interpret
= lov_getattr_interpret
;
1180 rqset
->set_arg
= (void *)lovset
;
1185 atomic_set(&lovset
->set_completes
, 0);
1186 err
= lov_fini_getattr_set(lovset
);
1187 return rc
? rc
: err
;
1190 static int lov_setattr_interpret(struct ptlrpc_request_set
*rqset
,
1193 struct lov_request_set
*lovset
= (struct lov_request_set
*)data
;
1197 atomic_set(&lovset
->set_completes
, 0);
1198 err
= lov_fini_setattr_set(lovset
);
1199 return rc
? rc
: err
;
1202 /* If @oti is given, the request goes from MDS and responses from OSTs are not
1203 * needed. Otherwise, a client is waiting for responses.
1205 static int lov_setattr_async(struct obd_export
*exp
, struct obd_info
*oinfo
,
1206 struct obd_trans_info
*oti
,
1207 struct ptlrpc_request_set
*rqset
)
1209 struct lov_request_set
*set
;
1210 struct lov_request
*req
;
1211 struct lov_obd
*lov
;
1215 ASSERT_LSM_MAGIC(oinfo
->oi_md
);
1216 if (oinfo
->oi_oa
->o_valid
& OBD_MD_FLCOOKIE
) {
1218 LASSERT(oti
->oti_logcookies
);
1221 if (!exp
|| !exp
->exp_obd
)
1224 lov
= &exp
->exp_obd
->u
.lov
;
1225 rc
= lov_prep_setattr_set(exp
, oinfo
, oti
, &set
);
1229 CDEBUG(D_INFO
, "objid "DOSTID
": %ux%u byte stripes\n",
1230 POSTID(&oinfo
->oi_md
->lsm_oi
),
1231 oinfo
->oi_md
->lsm_stripe_count
,
1232 oinfo
->oi_md
->lsm_stripe_size
);
1234 list_for_each_entry(req
, &set
->set_list
, rq_link
) {
1235 if (oinfo
->oi_oa
->o_valid
& OBD_MD_FLCOOKIE
)
1236 oti
->oti_logcookies
= set
->set_cookies
+ req
->rq_stripe
;
1238 CDEBUG(D_INFO
, "objid " DOSTID
"[%d] has subobj " DOSTID
" at idx%u\n",
1239 POSTID(&oinfo
->oi_oa
->o_oi
), req
->rq_stripe
,
1240 POSTID(&req
->rq_oi
.oi_oa
->o_oi
), req
->rq_idx
);
1242 rc
= obd_setattr_async(lov
->lov_tgts
[req
->rq_idx
]->ltd_exp
,
1243 &req
->rq_oi
, oti
, rqset
);
1245 CERROR("error: setattr objid "DOSTID
" subobj"
1246 DOSTID
" on OST idx %d: rc = %d\n",
1247 POSTID(&set
->set_oi
->oi_oa
->o_oi
),
1248 POSTID(&req
->rq_oi
.oi_oa
->o_oi
),
1254 /* If we are not waiting for responses on async requests, return. */
1255 if (rc
|| !rqset
|| list_empty(&rqset
->set_requests
)) {
1259 atomic_set(&set
->set_completes
, 0);
1260 err
= lov_fini_setattr_set(set
);
1261 return rc
? rc
: err
;
1264 LASSERT(!rqset
->set_interpret
);
1265 rqset
->set_interpret
= lov_setattr_interpret
;
1266 rqset
->set_arg
= (void *)set
;
1271 /* find any ldlm lock of the inode in lov
1276 static int lov_find_cbdata(struct obd_export
*exp
,
1277 struct lov_stripe_md
*lsm
, ldlm_iterator_t it
,
1280 struct lov_obd
*lov
;
1283 ASSERT_LSM_MAGIC(lsm
);
1285 if (!exp
|| !exp
->exp_obd
)
1288 lov
= &exp
->exp_obd
->u
.lov
;
1289 for (i
= 0; i
< lsm
->lsm_stripe_count
; i
++) {
1290 struct lov_stripe_md submd
;
1291 struct lov_oinfo
*loi
= lsm
->lsm_oinfo
[i
];
1293 if (lov_oinfo_is_dummy(loi
))
1296 if (!lov
->lov_tgts
[loi
->loi_ost_idx
]) {
1297 CDEBUG(D_HA
, "lov idx %d NULL\n", loi
->loi_ost_idx
);
1301 submd
.lsm_oi
= loi
->loi_oi
;
1302 submd
.lsm_stripe_count
= 0;
1303 rc
= obd_find_cbdata(lov
->lov_tgts
[loi
->loi_ost_idx
]->ltd_exp
,
1311 int lov_statfs_interpret(struct ptlrpc_request_set
*rqset
, void *data
, int rc
)
1313 struct lov_request_set
*lovset
= (struct lov_request_set
*)data
;
1317 atomic_set(&lovset
->set_completes
, 0);
1319 err
= lov_fini_statfs_set(lovset
);
1320 return rc
? rc
: err
;
1323 static int lov_statfs_async(struct obd_export
*exp
, struct obd_info
*oinfo
,
1324 __u64 max_age
, struct ptlrpc_request_set
*rqset
)
1326 struct obd_device
*obd
= class_exp2obd(exp
);
1327 struct lov_request_set
*set
;
1328 struct lov_request
*req
;
1329 struct lov_obd
*lov
;
1332 LASSERT(oinfo
->oi_osfs
);
1335 rc
= lov_prep_statfs_set(obd
, oinfo
, &set
);
1339 list_for_each_entry(req
, &set
->set_list
, rq_link
) {
1340 rc
= obd_statfs_async(lov
->lov_tgts
[req
->rq_idx
]->ltd_exp
,
1341 &req
->rq_oi
, max_age
, rqset
);
1346 if (rc
|| list_empty(&rqset
->set_requests
)) {
1350 atomic_set(&set
->set_completes
, 0);
1351 err
= lov_fini_statfs_set(set
);
1352 return rc
? rc
: err
;
1355 LASSERT(!rqset
->set_interpret
);
1356 rqset
->set_interpret
= lov_statfs_interpret
;
1357 rqset
->set_arg
= (void *)set
;
1361 static int lov_statfs(const struct lu_env
*env
, struct obd_export
*exp
,
1362 struct obd_statfs
*osfs
, __u64 max_age
, __u32 flags
)
1364 struct ptlrpc_request_set
*set
= NULL
;
1365 struct obd_info oinfo
= { };
1368 /* for obdclass we forbid using obd_statfs_rqset, but prefer using async
1371 set
= ptlrpc_prep_set();
1375 oinfo
.oi_osfs
= osfs
;
1376 oinfo
.oi_flags
= flags
;
1377 rc
= lov_statfs_async(exp
, &oinfo
, max_age
, set
);
1379 rc
= ptlrpc_set_wait(set
);
1380 ptlrpc_set_destroy(set
);
1385 static int lov_iocontrol(unsigned int cmd
, struct obd_export
*exp
, int len
,
1386 void *karg
, void __user
*uarg
)
1388 struct obd_device
*obddev
= class_exp2obd(exp
);
1389 struct lov_obd
*lov
= &obddev
->u
.lov
;
1390 int i
= 0, rc
= 0, count
= lov
->desc
.ld_tgt_count
;
1391 struct obd_uuid
*uuidp
;
1394 case IOC_OBD_STATFS
: {
1395 struct obd_ioctl_data
*data
= karg
;
1396 struct obd_device
*osc_obd
;
1397 struct obd_statfs stat_buf
= {0};
1401 memcpy(&index
, data
->ioc_inlbuf2
, sizeof(__u32
));
1405 if (!lov
->lov_tgts
[index
])
1406 /* Try again with the next index */
1408 if (!lov
->lov_tgts
[index
]->ltd_active
)
1411 osc_obd
= class_exp2obd(lov
->lov_tgts
[index
]->ltd_exp
);
1416 if (copy_to_user(data
->ioc_pbuf2
, obd2cli_tgt(osc_obd
),
1417 min((int)data
->ioc_plen2
,
1418 (int)sizeof(struct obd_uuid
))))
1421 memcpy(&flags
, data
->ioc_inlbuf1
, sizeof(__u32
));
1422 flags
= flags
& LL_STATFS_NODELAY
? OBD_STATFS_NODELAY
: 0;
1424 /* got statfs data */
1425 rc
= obd_statfs(NULL
, lov
->lov_tgts
[index
]->ltd_exp
, &stat_buf
,
1426 cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS
),
1430 if (copy_to_user(data
->ioc_pbuf1
, &stat_buf
,
1431 min((int)data
->ioc_plen1
,
1432 (int)sizeof(stat_buf
))))
1436 case OBD_IOC_LOV_GET_CONFIG
: {
1437 struct obd_ioctl_data
*data
;
1438 struct lov_desc
*desc
;
1443 if (obd_ioctl_getdata(&buf
, &len
, uarg
))
1446 data
= (struct obd_ioctl_data
*)buf
;
1448 if (sizeof(*desc
) > data
->ioc_inllen1
) {
1449 obd_ioctl_freedata(buf
, len
);
1453 if (sizeof(uuidp
->uuid
) * count
> data
->ioc_inllen2
) {
1454 obd_ioctl_freedata(buf
, len
);
1458 if (sizeof(__u32
) * count
> data
->ioc_inllen3
) {
1459 obd_ioctl_freedata(buf
, len
);
1463 desc
= (struct lov_desc
*)data
->ioc_inlbuf1
;
1464 memcpy(desc
, &(lov
->desc
), sizeof(*desc
));
1466 uuidp
= (struct obd_uuid
*)data
->ioc_inlbuf2
;
1467 genp
= (__u32
*)data
->ioc_inlbuf3
;
1468 /* the uuid will be empty for deleted OSTs */
1469 for (i
= 0; i
< count
; i
++, uuidp
++, genp
++) {
1470 if (!lov
->lov_tgts
[i
])
1472 *uuidp
= lov
->lov_tgts
[i
]->ltd_uuid
;
1473 *genp
= lov
->lov_tgts
[i
]->ltd_gen
;
1476 if (copy_to_user(uarg
, buf
, len
))
1478 obd_ioctl_freedata(buf
, len
);
1481 case LL_IOC_LOV_GETSTRIPE
:
1482 rc
= lov_getstripe(exp
, karg
, uarg
);
1484 case OBD_IOC_QUOTACTL
: {
1485 struct if_quotactl
*qctl
= karg
;
1486 struct lov_tgt_desc
*tgt
= NULL
;
1487 struct obd_quotactl
*oqctl
;
1489 if (qctl
->qc_valid
== QC_OSTIDX
) {
1490 if (count
<= qctl
->qc_idx
)
1493 tgt
= lov
->lov_tgts
[qctl
->qc_idx
];
1494 if (!tgt
|| !tgt
->ltd_exp
)
1496 } else if (qctl
->qc_valid
== QC_UUID
) {
1497 for (i
= 0; i
< count
; i
++) {
1498 tgt
= lov
->lov_tgts
[i
];
1500 !obd_uuid_equals(&tgt
->ltd_uuid
,
1516 LASSERT(tgt
&& tgt
->ltd_exp
);
1517 oqctl
= kzalloc(sizeof(*oqctl
), GFP_NOFS
);
1521 QCTL_COPY(oqctl
, qctl
);
1522 rc
= obd_quotactl(tgt
->ltd_exp
, oqctl
);
1524 QCTL_COPY(qctl
, oqctl
);
1525 qctl
->qc_valid
= QC_OSTIDX
;
1526 qctl
->obd_uuid
= tgt
->ltd_uuid
;
1537 for (i
= 0; i
< count
; i
++) {
1539 struct obd_device
*osc_obd
;
1541 /* OST was disconnected */
1542 if (!lov
->lov_tgts
[i
] || !lov
->lov_tgts
[i
]->ltd_exp
)
1545 /* ll_umount_begin() sets force flag but for lov, not
1546 * osc. Let's pass it through
1548 osc_obd
= class_exp2obd(lov
->lov_tgts
[i
]->ltd_exp
);
1549 osc_obd
->obd_force
= obddev
->obd_force
;
1550 err
= obd_iocontrol(cmd
, lov
->lov_tgts
[i
]->ltd_exp
,
1552 if (err
== -ENODATA
&& cmd
== OBD_IOC_POLL_QUOTACHECK
)
1555 if (lov
->lov_tgts
[i
]->ltd_active
) {
1556 CDEBUG(err
== -ENOTTY
?
1557 D_IOCTL
: D_WARNING
,
1558 "iocontrol OSC %s on OST idx %d cmd %x: err = %d\n",
1559 lov_uuid2str(lov
, i
),
1576 #define FIEMAP_BUFFER_SIZE 4096
1579 * Non-zero fe_logical indicates that this is a continuation FIEMAP
1580 * call. The local end offset and the device are sent in the first
1581 * fm_extent. This function calculates the stripe number from the index.
1582 * This function returns a stripe_no on which mapping is to be restarted.
1584 * This function returns fm_end_offset which is the in-OST offset at which
1585 * mapping should be restarted. If fm_end_offset=0 is returned then caller
1586 * will re-calculate proper offset in next stripe.
1587 * Note that the first extent is passed to lov_get_info via the value field.
1589 * \param fiemap fiemap request header
1590 * \param lsm striping information for the file
1591 * \param fm_start logical start of mapping
1592 * \param fm_end logical end of mapping
1593 * \param start_stripe starting stripe will be returned in this
1595 static u64
fiemap_calc_fm_end_offset(struct ll_user_fiemap
*fiemap
,
1596 struct lov_stripe_md
*lsm
, u64 fm_start
,
1597 u64 fm_end
, int *start_stripe
)
1599 u64 local_end
= fiemap
->fm_extents
[0].fe_logical
;
1600 u64 lun_start
, lun_end
;
1602 int stripe_no
= -1, i
;
1604 if (fiemap
->fm_extent_count
== 0 ||
1605 fiemap
->fm_extents
[0].fe_logical
== 0)
1608 /* Find out stripe_no from ost_index saved in the fe_device */
1609 for (i
= 0; i
< lsm
->lsm_stripe_count
; i
++) {
1610 struct lov_oinfo
*oinfo
= lsm
->lsm_oinfo
[i
];
1612 if (lov_oinfo_is_dummy(oinfo
))
1615 if (oinfo
->loi_ost_idx
== fiemap
->fm_extents
[0].fe_device
) {
1620 if (stripe_no
== -1)
1623 /* If we have finished mapping on previous device, shift logical
1624 * offset to start of next device
1626 if ((lov_stripe_intersects(lsm
, stripe_no
, fm_start
, fm_end
,
1627 &lun_start
, &lun_end
)) != 0 &&
1628 local_end
< lun_end
) {
1629 fm_end_offset
= local_end
;
1630 *start_stripe
= stripe_no
;
1632 /* This is a special value to indicate that caller should
1633 * calculate offset in next stripe.
1636 *start_stripe
= (stripe_no
+ 1) % lsm
->lsm_stripe_count
;
1639 return fm_end_offset
;
1643 * We calculate on which OST the mapping will end. If the length of mapping
1644 * is greater than (stripe_size * stripe_count) then the last_stripe will
1645 * will be one just before start_stripe. Else we check if the mapping
1646 * intersects each OST and find last_stripe.
1647 * This function returns the last_stripe and also sets the stripe_count
1648 * over which the mapping is spread
1650 * \param lsm striping information for the file
1651 * \param fm_start logical start of mapping
1652 * \param fm_end logical end of mapping
1653 * \param start_stripe starting stripe of the mapping
1654 * \param stripe_count the number of stripes across which to map is returned
1656 * \retval last_stripe return the last stripe of the mapping
1658 static int fiemap_calc_last_stripe(struct lov_stripe_md
*lsm
, u64 fm_start
,
1659 u64 fm_end
, int start_stripe
,
1663 u64 obd_start
, obd_end
;
1666 if (fm_end
- fm_start
> lsm
->lsm_stripe_size
* lsm
->lsm_stripe_count
) {
1667 last_stripe
= start_stripe
< 1 ? lsm
->lsm_stripe_count
- 1 :
1669 *stripe_count
= lsm
->lsm_stripe_count
;
1671 for (j
= 0, i
= start_stripe
; j
< lsm
->lsm_stripe_count
;
1672 i
= (i
+ 1) % lsm
->lsm_stripe_count
, j
++) {
1673 if ((lov_stripe_intersects(lsm
, i
, fm_start
, fm_end
,
1674 &obd_start
, &obd_end
)) == 0)
1678 last_stripe
= (start_stripe
+ j
- 1) % lsm
->lsm_stripe_count
;
1685 * Set fe_device and copy extents from local buffer into main return buffer.
1687 * \param fiemap fiemap request header
1688 * \param lcl_fm_ext array of local fiemap extents to be copied
1689 * \param ost_index OST index to be written into the fm_device field for each
1691 * \param ext_count number of extents to be copied
1692 * \param current_extent where to start copying in main extent array
1694 static void fiemap_prepare_and_copy_exts(struct ll_user_fiemap
*fiemap
,
1695 struct ll_fiemap_extent
*lcl_fm_ext
,
1696 int ost_index
, unsigned int ext_count
,
1702 for (ext
= 0; ext
< ext_count
; ext
++) {
1703 lcl_fm_ext
[ext
].fe_device
= ost_index
;
1704 lcl_fm_ext
[ext
].fe_flags
|= FIEMAP_EXTENT_NET
;
1707 /* Copy fm_extent's from fm_local to return buffer */
1708 to
= (char *)fiemap
+ fiemap_count_to_size(current_extent
);
1709 memcpy(to
, lcl_fm_ext
, ext_count
* sizeof(struct ll_fiemap_extent
));
1713 * Break down the FIEMAP request and send appropriate calls to individual OSTs.
1714 * This also handles the restarting of FIEMAP calls in case mapping overflows
1715 * the available number of extents in single call.
1717 static int lov_fiemap(struct lov_obd
*lov
, __u32 keylen
, void *key
,
1718 __u32
*vallen
, void *val
, struct lov_stripe_md
*lsm
)
1720 struct ll_fiemap_info_key
*fm_key
= key
;
1721 struct ll_user_fiemap
*fiemap
= val
;
1722 struct ll_user_fiemap
*fm_local
= NULL
;
1723 struct ll_fiemap_extent
*lcl_fm_ext
;
1725 unsigned int get_num_extents
= 0;
1726 int ost_index
= 0, actual_start_stripe
, start_stripe
;
1727 u64 fm_start
, fm_end
, fm_length
, fm_end_offset
;
1729 int current_extent
= 0, rc
= 0, i
;
1730 int ost_eof
= 0; /* EOF for object */
1731 int ost_done
= 0; /* done with required mapping for this OST? */
1733 int cur_stripe
= 0, cur_stripe_wrap
= 0, stripe_count
;
1734 unsigned int buffer_size
= FIEMAP_BUFFER_SIZE
;
1736 if (!lsm_has_objects(lsm
)) {
1741 if (fiemap_count_to_size(fm_key
->fiemap
.fm_extent_count
) < buffer_size
)
1742 buffer_size
= fiemap_count_to_size(fm_key
->fiemap
.fm_extent_count
);
1744 fm_local
= libcfs_kvzalloc(buffer_size
, GFP_NOFS
);
1749 lcl_fm_ext
= &fm_local
->fm_extents
[0];
1751 count_local
= fiemap_size_to_count(buffer_size
);
1753 memcpy(fiemap
, &fm_key
->fiemap
, sizeof(*fiemap
));
1754 fm_start
= fiemap
->fm_start
;
1755 fm_length
= fiemap
->fm_length
;
1756 /* Calculate start stripe, last stripe and length of mapping */
1757 actual_start_stripe
= start_stripe
= lov_stripe_number(lsm
, fm_start
);
1758 fm_end
= (fm_length
== ~0ULL ? fm_key
->oa
.o_size
:
1759 fm_start
+ fm_length
- 1);
1760 /* If fm_length != ~0ULL but fm_start+fm_length-1 exceeds file size */
1761 if (fm_end
> fm_key
->oa
.o_size
)
1762 fm_end
= fm_key
->oa
.o_size
;
1764 last_stripe
= fiemap_calc_last_stripe(lsm
, fm_start
, fm_end
,
1765 actual_start_stripe
,
1768 fm_end_offset
= fiemap_calc_fm_end_offset(fiemap
, lsm
, fm_start
,
1769 fm_end
, &start_stripe
);
1770 if (fm_end_offset
== -EINVAL
) {
1775 if (fiemap_count_to_size(fiemap
->fm_extent_count
) > *vallen
)
1776 fiemap
->fm_extent_count
= fiemap_size_to_count(*vallen
);
1777 if (fiemap
->fm_extent_count
== 0) {
1778 get_num_extents
= 1;
1781 /* Check each stripe */
1782 for (cur_stripe
= start_stripe
, i
= 0; i
< stripe_count
;
1783 i
++, cur_stripe
= (cur_stripe
+ 1) % lsm
->lsm_stripe_count
) {
1784 u64 req_fm_len
; /* Stores length of required mapping */
1785 u64 len_mapped_single_call
;
1786 u64 lun_start
, lun_end
, obd_object_end
;
1787 unsigned int ext_count
;
1789 cur_stripe_wrap
= cur_stripe
;
1791 /* Find out range of mapping on this stripe */
1792 if ((lov_stripe_intersects(lsm
, cur_stripe
, fm_start
, fm_end
,
1793 &lun_start
, &obd_object_end
)) == 0)
1796 if (lov_oinfo_is_dummy(lsm
->lsm_oinfo
[cur_stripe
])) {
1801 /* If this is a continuation FIEMAP call and we are on
1802 * starting stripe then lun_start needs to be set to
1805 if (fm_end_offset
!= 0 && cur_stripe
== start_stripe
)
1806 lun_start
= fm_end_offset
;
1808 if (fm_length
!= ~0ULL) {
1809 /* Handle fm_start + fm_length overflow */
1810 if (fm_start
+ fm_length
< fm_start
)
1811 fm_length
= ~0ULL - fm_start
;
1812 lun_end
= lov_size_to_stripe(lsm
, fm_start
+ fm_length
,
1818 if (lun_start
== lun_end
)
1821 req_fm_len
= obd_object_end
- lun_start
;
1822 fm_local
->fm_length
= 0;
1823 len_mapped_single_call
= 0;
1825 /* If the output buffer is very large and the objects have many
1826 * extents we may need to loop on a single OST repeatedly
1831 if (get_num_extents
== 0) {
1832 /* Don't get too many extents. */
1833 if (current_extent
+ count_local
>
1834 fiemap
->fm_extent_count
)
1835 count_local
= fiemap
->fm_extent_count
-
1839 lun_start
+= len_mapped_single_call
;
1840 fm_local
->fm_length
= req_fm_len
- len_mapped_single_call
;
1841 req_fm_len
= fm_local
->fm_length
;
1842 fm_local
->fm_extent_count
= count_local
;
1843 fm_local
->fm_mapped_extents
= 0;
1844 fm_local
->fm_flags
= fiemap
->fm_flags
;
1846 fm_key
->oa
.o_oi
= lsm
->lsm_oinfo
[cur_stripe
]->loi_oi
;
1847 ost_index
= lsm
->lsm_oinfo
[cur_stripe
]->loi_ost_idx
;
1849 if (ost_index
< 0 ||
1850 ost_index
>= lov
->desc
.ld_tgt_count
) {
1855 /* If OST is inactive, return extent with UNKNOWN flag */
1856 if (!lov
->lov_tgts
[ost_index
]->ltd_active
) {
1857 fm_local
->fm_flags
|= FIEMAP_EXTENT_LAST
;
1858 fm_local
->fm_mapped_extents
= 1;
1860 lcl_fm_ext
[0].fe_logical
= lun_start
;
1861 lcl_fm_ext
[0].fe_length
= obd_object_end
-
1863 lcl_fm_ext
[0].fe_flags
|= FIEMAP_EXTENT_UNKNOWN
;
1868 fm_local
->fm_start
= lun_start
;
1869 fm_local
->fm_flags
&= ~FIEMAP_FLAG_DEVICE_ORDER
;
1870 memcpy(&fm_key
->fiemap
, fm_local
, sizeof(*fm_local
));
1871 *vallen
= fiemap_count_to_size(fm_local
->fm_extent_count
);
1872 rc
= obd_get_info(NULL
,
1873 lov
->lov_tgts
[ost_index
]->ltd_exp
,
1874 keylen
, key
, vallen
, fm_local
, lsm
);
1879 ext_count
= fm_local
->fm_mapped_extents
;
1880 if (ext_count
== 0) {
1882 /* If last stripe has hole at the end,
1883 * then we need to return
1885 if (cur_stripe_wrap
== last_stripe
) {
1886 fiemap
->fm_mapped_extents
= 0;
1892 /* If we just need num of extents then go to next device */
1893 if (get_num_extents
) {
1894 current_extent
+= ext_count
;
1898 len_mapped_single_call
= lcl_fm_ext
[ext_count
-1].fe_logical
-
1899 lun_start
+ lcl_fm_ext
[ext_count
- 1].fe_length
;
1901 /* Have we finished mapping on this device? */
1902 if (req_fm_len
<= len_mapped_single_call
)
1905 /* Clear the EXTENT_LAST flag which can be present on
1908 if (lcl_fm_ext
[ext_count
-1].fe_flags
& FIEMAP_EXTENT_LAST
)
1909 lcl_fm_ext
[ext_count
- 1].fe_flags
&=
1910 ~FIEMAP_EXTENT_LAST
;
1912 curr_loc
= lov_stripe_size(lsm
,
1913 lcl_fm_ext
[ext_count
- 1].fe_logical
+
1914 lcl_fm_ext
[ext_count
- 1].fe_length
,
1916 if (curr_loc
>= fm_key
->oa
.o_size
)
1919 fiemap_prepare_and_copy_exts(fiemap
, lcl_fm_ext
,
1920 ost_index
, ext_count
,
1923 current_extent
+= ext_count
;
1925 /* Ran out of available extents? */
1926 if (current_extent
>= fiemap
->fm_extent_count
)
1928 } while (ost_done
== 0 && ost_eof
== 0);
1930 if (cur_stripe_wrap
== last_stripe
)
1935 /* Indicate that we are returning device offsets unless file just has
1938 if (lsm
->lsm_stripe_count
> 1)
1939 fiemap
->fm_flags
|= FIEMAP_FLAG_DEVICE_ORDER
;
1941 if (get_num_extents
)
1942 goto skip_last_device_calc
;
1944 /* Check if we have reached the last stripe and whether mapping for that
1947 if (cur_stripe_wrap
== last_stripe
) {
1948 if (ost_done
|| ost_eof
)
1949 fiemap
->fm_extents
[current_extent
- 1].fe_flags
|=
1953 skip_last_device_calc
:
1954 fiemap
->fm_mapped_extents
= current_extent
;
1961 static int lov_get_info(const struct lu_env
*env
, struct obd_export
*exp
,
1962 __u32 keylen
, void *key
, __u32
*vallen
, void *val
,
1963 struct lov_stripe_md
*lsm
)
1965 struct obd_device
*obddev
= class_exp2obd(exp
);
1966 struct lov_obd
*lov
= &obddev
->u
.lov
;
1969 if (!vallen
|| !val
)
1974 if (KEY_IS(KEY_LOCK_TO_STRIPE
)) {
1977 struct ldlm_lock
*lock
;
1979 struct ldlm_res_id
*res_id
= &data
->lock
->l_resource
->lr_name
;
1980 struct lov_oinfo
*loi
;
1981 __u32
*stripe
= val
;
1983 if (*vallen
< sizeof(*stripe
)) {
1987 *vallen
= sizeof(*stripe
);
1989 /* XXX This is another one of those bits that will need to
1990 * change if we ever actually support nested LOVs. It uses
1991 * the lock's export to find out which stripe it is.
1993 /* XXX - it's assumed all the locks for deleted OSTs have
1994 * been cancelled. Also, the export for deleted OSTs will
1995 * be NULL and won't match the lock's export.
1997 for (i
= 0; i
< lsm
->lsm_stripe_count
; i
++) {
1998 loi
= lsm
->lsm_oinfo
[i
];
1999 if (lov_oinfo_is_dummy(loi
))
2002 if (!lov
->lov_tgts
[loi
->loi_ost_idx
])
2004 if (lov
->lov_tgts
[loi
->loi_ost_idx
]->ltd_exp
==
2005 data
->lock
->l_conn_export
&&
2006 ostid_res_name_eq(&loi
->loi_oi
, res_id
)) {
2012 LDLM_ERROR(data
->lock
, "lock on inode without such object");
2013 dump_lsm(D_ERROR
, lsm
);
2016 } else if (KEY_IS(KEY_LAST_ID
)) {
2017 struct obd_id_info
*info
= val
;
2018 __u32 size
= sizeof(u64
);
2019 struct lov_tgt_desc
*tgt
;
2021 LASSERT(*vallen
== sizeof(struct obd_id_info
));
2022 tgt
= lov
->lov_tgts
[info
->idx
];
2024 if (!tgt
|| !tgt
->ltd_active
) {
2029 rc
= obd_get_info(env
, tgt
->ltd_exp
, keylen
, key
,
2030 &size
, info
->data
, NULL
);
2033 } else if (KEY_IS(KEY_LOVDESC
)) {
2034 struct lov_desc
*desc_ret
= val
;
2035 *desc_ret
= lov
->desc
;
2039 } else if (KEY_IS(KEY_FIEMAP
)) {
2040 rc
= lov_fiemap(lov
, keylen
, key
, vallen
, val
, lsm
);
2042 } else if (KEY_IS(KEY_CONNECT_FLAG
)) {
2043 struct lov_tgt_desc
*tgt
;
2044 __u64 ost_idx
= *((__u64
*)val
);
2046 LASSERT(*vallen
== sizeof(__u64
));
2047 LASSERT(ost_idx
< lov
->desc
.ld_tgt_count
);
2048 tgt
= lov
->lov_tgts
[ost_idx
];
2050 if (!tgt
|| !tgt
->ltd_exp
) {
2055 *((__u64
*)val
) = exp_connect_flags(tgt
->ltd_exp
);
2058 } else if (KEY_IS(KEY_TGT_COUNT
)) {
2059 *((int *)val
) = lov
->desc
.ld_tgt_count
;
2071 static int lov_set_info_async(const struct lu_env
*env
, struct obd_export
*exp
,
2072 u32 keylen
, void *key
, u32 vallen
,
2073 void *val
, struct ptlrpc_request_set
*set
)
2075 struct obd_device
*obddev
= class_exp2obd(exp
);
2076 struct lov_obd
*lov
= &obddev
->u
.lov
;
2079 struct lov_tgt_desc
*tgt
;
2080 unsigned incr
, check_uuid
,
2081 do_inactive
, no_set
;
2082 unsigned next_id
= 0, mds_con
= 0;
2084 incr
= check_uuid
= do_inactive
= no_set
= 0;
2087 set
= ptlrpc_prep_set();
2093 count
= lov
->desc
.ld_tgt_count
;
2095 if (KEY_IS(KEY_NEXT_ID
)) {
2096 count
= vallen
/ sizeof(struct obd_id_info
);
2097 vallen
= sizeof(u64
);
2098 incr
= sizeof(struct obd_id_info
);
2101 } else if (KEY_IS(KEY_CHECKSUM
)) {
2103 } else if (KEY_IS(KEY_EVICT_BY_NID
)) {
2104 /* use defaults: do_inactive = incr = 0; */
2105 } else if (KEY_IS(KEY_MDS_CONN
)) {
2107 } else if (KEY_IS(KEY_CACHE_SET
)) {
2108 LASSERT(!lov
->lov_cache
);
2109 lov
->lov_cache
= val
;
2113 for (i
= 0; i
< count
; i
++, val
= (char *)val
+ incr
) {
2115 tgt
= lov
->lov_tgts
[((struct obd_id_info
*)val
)->idx
];
2117 tgt
= lov
->lov_tgts
[i
];
2118 /* OST was disconnected */
2119 if (!tgt
|| !tgt
->ltd_exp
)
2122 /* OST is inactive and we don't want inactive OSCs */
2123 if (!tgt
->ltd_active
&& !do_inactive
)
2127 struct mds_group_info
*mgi
;
2129 LASSERT(vallen
== sizeof(*mgi
));
2130 mgi
= (struct mds_group_info
*)val
;
2132 /* Only want a specific OSC */
2133 if (mgi
->uuid
&& !obd_uuid_equals(mgi
->uuid
,
2137 err
= obd_set_info_async(env
, tgt
->ltd_exp
,
2138 keylen
, key
, sizeof(int),
2140 } else if (next_id
) {
2141 err
= obd_set_info_async(env
, tgt
->ltd_exp
,
2142 keylen
, key
, vallen
,
2143 ((struct obd_id_info
*)val
)->data
, set
);
2145 /* Only want a specific OSC */
2147 !obd_uuid_equals(val
, &tgt
->ltd_uuid
))
2150 err
= obd_set_info_async(env
, tgt
->ltd_exp
,
2151 keylen
, key
, vallen
, val
, set
);
2160 err
= ptlrpc_set_wait(set
);
2163 ptlrpc_set_destroy(set
);
2168 void lov_stripe_lock(struct lov_stripe_md
*md
)
2169 __acquires(&md
->lsm_lock
)
2171 LASSERT(md
->lsm_lock_owner
!= current_pid());
2172 spin_lock(&md
->lsm_lock
);
2173 LASSERT(md
->lsm_lock_owner
== 0);
2174 md
->lsm_lock_owner
= current_pid();
2176 EXPORT_SYMBOL(lov_stripe_lock
);
2178 void lov_stripe_unlock(struct lov_stripe_md
*md
)
2179 __releases(&md
->lsm_lock
)
2181 LASSERT(md
->lsm_lock_owner
== current_pid());
2182 md
->lsm_lock_owner
= 0;
2183 spin_unlock(&md
->lsm_lock
);
2185 EXPORT_SYMBOL(lov_stripe_unlock
);
2187 static int lov_quotactl(struct obd_device
*obd
, struct obd_export
*exp
,
2188 struct obd_quotactl
*oqctl
)
2190 struct lov_obd
*lov
= &obd
->u
.lov
;
2191 struct lov_tgt_desc
*tgt
;
2193 __u64 bhardlimit
= 0;
2196 if (oqctl
->qc_cmd
!= LUSTRE_Q_QUOTAON
&&
2197 oqctl
->qc_cmd
!= LUSTRE_Q_QUOTAOFF
&&
2198 oqctl
->qc_cmd
!= Q_GETOQUOTA
&&
2199 oqctl
->qc_cmd
!= Q_INITQUOTA
&&
2200 oqctl
->qc_cmd
!= LUSTRE_Q_SETQUOTA
&&
2201 oqctl
->qc_cmd
!= Q_FINVALIDATE
) {
2202 CERROR("bad quota opc %x for lov obd", oqctl
->qc_cmd
);
2208 for (i
= 0; i
< lov
->desc
.ld_tgt_count
; i
++) {
2211 tgt
= lov
->lov_tgts
[i
];
2216 if (!tgt
->ltd_active
|| tgt
->ltd_reap
) {
2217 if (oqctl
->qc_cmd
== Q_GETOQUOTA
&&
2218 lov
->lov_tgts
[i
]->ltd_activate
) {
2220 CERROR("ost %d is inactive\n", i
);
2222 CDEBUG(D_HA
, "ost %d is inactive\n", i
);
2227 err
= obd_quotactl(tgt
->ltd_exp
, oqctl
);
2229 if (tgt
->ltd_active
&& !rc
)
2234 if (oqctl
->qc_cmd
== Q_GETOQUOTA
) {
2235 curspace
+= oqctl
->qc_dqblk
.dqb_curspace
;
2236 bhardlimit
+= oqctl
->qc_dqblk
.dqb_bhardlimit
;
2241 if (oqctl
->qc_cmd
== Q_GETOQUOTA
) {
2242 oqctl
->qc_dqblk
.dqb_curspace
= curspace
;
2243 oqctl
->qc_dqblk
.dqb_bhardlimit
= bhardlimit
;
2248 static int lov_quotacheck(struct obd_device
*obd
, struct obd_export
*exp
,
2249 struct obd_quotactl
*oqctl
)
2251 struct lov_obd
*lov
= &obd
->u
.lov
;
2256 for (i
= 0; i
< lov
->desc
.ld_tgt_count
; i
++) {
2257 if (!lov
->lov_tgts
[i
])
2260 /* Skip quota check on the administratively disabled OSTs. */
2261 if (!lov
->lov_tgts
[i
]->ltd_activate
) {
2262 CWARN("lov idx %d was administratively disabled, skip quotacheck on it.\n",
2267 if (!lov
->lov_tgts
[i
]->ltd_active
) {
2268 CERROR("lov idx %d inactive\n", i
);
2274 for (i
= 0; i
< lov
->desc
.ld_tgt_count
; i
++) {
2277 if (!lov
->lov_tgts
[i
] || !lov
->lov_tgts
[i
]->ltd_activate
)
2280 err
= obd_quotacheck(lov
->lov_tgts
[i
]->ltd_exp
, oqctl
);
2291 static struct obd_ops lov_obd_ops
= {
2292 .owner
= THIS_MODULE
,
2294 .precleanup
= lov_precleanup
,
2295 .cleanup
= lov_cleanup
,
2296 /*.process_config = lov_process_config,*/
2297 .connect
= lov_connect
,
2298 .disconnect
= lov_disconnect
,
2299 .statfs
= lov_statfs
,
2300 .statfs_async
= lov_statfs_async
,
2301 .packmd
= lov_packmd
,
2302 .unpackmd
= lov_unpackmd
,
2303 .create
= lov_create
,
2304 .destroy
= lov_destroy
,
2305 .getattr_async
= lov_getattr_async
,
2306 .setattr_async
= lov_setattr_async
,
2307 .adjust_kms
= lov_adjust_kms
,
2308 .find_cbdata
= lov_find_cbdata
,
2309 .iocontrol
= lov_iocontrol
,
2310 .get_info
= lov_get_info
,
2311 .set_info_async
= lov_set_info_async
,
2312 .notify
= lov_notify
,
2313 .pool_new
= lov_pool_new
,
2314 .pool_rem
= lov_pool_remove
,
2315 .pool_add
= lov_pool_add
,
2316 .pool_del
= lov_pool_del
,
2317 .getref
= lov_getref
,
2318 .putref
= lov_putref
,
2319 .quotactl
= lov_quotactl
,
2320 .quotacheck
= lov_quotacheck
,
2323 struct kmem_cache
*lov_oinfo_slab
;
2325 static int __init
lov_init(void)
2327 struct lprocfs_static_vars lvars
= { NULL
};
2330 /* print an address of _any_ initialized kernel symbol from this
2331 * module, to allow debugging with gdb that doesn't support data
2332 * symbols from modules.
2334 CDEBUG(D_INFO
, "Lustre LOV module (%p).\n", &lov_caches
);
2336 rc
= lu_kmem_init(lov_caches
);
2340 lov_oinfo_slab
= kmem_cache_create("lov_oinfo",
2341 sizeof(struct lov_oinfo
),
2342 0, SLAB_HWCACHE_ALIGN
, NULL
);
2343 if (!lov_oinfo_slab
) {
2344 lu_kmem_fini(lov_caches
);
2347 lprocfs_lov_init_vars(&lvars
);
2349 rc
= class_register_type(&lov_obd_ops
, NULL
,
2350 LUSTRE_LOV_NAME
, &lov_device_type
);
2353 kmem_cache_destroy(lov_oinfo_slab
);
2354 lu_kmem_fini(lov_caches
);
2360 static void /*__exit*/ lov_exit(void)
2362 class_unregister_type(LUSTRE_LOV_NAME
);
2363 kmem_cache_destroy(lov_oinfo_slab
);
2365 lu_kmem_fini(lov_caches
);
2368 MODULE_AUTHOR("OpenSFS, Inc. <http://www.lustre.org/>");
2369 MODULE_DESCRIPTION("Lustre Logical Object Volume");
2370 MODULE_LICENSE("GPL");
2371 MODULE_VERSION(LUSTRE_VERSION_STRING
);
2373 module_init(lov_init
);
2374 module_exit(lov_exit
);